xref: /freebsd/contrib/llvm-project/clang/lib/Sema/SemaExprObjC.cpp (revision 5b56413d04e608379c9a306373554a8e4d321bc0)
1 //===--- SemaExprObjC.cpp - Semantic Analysis for ObjC Expressions --------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 //  This file implements semantic analysis for Objective-C expressions.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/DeclObjC.h"
15 #include "clang/AST/ExprObjC.h"
16 #include "clang/AST/StmtVisitor.h"
17 #include "clang/AST/TypeLoc.h"
18 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
19 #include "clang/Basic/Builtins.h"
20 #include "clang/Edit/Commit.h"
21 #include "clang/Edit/Rewriters.h"
22 #include "clang/Lex/Preprocessor.h"
23 #include "clang/Sema/Initialization.h"
24 #include "clang/Sema/Lookup.h"
25 #include "clang/Sema/Scope.h"
26 #include "clang/Sema/ScopeInfo.h"
27 #include "clang/Sema/SemaInternal.h"
28 #include "llvm/ADT/SmallString.h"
29 #include "llvm/Support/ConvertUTF.h"
30 #include <optional>
31 
32 using namespace clang;
33 using namespace sema;
34 using llvm::ArrayRef;
35 
36 ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
37                                         ArrayRef<Expr *> Strings) {
38   // Most ObjC strings are formed out of a single piece.  However, we *can*
39   // have strings formed out of multiple @ strings with multiple pptokens in
40   // each one, e.g. @"foo" "bar" @"baz" "qux"   which need to be turned into one
41   // StringLiteral for ObjCStringLiteral to hold onto.
42   StringLiteral *S = cast<StringLiteral>(Strings[0]);
43 
44   // If we have a multi-part string, merge it all together.
45   if (Strings.size() != 1) {
46     // Concatenate objc strings.
47     SmallString<128> StrBuf;
48     SmallVector<SourceLocation, 8> StrLocs;
49 
50     for (Expr *E : Strings) {
51       S = cast<StringLiteral>(E);
52 
53       // ObjC strings can't be wide or UTF.
54       if (!S->isOrdinary()) {
55         Diag(S->getBeginLoc(), diag::err_cfstring_literal_not_string_constant)
56             << S->getSourceRange();
57         return true;
58       }
59 
60       // Append the string.
61       StrBuf += S->getString();
62 
63       // Get the locations of the string tokens.
64       StrLocs.append(S->tokloc_begin(), S->tokloc_end());
65     }
66 
67     // Create the aggregate string with the appropriate content and location
68     // information.
69     const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
70     assert(CAT && "String literal not of constant array type!");
71     QualType StrTy = Context.getConstantArrayType(
72         CAT->getElementType(), llvm::APInt(32, StrBuf.size() + 1), nullptr,
73         CAT->getSizeModifier(), CAT->getIndexTypeCVRQualifiers());
74     S = StringLiteral::Create(Context, StrBuf, StringLiteralKind::Ordinary,
75                               /*Pascal=*/false, StrTy, &StrLocs[0],
76                               StrLocs.size());
77   }
78 
79   return BuildObjCStringLiteral(AtLocs[0], S);
80 }
81 
82 ExprResult Sema::BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S){
83   // Verify that this composite string is acceptable for ObjC strings.
84   if (CheckObjCString(S))
85     return true;
86 
87   // Initialize the constant string interface lazily. This assumes
88   // the NSString interface is seen in this translation unit. Note: We
89   // don't use NSConstantString, since the runtime team considers this
90   // interface private (even though it appears in the header files).
91   QualType Ty = Context.getObjCConstantStringInterface();
92   if (!Ty.isNull()) {
93     Ty = Context.getObjCObjectPointerType(Ty);
94   } else if (getLangOpts().NoConstantCFStrings) {
95     IdentifierInfo *NSIdent=nullptr;
96     std::string StringClass(getLangOpts().ObjCConstantStringClass);
97 
98     if (StringClass.empty())
99       NSIdent = &Context.Idents.get("NSConstantString");
100     else
101       NSIdent = &Context.Idents.get(StringClass);
102 
103     NamedDecl *IF = LookupSingleName(TUScope, NSIdent, AtLoc,
104                                      LookupOrdinaryName);
105     if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) {
106       Context.setObjCConstantStringInterface(StrIF);
107       Ty = Context.getObjCConstantStringInterface();
108       Ty = Context.getObjCObjectPointerType(Ty);
109     } else {
110       // If there is no NSConstantString interface defined then treat this
111       // as error and recover from it.
112       Diag(S->getBeginLoc(), diag::err_no_nsconstant_string_class)
113           << NSIdent << S->getSourceRange();
114       Ty = Context.getObjCIdType();
115     }
116   } else {
117     IdentifierInfo *NSIdent = NSAPIObj->getNSClassId(NSAPI::ClassId_NSString);
118     NamedDecl *IF = LookupSingleName(TUScope, NSIdent, AtLoc,
119                                      LookupOrdinaryName);
120     if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) {
121       Context.setObjCConstantStringInterface(StrIF);
122       Ty = Context.getObjCConstantStringInterface();
123       Ty = Context.getObjCObjectPointerType(Ty);
124     } else {
125       // If there is no NSString interface defined, implicitly declare
126       // a @class NSString; and use that instead. This is to make sure
127       // type of an NSString literal is represented correctly, instead of
128       // being an 'id' type.
129       Ty = Context.getObjCNSStringType();
130       if (Ty.isNull()) {
131         ObjCInterfaceDecl *NSStringIDecl =
132           ObjCInterfaceDecl::Create (Context,
133                                      Context.getTranslationUnitDecl(),
134                                      SourceLocation(), NSIdent,
135                                      nullptr, nullptr, SourceLocation());
136         Ty = Context.getObjCInterfaceType(NSStringIDecl);
137         Context.setObjCNSStringType(Ty);
138       }
139       Ty = Context.getObjCObjectPointerType(Ty);
140     }
141   }
142 
143   return new (Context) ObjCStringLiteral(S, Ty, AtLoc);
144 }
145 
146 /// Emits an error if the given method does not exist, or if the return
147 /// type is not an Objective-C object.
148 static bool validateBoxingMethod(Sema &S, SourceLocation Loc,
149                                  const ObjCInterfaceDecl *Class,
150                                  Selector Sel, const ObjCMethodDecl *Method) {
151   if (!Method) {
152     // FIXME: Is there a better way to avoid quotes than using getName()?
153     S.Diag(Loc, diag::err_undeclared_boxing_method) << Sel << Class->getName();
154     return false;
155   }
156 
157   // Make sure the return type is reasonable.
158   QualType ReturnType = Method->getReturnType();
159   if (!ReturnType->isObjCObjectPointerType()) {
160     S.Diag(Loc, diag::err_objc_literal_method_sig)
161       << Sel;
162     S.Diag(Method->getLocation(), diag::note_objc_literal_method_return)
163       << ReturnType;
164     return false;
165   }
166 
167   return true;
168 }
169 
170 /// Maps ObjCLiteralKind to NSClassIdKindKind
171 static NSAPI::NSClassIdKindKind ClassKindFromLiteralKind(
172                                             Sema::ObjCLiteralKind LiteralKind) {
173   switch (LiteralKind) {
174     case Sema::LK_Array:
175       return NSAPI::ClassId_NSArray;
176     case Sema::LK_Dictionary:
177       return NSAPI::ClassId_NSDictionary;
178     case Sema::LK_Numeric:
179       return NSAPI::ClassId_NSNumber;
180     case Sema::LK_String:
181       return NSAPI::ClassId_NSString;
182     case Sema::LK_Boxed:
183       return NSAPI::ClassId_NSValue;
184 
185     // there is no corresponding matching
186     // between LK_None/LK_Block and NSClassIdKindKind
187     case Sema::LK_Block:
188     case Sema::LK_None:
189       break;
190   }
191   llvm_unreachable("LiteralKind can't be converted into a ClassKind");
192 }
193 
194 /// Validates ObjCInterfaceDecl availability.
195 /// ObjCInterfaceDecl, used to create ObjC literals, should be defined
196 /// if clang not in a debugger mode.
197 static bool ValidateObjCLiteralInterfaceDecl(Sema &S, ObjCInterfaceDecl *Decl,
198                                             SourceLocation Loc,
199                                             Sema::ObjCLiteralKind LiteralKind) {
200   if (!Decl) {
201     NSAPI::NSClassIdKindKind Kind = ClassKindFromLiteralKind(LiteralKind);
202     IdentifierInfo *II = S.NSAPIObj->getNSClassId(Kind);
203     S.Diag(Loc, diag::err_undeclared_objc_literal_class)
204       << II->getName() << LiteralKind;
205     return false;
206   } else if (!Decl->hasDefinition() && !S.getLangOpts().DebuggerObjCLiteral) {
207     S.Diag(Loc, diag::err_undeclared_objc_literal_class)
208       << Decl->getName() << LiteralKind;
209     S.Diag(Decl->getLocation(), diag::note_forward_class);
210     return false;
211   }
212 
213   return true;
214 }
215 
216 /// Looks up ObjCInterfaceDecl of a given NSClassIdKindKind.
217 /// Used to create ObjC literals, such as NSDictionary (@{}),
218 /// NSArray (@[]) and Boxed Expressions (@())
219 static ObjCInterfaceDecl *LookupObjCInterfaceDeclForLiteral(Sema &S,
220                                             SourceLocation Loc,
221                                             Sema::ObjCLiteralKind LiteralKind) {
222   NSAPI::NSClassIdKindKind ClassKind = ClassKindFromLiteralKind(LiteralKind);
223   IdentifierInfo *II = S.NSAPIObj->getNSClassId(ClassKind);
224   NamedDecl *IF = S.LookupSingleName(S.TUScope, II, Loc,
225                                      Sema::LookupOrdinaryName);
226   ObjCInterfaceDecl *ID = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
227   if (!ID && S.getLangOpts().DebuggerObjCLiteral) {
228     ASTContext &Context = S.Context;
229     TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
230     ID = ObjCInterfaceDecl::Create (Context, TU, SourceLocation(), II,
231                                     nullptr, nullptr, SourceLocation());
232   }
233 
234   if (!ValidateObjCLiteralInterfaceDecl(S, ID, Loc, LiteralKind)) {
235     ID = nullptr;
236   }
237 
238   return ID;
239 }
240 
241 /// Retrieve the NSNumber factory method that should be used to create
242 /// an Objective-C literal for the given type.
243 static ObjCMethodDecl *getNSNumberFactoryMethod(Sema &S, SourceLocation Loc,
244                                                 QualType NumberType,
245                                                 bool isLiteral = false,
246                                                 SourceRange R = SourceRange()) {
247   std::optional<NSAPI::NSNumberLiteralMethodKind> Kind =
248       S.NSAPIObj->getNSNumberFactoryMethodKind(NumberType);
249 
250   if (!Kind) {
251     if (isLiteral) {
252       S.Diag(Loc, diag::err_invalid_nsnumber_type)
253         << NumberType << R;
254     }
255     return nullptr;
256   }
257 
258   // If we already looked up this method, we're done.
259   if (S.NSNumberLiteralMethods[*Kind])
260     return S.NSNumberLiteralMethods[*Kind];
261 
262   Selector Sel = S.NSAPIObj->getNSNumberLiteralSelector(*Kind,
263                                                         /*Instance=*/false);
264 
265   ASTContext &CX = S.Context;
266 
267   // Look up the NSNumber class, if we haven't done so already. It's cached
268   // in the Sema instance.
269   if (!S.NSNumberDecl) {
270     S.NSNumberDecl = LookupObjCInterfaceDeclForLiteral(S, Loc,
271                                                        Sema::LK_Numeric);
272     if (!S.NSNumberDecl) {
273       return nullptr;
274     }
275   }
276 
277   if (S.NSNumberPointer.isNull()) {
278     // generate the pointer to NSNumber type.
279     QualType NSNumberObject = CX.getObjCInterfaceType(S.NSNumberDecl);
280     S.NSNumberPointer = CX.getObjCObjectPointerType(NSNumberObject);
281   }
282 
283   // Look for the appropriate method within NSNumber.
284   ObjCMethodDecl *Method = S.NSNumberDecl->lookupClassMethod(Sel);
285   if (!Method && S.getLangOpts().DebuggerObjCLiteral) {
286     // create a stub definition this NSNumber factory method.
287     TypeSourceInfo *ReturnTInfo = nullptr;
288     Method = ObjCMethodDecl::Create(
289         CX, SourceLocation(), SourceLocation(), Sel, S.NSNumberPointer,
290         ReturnTInfo, S.NSNumberDecl,
291         /*isInstance=*/false, /*isVariadic=*/false,
292         /*isPropertyAccessor=*/false,
293         /*isSynthesizedAccessorStub=*/false,
294         /*isImplicitlyDeclared=*/true,
295         /*isDefined=*/false, ObjCImplementationControl::Required,
296         /*HasRelatedResultType=*/false);
297     ParmVarDecl *value = ParmVarDecl::Create(S.Context, Method,
298                                              SourceLocation(), SourceLocation(),
299                                              &CX.Idents.get("value"),
300                                              NumberType, /*TInfo=*/nullptr,
301                                              SC_None, nullptr);
302     Method->setMethodParams(S.Context, value, std::nullopt);
303   }
304 
305   if (!validateBoxingMethod(S, Loc, S.NSNumberDecl, Sel, Method))
306     return nullptr;
307 
308   // Note: if the parameter type is out-of-line, we'll catch it later in the
309   // implicit conversion.
310 
311   S.NSNumberLiteralMethods[*Kind] = Method;
312   return Method;
313 }
314 
315 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
316 /// numeric literal expression. Type of the expression will be "NSNumber *".
317 ExprResult Sema::BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number) {
318   // Determine the type of the literal.
319   QualType NumberType = Number->getType();
320   if (CharacterLiteral *Char = dyn_cast<CharacterLiteral>(Number)) {
321     // In C, character literals have type 'int'. That's not the type we want
322     // to use to determine the Objective-c literal kind.
323     switch (Char->getKind()) {
324     case CharacterLiteralKind::Ascii:
325     case CharacterLiteralKind::UTF8:
326       NumberType = Context.CharTy;
327       break;
328 
329     case CharacterLiteralKind::Wide:
330       NumberType = Context.getWideCharType();
331       break;
332 
333     case CharacterLiteralKind::UTF16:
334       NumberType = Context.Char16Ty;
335       break;
336 
337     case CharacterLiteralKind::UTF32:
338       NumberType = Context.Char32Ty;
339       break;
340     }
341   }
342 
343   // Look for the appropriate method within NSNumber.
344   // Construct the literal.
345   SourceRange NR(Number->getSourceRange());
346   ObjCMethodDecl *Method = getNSNumberFactoryMethod(*this, AtLoc, NumberType,
347                                                     true, NR);
348   if (!Method)
349     return ExprError();
350 
351   // Convert the number to the type that the parameter expects.
352   ParmVarDecl *ParamDecl = Method->parameters()[0];
353   InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
354                                                                     ParamDecl);
355   ExprResult ConvertedNumber = PerformCopyInitialization(Entity,
356                                                          SourceLocation(),
357                                                          Number);
358   if (ConvertedNumber.isInvalid())
359     return ExprError();
360   Number = ConvertedNumber.get();
361 
362   // Use the effective source range of the literal, including the leading '@'.
363   return MaybeBindToTemporary(
364            new (Context) ObjCBoxedExpr(Number, NSNumberPointer, Method,
365                                        SourceRange(AtLoc, NR.getEnd())));
366 }
367 
368 ExprResult Sema::ActOnObjCBoolLiteral(SourceLocation AtLoc,
369                                       SourceLocation ValueLoc,
370                                       bool Value) {
371   ExprResult Inner;
372   if (getLangOpts().CPlusPlus) {
373     Inner = ActOnCXXBoolLiteral(ValueLoc, Value? tok::kw_true : tok::kw_false);
374   } else {
375     // C doesn't actually have a way to represent literal values of type
376     // _Bool. So, we'll use 0/1 and implicit cast to _Bool.
377     Inner = ActOnIntegerConstant(ValueLoc, Value? 1 : 0);
378     Inner = ImpCastExprToType(Inner.get(), Context.BoolTy,
379                               CK_IntegralToBoolean);
380   }
381 
382   return BuildObjCNumericLiteral(AtLoc, Inner.get());
383 }
384 
385 /// Check that the given expression is a valid element of an Objective-C
386 /// collection literal.
387 static ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element,
388                                                     QualType T,
389                                                     bool ArrayLiteral = false) {
390   // If the expression is type-dependent, there's nothing for us to do.
391   if (Element->isTypeDependent())
392     return Element;
393 
394   ExprResult Result = S.CheckPlaceholderExpr(Element);
395   if (Result.isInvalid())
396     return ExprError();
397   Element = Result.get();
398 
399   // In C++, check for an implicit conversion to an Objective-C object pointer
400   // type.
401   if (S.getLangOpts().CPlusPlus && Element->getType()->isRecordType()) {
402     InitializedEntity Entity
403       = InitializedEntity::InitializeParameter(S.Context, T,
404                                                /*Consumed=*/false);
405     InitializationKind Kind = InitializationKind::CreateCopy(
406         Element->getBeginLoc(), SourceLocation());
407     InitializationSequence Seq(S, Entity, Kind, Element);
408     if (!Seq.Failed())
409       return Seq.Perform(S, Entity, Kind, Element);
410   }
411 
412   Expr *OrigElement = Element;
413 
414   // Perform lvalue-to-rvalue conversion.
415   Result = S.DefaultLvalueConversion(Element);
416   if (Result.isInvalid())
417     return ExprError();
418   Element = Result.get();
419 
420   // Make sure that we have an Objective-C pointer type or block.
421   if (!Element->getType()->isObjCObjectPointerType() &&
422       !Element->getType()->isBlockPointerType()) {
423     bool Recovered = false;
424 
425     // If this is potentially an Objective-C numeric literal, add the '@'.
426     if (isa<IntegerLiteral>(OrigElement) ||
427         isa<CharacterLiteral>(OrigElement) ||
428         isa<FloatingLiteral>(OrigElement) ||
429         isa<ObjCBoolLiteralExpr>(OrigElement) ||
430         isa<CXXBoolLiteralExpr>(OrigElement)) {
431       if (S.NSAPIObj->getNSNumberFactoryMethodKind(OrigElement->getType())) {
432         int Which = isa<CharacterLiteral>(OrigElement) ? 1
433                   : (isa<CXXBoolLiteralExpr>(OrigElement) ||
434                      isa<ObjCBoolLiteralExpr>(OrigElement)) ? 2
435                   : 3;
436 
437         S.Diag(OrigElement->getBeginLoc(), diag::err_box_literal_collection)
438             << Which << OrigElement->getSourceRange()
439             << FixItHint::CreateInsertion(OrigElement->getBeginLoc(), "@");
440 
441         Result =
442             S.BuildObjCNumericLiteral(OrigElement->getBeginLoc(), OrigElement);
443         if (Result.isInvalid())
444           return ExprError();
445 
446         Element = Result.get();
447         Recovered = true;
448       }
449     }
450     // If this is potentially an Objective-C string literal, add the '@'.
451     else if (StringLiteral *String = dyn_cast<StringLiteral>(OrigElement)) {
452       if (String->isOrdinary()) {
453         S.Diag(OrigElement->getBeginLoc(), diag::err_box_literal_collection)
454             << 0 << OrigElement->getSourceRange()
455             << FixItHint::CreateInsertion(OrigElement->getBeginLoc(), "@");
456 
457         Result = S.BuildObjCStringLiteral(OrigElement->getBeginLoc(), String);
458         if (Result.isInvalid())
459           return ExprError();
460 
461         Element = Result.get();
462         Recovered = true;
463       }
464     }
465 
466     if (!Recovered) {
467       S.Diag(Element->getBeginLoc(), diag::err_invalid_collection_element)
468           << Element->getType();
469       return ExprError();
470     }
471   }
472   if (ArrayLiteral)
473     if (ObjCStringLiteral *getString =
474           dyn_cast<ObjCStringLiteral>(OrigElement)) {
475       if (StringLiteral *SL = getString->getString()) {
476         unsigned numConcat = SL->getNumConcatenated();
477         if (numConcat > 1) {
478           // Only warn if the concatenated string doesn't come from a macro.
479           bool hasMacro = false;
480           for (unsigned i = 0; i < numConcat ; ++i)
481             if (SL->getStrTokenLoc(i).isMacroID()) {
482               hasMacro = true;
483               break;
484             }
485           if (!hasMacro)
486             S.Diag(Element->getBeginLoc(),
487                    diag::warn_concatenated_nsarray_literal)
488                 << Element->getType();
489         }
490       }
491     }
492 
493   // Make sure that the element has the type that the container factory
494   // function expects.
495   return S.PerformCopyInitialization(
496       InitializedEntity::InitializeParameter(S.Context, T,
497                                              /*Consumed=*/false),
498       Element->getBeginLoc(), Element);
499 }
500 
501 ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
502   if (ValueExpr->isTypeDependent()) {
503     ObjCBoxedExpr *BoxedExpr =
504       new (Context) ObjCBoxedExpr(ValueExpr, Context.DependentTy, nullptr, SR);
505     return BoxedExpr;
506   }
507   ObjCMethodDecl *BoxingMethod = nullptr;
508   QualType BoxedType;
509   // Convert the expression to an RValue, so we can check for pointer types...
510   ExprResult RValue = DefaultFunctionArrayLvalueConversion(ValueExpr);
511   if (RValue.isInvalid()) {
512     return ExprError();
513   }
514   SourceLocation Loc = SR.getBegin();
515   ValueExpr = RValue.get();
516   QualType ValueType(ValueExpr->getType());
517   if (const PointerType *PT = ValueType->getAs<PointerType>()) {
518     QualType PointeeType = PT->getPointeeType();
519     if (Context.hasSameUnqualifiedType(PointeeType, Context.CharTy)) {
520 
521       if (!NSStringDecl) {
522         NSStringDecl = LookupObjCInterfaceDeclForLiteral(*this, Loc,
523                                                          Sema::LK_String);
524         if (!NSStringDecl) {
525           return ExprError();
526         }
527         QualType NSStringObject = Context.getObjCInterfaceType(NSStringDecl);
528         NSStringPointer = Context.getObjCObjectPointerType(NSStringObject);
529       }
530 
531       // The boxed expression can be emitted as a compile time constant if it is
532       // a string literal whose character encoding is compatible with UTF-8.
533       if (auto *CE = dyn_cast<ImplicitCastExpr>(ValueExpr))
534         if (CE->getCastKind() == CK_ArrayToPointerDecay)
535           if (auto *SL =
536                   dyn_cast<StringLiteral>(CE->getSubExpr()->IgnoreParens())) {
537             assert((SL->isOrdinary() || SL->isUTF8()) &&
538                    "unexpected character encoding");
539             StringRef Str = SL->getString();
540             const llvm::UTF8 *StrBegin = Str.bytes_begin();
541             const llvm::UTF8 *StrEnd = Str.bytes_end();
542             // Check that this is a valid UTF-8 string.
543             if (llvm::isLegalUTF8String(&StrBegin, StrEnd)) {
544               BoxedType = Context.getAttributedType(
545                   AttributedType::getNullabilityAttrKind(
546                       NullabilityKind::NonNull),
547                   NSStringPointer, NSStringPointer);
548               return new (Context) ObjCBoxedExpr(CE, BoxedType, nullptr, SR);
549             }
550 
551             Diag(SL->getBeginLoc(), diag::warn_objc_boxing_invalid_utf8_string)
552                 << NSStringPointer << SL->getSourceRange();
553           }
554 
555       if (!StringWithUTF8StringMethod) {
556         IdentifierInfo *II = &Context.Idents.get("stringWithUTF8String");
557         Selector stringWithUTF8String = Context.Selectors.getUnarySelector(II);
558 
559         // Look for the appropriate method within NSString.
560         BoxingMethod = NSStringDecl->lookupClassMethod(stringWithUTF8String);
561         if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) {
562           // Debugger needs to work even if NSString hasn't been defined.
563           TypeSourceInfo *ReturnTInfo = nullptr;
564           ObjCMethodDecl *M = ObjCMethodDecl::Create(
565               Context, SourceLocation(), SourceLocation(), stringWithUTF8String,
566               NSStringPointer, ReturnTInfo, NSStringDecl,
567               /*isInstance=*/false, /*isVariadic=*/false,
568               /*isPropertyAccessor=*/false,
569               /*isSynthesizedAccessorStub=*/false,
570               /*isImplicitlyDeclared=*/true,
571               /*isDefined=*/false, ObjCImplementationControl::Required,
572               /*HasRelatedResultType=*/false);
573           QualType ConstCharType = Context.CharTy.withConst();
574           ParmVarDecl *value =
575             ParmVarDecl::Create(Context, M,
576                                 SourceLocation(), SourceLocation(),
577                                 &Context.Idents.get("value"),
578                                 Context.getPointerType(ConstCharType),
579                                 /*TInfo=*/nullptr,
580                                 SC_None, nullptr);
581           M->setMethodParams(Context, value, std::nullopt);
582           BoxingMethod = M;
583         }
584 
585         if (!validateBoxingMethod(*this, Loc, NSStringDecl,
586                                   stringWithUTF8String, BoxingMethod))
587            return ExprError();
588 
589         StringWithUTF8StringMethod = BoxingMethod;
590       }
591 
592       BoxingMethod = StringWithUTF8StringMethod;
593       BoxedType = NSStringPointer;
594       // Transfer the nullability from method's return type.
595       std::optional<NullabilityKind> Nullability =
596           BoxingMethod->getReturnType()->getNullability();
597       if (Nullability)
598         BoxedType = Context.getAttributedType(
599             AttributedType::getNullabilityAttrKind(*Nullability), BoxedType,
600             BoxedType);
601     }
602   } else if (ValueType->isBuiltinType()) {
603     // The other types we support are numeric, char and BOOL/bool. We could also
604     // provide limited support for structure types, such as NSRange, NSRect, and
605     // NSSize. See NSValue (NSValueGeometryExtensions) in <Foundation/NSGeometry.h>
606     // for more details.
607 
608     // Check for a top-level character literal.
609     if (const CharacterLiteral *Char =
610         dyn_cast<CharacterLiteral>(ValueExpr->IgnoreParens())) {
611       // In C, character literals have type 'int'. That's not the type we want
612       // to use to determine the Objective-c literal kind.
613       switch (Char->getKind()) {
614       case CharacterLiteralKind::Ascii:
615       case CharacterLiteralKind::UTF8:
616         ValueType = Context.CharTy;
617         break;
618 
619       case CharacterLiteralKind::Wide:
620         ValueType = Context.getWideCharType();
621         break;
622 
623       case CharacterLiteralKind::UTF16:
624         ValueType = Context.Char16Ty;
625         break;
626 
627       case CharacterLiteralKind::UTF32:
628         ValueType = Context.Char32Ty;
629         break;
630       }
631     }
632     // FIXME:  Do I need to do anything special with BoolTy expressions?
633 
634     // Look for the appropriate method within NSNumber.
635     BoxingMethod = getNSNumberFactoryMethod(*this, Loc, ValueType);
636     BoxedType = NSNumberPointer;
637   } else if (const EnumType *ET = ValueType->getAs<EnumType>()) {
638     if (!ET->getDecl()->isComplete()) {
639       Diag(Loc, diag::err_objc_incomplete_boxed_expression_type)
640         << ValueType << ValueExpr->getSourceRange();
641       return ExprError();
642     }
643 
644     BoxingMethod = getNSNumberFactoryMethod(*this, Loc,
645                                             ET->getDecl()->getIntegerType());
646     BoxedType = NSNumberPointer;
647   } else if (ValueType->isObjCBoxableRecordType()) {
648     // Support for structure types, that marked as objc_boxable
649     // struct __attribute__((objc_boxable)) s { ... };
650 
651     // Look up the NSValue class, if we haven't done so already. It's cached
652     // in the Sema instance.
653     if (!NSValueDecl) {
654       NSValueDecl = LookupObjCInterfaceDeclForLiteral(*this, Loc,
655                                                       Sema::LK_Boxed);
656       if (!NSValueDecl) {
657         return ExprError();
658       }
659 
660       // generate the pointer to NSValue type.
661       QualType NSValueObject = Context.getObjCInterfaceType(NSValueDecl);
662       NSValuePointer = Context.getObjCObjectPointerType(NSValueObject);
663     }
664 
665     if (!ValueWithBytesObjCTypeMethod) {
666       IdentifierInfo *II[] = {
667         &Context.Idents.get("valueWithBytes"),
668         &Context.Idents.get("objCType")
669       };
670       Selector ValueWithBytesObjCType = Context.Selectors.getSelector(2, II);
671 
672       // Look for the appropriate method within NSValue.
673       BoxingMethod = NSValueDecl->lookupClassMethod(ValueWithBytesObjCType);
674       if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) {
675         // Debugger needs to work even if NSValue hasn't been defined.
676         TypeSourceInfo *ReturnTInfo = nullptr;
677         ObjCMethodDecl *M = ObjCMethodDecl::Create(
678             Context, SourceLocation(), SourceLocation(), ValueWithBytesObjCType,
679             NSValuePointer, ReturnTInfo, NSValueDecl,
680             /*isInstance=*/false,
681             /*isVariadic=*/false,
682             /*isPropertyAccessor=*/false,
683             /*isSynthesizedAccessorStub=*/false,
684             /*isImplicitlyDeclared=*/true,
685             /*isDefined=*/false, ObjCImplementationControl::Required,
686             /*HasRelatedResultType=*/false);
687 
688         SmallVector<ParmVarDecl *, 2> Params;
689 
690         ParmVarDecl *bytes =
691         ParmVarDecl::Create(Context, M,
692                             SourceLocation(), SourceLocation(),
693                             &Context.Idents.get("bytes"),
694                             Context.VoidPtrTy.withConst(),
695                             /*TInfo=*/nullptr,
696                             SC_None, nullptr);
697         Params.push_back(bytes);
698 
699         QualType ConstCharType = Context.CharTy.withConst();
700         ParmVarDecl *type =
701         ParmVarDecl::Create(Context, M,
702                             SourceLocation(), SourceLocation(),
703                             &Context.Idents.get("type"),
704                             Context.getPointerType(ConstCharType),
705                             /*TInfo=*/nullptr,
706                             SC_None, nullptr);
707         Params.push_back(type);
708 
709         M->setMethodParams(Context, Params, std::nullopt);
710         BoxingMethod = M;
711       }
712 
713       if (!validateBoxingMethod(*this, Loc, NSValueDecl,
714                                 ValueWithBytesObjCType, BoxingMethod))
715         return ExprError();
716 
717       ValueWithBytesObjCTypeMethod = BoxingMethod;
718     }
719 
720     if (!ValueType.isTriviallyCopyableType(Context)) {
721       Diag(Loc, diag::err_objc_non_trivially_copyable_boxed_expression_type)
722         << ValueType << ValueExpr->getSourceRange();
723       return ExprError();
724     }
725 
726     BoxingMethod = ValueWithBytesObjCTypeMethod;
727     BoxedType = NSValuePointer;
728   }
729 
730   if (!BoxingMethod) {
731     Diag(Loc, diag::err_objc_illegal_boxed_expression_type)
732       << ValueType << ValueExpr->getSourceRange();
733     return ExprError();
734   }
735 
736   DiagnoseUseOfDecl(BoxingMethod, Loc);
737 
738   ExprResult ConvertedValueExpr;
739   if (ValueType->isObjCBoxableRecordType()) {
740     InitializedEntity IE = InitializedEntity::InitializeTemporary(ValueType);
741     ConvertedValueExpr = PerformCopyInitialization(IE, ValueExpr->getExprLoc(),
742                                                    ValueExpr);
743   } else {
744     // Convert the expression to the type that the parameter requires.
745     ParmVarDecl *ParamDecl = BoxingMethod->parameters()[0];
746     InitializedEntity IE = InitializedEntity::InitializeParameter(Context,
747                                                                   ParamDecl);
748     ConvertedValueExpr = PerformCopyInitialization(IE, SourceLocation(),
749                                                    ValueExpr);
750   }
751 
752   if (ConvertedValueExpr.isInvalid())
753     return ExprError();
754   ValueExpr = ConvertedValueExpr.get();
755 
756   ObjCBoxedExpr *BoxedExpr =
757     new (Context) ObjCBoxedExpr(ValueExpr, BoxedType,
758                                       BoxingMethod, SR);
759   return MaybeBindToTemporary(BoxedExpr);
760 }
761 
762 /// Build an ObjC subscript pseudo-object expression, given that
763 /// that's supported by the runtime.
764 ExprResult Sema::BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
765                                         Expr *IndexExpr,
766                                         ObjCMethodDecl *getterMethod,
767                                         ObjCMethodDecl *setterMethod) {
768   assert(!LangOpts.isSubscriptPointerArithmetic());
769 
770   // We can't get dependent types here; our callers should have
771   // filtered them out.
772   assert((!BaseExpr->isTypeDependent() && !IndexExpr->isTypeDependent()) &&
773          "base or index cannot have dependent type here");
774 
775   // Filter out placeholders in the index.  In theory, overloads could
776   // be preserved here, although that might not actually work correctly.
777   ExprResult Result = CheckPlaceholderExpr(IndexExpr);
778   if (Result.isInvalid())
779     return ExprError();
780   IndexExpr = Result.get();
781 
782   // Perform lvalue-to-rvalue conversion on the base.
783   Result = DefaultLvalueConversion(BaseExpr);
784   if (Result.isInvalid())
785     return ExprError();
786   BaseExpr = Result.get();
787 
788   // Build the pseudo-object expression.
789   return new (Context) ObjCSubscriptRefExpr(
790       BaseExpr, IndexExpr, Context.PseudoObjectTy, VK_LValue, OK_ObjCSubscript,
791       getterMethod, setterMethod, RB);
792 }
793 
794 ExprResult Sema::BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements) {
795   SourceLocation Loc = SR.getBegin();
796 
797   if (!NSArrayDecl) {
798     NSArrayDecl = LookupObjCInterfaceDeclForLiteral(*this, Loc,
799                                                     Sema::LK_Array);
800     if (!NSArrayDecl) {
801       return ExprError();
802     }
803   }
804 
805   // Find the arrayWithObjects:count: method, if we haven't done so already.
806   QualType IdT = Context.getObjCIdType();
807   if (!ArrayWithObjectsMethod) {
808     Selector
809       Sel = NSAPIObj->getNSArraySelector(NSAPI::NSArr_arrayWithObjectsCount);
810     ObjCMethodDecl *Method = NSArrayDecl->lookupClassMethod(Sel);
811     if (!Method && getLangOpts().DebuggerObjCLiteral) {
812       TypeSourceInfo *ReturnTInfo = nullptr;
813       Method = ObjCMethodDecl::Create(
814           Context, SourceLocation(), SourceLocation(), Sel, IdT, ReturnTInfo,
815           Context.getTranslationUnitDecl(), false /*Instance*/,
816           false /*isVariadic*/,
817           /*isPropertyAccessor=*/false, /*isSynthesizedAccessorStub=*/false,
818           /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
819           ObjCImplementationControl::Required, false);
820       SmallVector<ParmVarDecl *, 2> Params;
821       ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
822                                                  SourceLocation(),
823                                                  SourceLocation(),
824                                                  &Context.Idents.get("objects"),
825                                                  Context.getPointerType(IdT),
826                                                  /*TInfo=*/nullptr,
827                                                  SC_None, nullptr);
828       Params.push_back(objects);
829       ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
830                                              SourceLocation(),
831                                              SourceLocation(),
832                                              &Context.Idents.get("cnt"),
833                                              Context.UnsignedLongTy,
834                                              /*TInfo=*/nullptr, SC_None,
835                                              nullptr);
836       Params.push_back(cnt);
837       Method->setMethodParams(Context, Params, std::nullopt);
838     }
839 
840     if (!validateBoxingMethod(*this, Loc, NSArrayDecl, Sel, Method))
841       return ExprError();
842 
843     // Dig out the type that all elements should be converted to.
844     QualType T = Method->parameters()[0]->getType();
845     const PointerType *PtrT = T->getAs<PointerType>();
846     if (!PtrT ||
847         !Context.hasSameUnqualifiedType(PtrT->getPointeeType(), IdT)) {
848       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
849         << Sel;
850       Diag(Method->parameters()[0]->getLocation(),
851            diag::note_objc_literal_method_param)
852         << 0 << T
853         << Context.getPointerType(IdT.withConst());
854       return ExprError();
855     }
856 
857     // Check that the 'count' parameter is integral.
858     if (!Method->parameters()[1]->getType()->isIntegerType()) {
859       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
860         << Sel;
861       Diag(Method->parameters()[1]->getLocation(),
862            diag::note_objc_literal_method_param)
863         << 1
864         << Method->parameters()[1]->getType()
865         << "integral";
866       return ExprError();
867     }
868 
869     // We've found a good +arrayWithObjects:count: method. Save it!
870     ArrayWithObjectsMethod = Method;
871   }
872 
873   QualType ObjectsType = ArrayWithObjectsMethod->parameters()[0]->getType();
874   QualType RequiredType = ObjectsType->castAs<PointerType>()->getPointeeType();
875 
876   // Check that each of the elements provided is valid in a collection literal,
877   // performing conversions as necessary.
878   Expr **ElementsBuffer = Elements.data();
879   for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
880     ExprResult Converted = CheckObjCCollectionLiteralElement(*this,
881                                                              ElementsBuffer[I],
882                                                              RequiredType, true);
883     if (Converted.isInvalid())
884       return ExprError();
885 
886     ElementsBuffer[I] = Converted.get();
887   }
888 
889   QualType Ty
890     = Context.getObjCObjectPointerType(
891                                     Context.getObjCInterfaceType(NSArrayDecl));
892 
893   return MaybeBindToTemporary(
894            ObjCArrayLiteral::Create(Context, Elements, Ty,
895                                     ArrayWithObjectsMethod, SR));
896 }
897 
898 /// Check for duplicate keys in an ObjC dictionary literal. For instance:
899 ///   NSDictionary *nd = @{ @"foo" : @"bar", @"foo" : @"baz" };
900 static void
901 CheckObjCDictionaryLiteralDuplicateKeys(Sema &S,
902                                         ObjCDictionaryLiteral *Literal) {
903   if (Literal->isValueDependent() || Literal->isTypeDependent())
904     return;
905 
906   // NSNumber has quite relaxed equality semantics (for instance, @YES is
907   // considered equal to @1.0). For now, ignore floating points and just do a
908   // bit-width and sign agnostic integer compare.
909   struct APSIntCompare {
910     bool operator()(const llvm::APSInt &LHS, const llvm::APSInt &RHS) const {
911       return llvm::APSInt::compareValues(LHS, RHS) < 0;
912     }
913   };
914 
915   llvm::DenseMap<StringRef, SourceLocation> StringKeys;
916   std::map<llvm::APSInt, SourceLocation, APSIntCompare> IntegralKeys;
917 
918   auto checkOneKey = [&](auto &Map, const auto &Key, SourceLocation Loc) {
919     auto Pair = Map.insert({Key, Loc});
920     if (!Pair.second) {
921       S.Diag(Loc, diag::warn_nsdictionary_duplicate_key);
922       S.Diag(Pair.first->second, diag::note_nsdictionary_duplicate_key_here);
923     }
924   };
925 
926   for (unsigned Idx = 0, End = Literal->getNumElements(); Idx != End; ++Idx) {
927     Expr *Key = Literal->getKeyValueElement(Idx).Key->IgnoreParenImpCasts();
928 
929     if (auto *StrLit = dyn_cast<ObjCStringLiteral>(Key)) {
930       StringRef Bytes = StrLit->getString()->getBytes();
931       SourceLocation Loc = StrLit->getExprLoc();
932       checkOneKey(StringKeys, Bytes, Loc);
933     }
934 
935     if (auto *BE = dyn_cast<ObjCBoxedExpr>(Key)) {
936       Expr *Boxed = BE->getSubExpr();
937       SourceLocation Loc = BE->getExprLoc();
938 
939       // Check for @("foo").
940       if (auto *Str = dyn_cast<StringLiteral>(Boxed->IgnoreParenImpCasts())) {
941         checkOneKey(StringKeys, Str->getBytes(), Loc);
942         continue;
943       }
944 
945       Expr::EvalResult Result;
946       if (Boxed->EvaluateAsInt(Result, S.getASTContext(),
947                                Expr::SE_AllowSideEffects)) {
948         checkOneKey(IntegralKeys, Result.Val.getInt(), Loc);
949       }
950     }
951   }
952 }
953 
954 ExprResult Sema::BuildObjCDictionaryLiteral(SourceRange SR,
955                               MutableArrayRef<ObjCDictionaryElement> Elements) {
956   SourceLocation Loc = SR.getBegin();
957 
958   if (!NSDictionaryDecl) {
959     NSDictionaryDecl = LookupObjCInterfaceDeclForLiteral(*this, Loc,
960                                                          Sema::LK_Dictionary);
961     if (!NSDictionaryDecl) {
962       return ExprError();
963     }
964   }
965 
966   // Find the dictionaryWithObjects:forKeys:count: method, if we haven't done
967   // so already.
968   QualType IdT = Context.getObjCIdType();
969   if (!DictionaryWithObjectsMethod) {
970     Selector Sel = NSAPIObj->getNSDictionarySelector(
971                                NSAPI::NSDict_dictionaryWithObjectsForKeysCount);
972     ObjCMethodDecl *Method = NSDictionaryDecl->lookupClassMethod(Sel);
973     if (!Method && getLangOpts().DebuggerObjCLiteral) {
974       Method = ObjCMethodDecl::Create(
975           Context, SourceLocation(), SourceLocation(), Sel, IdT,
976           nullptr /*TypeSourceInfo */, Context.getTranslationUnitDecl(),
977           false /*Instance*/, false /*isVariadic*/,
978           /*isPropertyAccessor=*/false,
979           /*isSynthesizedAccessorStub=*/false,
980           /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
981           ObjCImplementationControl::Required, false);
982       SmallVector<ParmVarDecl *, 3> Params;
983       ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
984                                                  SourceLocation(),
985                                                  SourceLocation(),
986                                                  &Context.Idents.get("objects"),
987                                                  Context.getPointerType(IdT),
988                                                  /*TInfo=*/nullptr, SC_None,
989                                                  nullptr);
990       Params.push_back(objects);
991       ParmVarDecl *keys = ParmVarDecl::Create(Context, Method,
992                                               SourceLocation(),
993                                               SourceLocation(),
994                                               &Context.Idents.get("keys"),
995                                               Context.getPointerType(IdT),
996                                               /*TInfo=*/nullptr, SC_None,
997                                               nullptr);
998       Params.push_back(keys);
999       ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
1000                                              SourceLocation(),
1001                                              SourceLocation(),
1002                                              &Context.Idents.get("cnt"),
1003                                              Context.UnsignedLongTy,
1004                                              /*TInfo=*/nullptr, SC_None,
1005                                              nullptr);
1006       Params.push_back(cnt);
1007       Method->setMethodParams(Context, Params, std::nullopt);
1008     }
1009 
1010     if (!validateBoxingMethod(*this, SR.getBegin(), NSDictionaryDecl, Sel,
1011                               Method))
1012        return ExprError();
1013 
1014     // Dig out the type that all values should be converted to.
1015     QualType ValueT = Method->parameters()[0]->getType();
1016     const PointerType *PtrValue = ValueT->getAs<PointerType>();
1017     if (!PtrValue ||
1018         !Context.hasSameUnqualifiedType(PtrValue->getPointeeType(), IdT)) {
1019       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
1020         << Sel;
1021       Diag(Method->parameters()[0]->getLocation(),
1022            diag::note_objc_literal_method_param)
1023         << 0 << ValueT
1024         << Context.getPointerType(IdT.withConst());
1025       return ExprError();
1026     }
1027 
1028     // Dig out the type that all keys should be converted to.
1029     QualType KeyT = Method->parameters()[1]->getType();
1030     const PointerType *PtrKey = KeyT->getAs<PointerType>();
1031     if (!PtrKey ||
1032         !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
1033                                         IdT)) {
1034       bool err = true;
1035       if (PtrKey) {
1036         if (QIDNSCopying.isNull()) {
1037           // key argument of selector is id<NSCopying>?
1038           if (ObjCProtocolDecl *NSCopyingPDecl =
1039               LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) {
1040             ObjCProtocolDecl *PQ[] = {NSCopyingPDecl};
1041             QIDNSCopying = Context.getObjCObjectType(
1042                 Context.ObjCBuiltinIdTy, {},
1043                 llvm::ArrayRef((ObjCProtocolDecl **)PQ, 1), false);
1044             QIDNSCopying = Context.getObjCObjectPointerType(QIDNSCopying);
1045           }
1046         }
1047         if (!QIDNSCopying.isNull())
1048           err = !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
1049                                                 QIDNSCopying);
1050       }
1051 
1052       if (err) {
1053         Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
1054           << Sel;
1055         Diag(Method->parameters()[1]->getLocation(),
1056              diag::note_objc_literal_method_param)
1057           << 1 << KeyT
1058           << Context.getPointerType(IdT.withConst());
1059         return ExprError();
1060       }
1061     }
1062 
1063     // Check that the 'count' parameter is integral.
1064     QualType CountType = Method->parameters()[2]->getType();
1065     if (!CountType->isIntegerType()) {
1066       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
1067         << Sel;
1068       Diag(Method->parameters()[2]->getLocation(),
1069            diag::note_objc_literal_method_param)
1070         << 2 << CountType
1071         << "integral";
1072       return ExprError();
1073     }
1074 
1075     // We've found a good +dictionaryWithObjects:keys:count: method; save it!
1076     DictionaryWithObjectsMethod = Method;
1077   }
1078 
1079   QualType ValuesT = DictionaryWithObjectsMethod->parameters()[0]->getType();
1080   QualType ValueT = ValuesT->castAs<PointerType>()->getPointeeType();
1081   QualType KeysT = DictionaryWithObjectsMethod->parameters()[1]->getType();
1082   QualType KeyT = KeysT->castAs<PointerType>()->getPointeeType();
1083 
1084   // Check that each of the keys and values provided is valid in a collection
1085   // literal, performing conversions as necessary.
1086   bool HasPackExpansions = false;
1087   for (ObjCDictionaryElement &Element : Elements) {
1088     // Check the key.
1089     ExprResult Key = CheckObjCCollectionLiteralElement(*this, Element.Key,
1090                                                        KeyT);
1091     if (Key.isInvalid())
1092       return ExprError();
1093 
1094     // Check the value.
1095     ExprResult Value
1096       = CheckObjCCollectionLiteralElement(*this, Element.Value, ValueT);
1097     if (Value.isInvalid())
1098       return ExprError();
1099 
1100     Element.Key = Key.get();
1101     Element.Value = Value.get();
1102 
1103     if (Element.EllipsisLoc.isInvalid())
1104       continue;
1105 
1106     if (!Element.Key->containsUnexpandedParameterPack() &&
1107         !Element.Value->containsUnexpandedParameterPack()) {
1108       Diag(Element.EllipsisLoc,
1109            diag::err_pack_expansion_without_parameter_packs)
1110           << SourceRange(Element.Key->getBeginLoc(),
1111                          Element.Value->getEndLoc());
1112       return ExprError();
1113     }
1114 
1115     HasPackExpansions = true;
1116   }
1117 
1118   QualType Ty = Context.getObjCObjectPointerType(
1119       Context.getObjCInterfaceType(NSDictionaryDecl));
1120 
1121   auto *Literal =
1122       ObjCDictionaryLiteral::Create(Context, Elements, HasPackExpansions, Ty,
1123                                     DictionaryWithObjectsMethod, SR);
1124   CheckObjCDictionaryLiteralDuplicateKeys(*this, Literal);
1125   return MaybeBindToTemporary(Literal);
1126 }
1127 
1128 ExprResult Sema::BuildObjCEncodeExpression(SourceLocation AtLoc,
1129                                       TypeSourceInfo *EncodedTypeInfo,
1130                                       SourceLocation RParenLoc) {
1131   QualType EncodedType = EncodedTypeInfo->getType();
1132   QualType StrTy;
1133   if (EncodedType->isDependentType())
1134     StrTy = Context.DependentTy;
1135   else {
1136     if (!EncodedType->getAsArrayTypeUnsafe() && //// Incomplete array is handled.
1137         !EncodedType->isVoidType()) // void is handled too.
1138       if (RequireCompleteType(AtLoc, EncodedType,
1139                               diag::err_incomplete_type_objc_at_encode,
1140                               EncodedTypeInfo->getTypeLoc()))
1141         return ExprError();
1142 
1143     std::string Str;
1144     QualType NotEncodedT;
1145     Context.getObjCEncodingForType(EncodedType, Str, nullptr, &NotEncodedT);
1146     if (!NotEncodedT.isNull())
1147       Diag(AtLoc, diag::warn_incomplete_encoded_type)
1148         << EncodedType << NotEncodedT;
1149 
1150     // The type of @encode is the same as the type of the corresponding string,
1151     // which is an array type.
1152     StrTy = Context.getStringLiteralArrayType(Context.CharTy, Str.size());
1153   }
1154 
1155   return new (Context) ObjCEncodeExpr(StrTy, EncodedTypeInfo, AtLoc, RParenLoc);
1156 }
1157 
1158 ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc,
1159                                            SourceLocation EncodeLoc,
1160                                            SourceLocation LParenLoc,
1161                                            ParsedType ty,
1162                                            SourceLocation RParenLoc) {
1163   // FIXME: Preserve type source info ?
1164   TypeSourceInfo *TInfo;
1165   QualType EncodedType = GetTypeFromParser(ty, &TInfo);
1166   if (!TInfo)
1167     TInfo = Context.getTrivialTypeSourceInfo(EncodedType,
1168                                              getLocForEndOfToken(LParenLoc));
1169 
1170   return BuildObjCEncodeExpression(AtLoc, TInfo, RParenLoc);
1171 }
1172 
1173 static bool HelperToDiagnoseMismatchedMethodsInGlobalPool(Sema &S,
1174                                                SourceLocation AtLoc,
1175                                                SourceLocation LParenLoc,
1176                                                SourceLocation RParenLoc,
1177                                                ObjCMethodDecl *Method,
1178                                                ObjCMethodList &MethList) {
1179   ObjCMethodList *M = &MethList;
1180   bool Warned = false;
1181   for (M = M->getNext(); M; M=M->getNext()) {
1182     ObjCMethodDecl *MatchingMethodDecl = M->getMethod();
1183     if (MatchingMethodDecl == Method ||
1184         isa<ObjCImplDecl>(MatchingMethodDecl->getDeclContext()) ||
1185         MatchingMethodDecl->getSelector() != Method->getSelector())
1186       continue;
1187     if (!S.MatchTwoMethodDeclarations(Method,
1188                                       MatchingMethodDecl, Sema::MMS_loose)) {
1189       if (!Warned) {
1190         Warned = true;
1191         S.Diag(AtLoc, diag::warn_multiple_selectors)
1192           << Method->getSelector() << FixItHint::CreateInsertion(LParenLoc, "(")
1193           << FixItHint::CreateInsertion(RParenLoc, ")");
1194         S.Diag(Method->getLocation(), diag::note_method_declared_at)
1195           << Method->getDeclName();
1196       }
1197       S.Diag(MatchingMethodDecl->getLocation(), diag::note_method_declared_at)
1198         << MatchingMethodDecl->getDeclName();
1199     }
1200   }
1201   return Warned;
1202 }
1203 
1204 static void DiagnoseMismatchedSelectors(Sema &S, SourceLocation AtLoc,
1205                                         ObjCMethodDecl *Method,
1206                                         SourceLocation LParenLoc,
1207                                         SourceLocation RParenLoc,
1208                                         bool WarnMultipleSelectors) {
1209   if (!WarnMultipleSelectors ||
1210       S.Diags.isIgnored(diag::warn_multiple_selectors, SourceLocation()))
1211     return;
1212   bool Warned = false;
1213   for (Sema::GlobalMethodPool::iterator b = S.MethodPool.begin(),
1214        e = S.MethodPool.end(); b != e; b++) {
1215     // first, instance methods
1216     ObjCMethodList &InstMethList = b->second.first;
1217     if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc,
1218                                                       Method, InstMethList))
1219       Warned = true;
1220 
1221     // second, class methods
1222     ObjCMethodList &ClsMethList = b->second.second;
1223     if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc,
1224                                                       Method, ClsMethList) || Warned)
1225       return;
1226   }
1227 }
1228 
1229 static ObjCMethodDecl *LookupDirectMethodInMethodList(Sema &S, Selector Sel,
1230                                                       ObjCMethodList &MethList,
1231                                                       bool &onlyDirect,
1232                                                       bool &anyDirect) {
1233   (void)Sel;
1234   ObjCMethodList *M = &MethList;
1235   ObjCMethodDecl *DirectMethod = nullptr;
1236   for (; M; M = M->getNext()) {
1237     ObjCMethodDecl *Method = M->getMethod();
1238     if (!Method)
1239       continue;
1240     assert(Method->getSelector() == Sel && "Method with wrong selector in method list");
1241     if (Method->isDirectMethod()) {
1242       anyDirect = true;
1243       DirectMethod = Method;
1244     } else
1245       onlyDirect = false;
1246   }
1247 
1248   return DirectMethod;
1249 }
1250 
1251 // Search the global pool for (potentially) direct methods matching the given
1252 // selector. If a non-direct method is found, set \param onlyDirect to false. If
1253 // a direct method is found, set \param anyDirect to true. Returns a direct
1254 // method, if any.
1255 static ObjCMethodDecl *LookupDirectMethodInGlobalPool(Sema &S, Selector Sel,
1256                                                       bool &onlyDirect,
1257                                                       bool &anyDirect) {
1258   auto Iter = S.MethodPool.find(Sel);
1259   if (Iter == S.MethodPool.end())
1260     return nullptr;
1261 
1262   ObjCMethodDecl *DirectInstance = LookupDirectMethodInMethodList(
1263       S, Sel, Iter->second.first, onlyDirect, anyDirect);
1264   ObjCMethodDecl *DirectClass = LookupDirectMethodInMethodList(
1265       S, Sel, Iter->second.second, onlyDirect, anyDirect);
1266 
1267   return DirectInstance ? DirectInstance : DirectClass;
1268 }
1269 
1270 static ObjCMethodDecl *findMethodInCurrentClass(Sema &S, Selector Sel) {
1271   auto *CurMD = S.getCurMethodDecl();
1272   if (!CurMD)
1273     return nullptr;
1274   ObjCInterfaceDecl *IFace = CurMD->getClassInterface();
1275 
1276   // The language enforce that only one direct method is present in a given
1277   // class, so we just need to find one method in the current class to know
1278   // whether Sel is potentially direct in this context.
1279   if (ObjCMethodDecl *MD = IFace->lookupMethod(Sel, /*isInstance=*/true))
1280     return MD;
1281   if (ObjCMethodDecl *MD = IFace->lookupPrivateMethod(Sel, /*Instance=*/true))
1282     return MD;
1283   if (ObjCMethodDecl *MD = IFace->lookupMethod(Sel, /*isInstance=*/false))
1284     return MD;
1285   if (ObjCMethodDecl *MD = IFace->lookupPrivateMethod(Sel, /*Instance=*/false))
1286     return MD;
1287 
1288   return nullptr;
1289 }
1290 
1291 ExprResult Sema::ParseObjCSelectorExpression(Selector Sel,
1292                                              SourceLocation AtLoc,
1293                                              SourceLocation SelLoc,
1294                                              SourceLocation LParenLoc,
1295                                              SourceLocation RParenLoc,
1296                                              bool WarnMultipleSelectors) {
1297   ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel,
1298                              SourceRange(LParenLoc, RParenLoc));
1299   if (!Method)
1300     Method = LookupFactoryMethodInGlobalPool(Sel,
1301                                           SourceRange(LParenLoc, RParenLoc));
1302   if (!Method) {
1303     if (const ObjCMethodDecl *OM = SelectorsForTypoCorrection(Sel)) {
1304       Selector MatchedSel = OM->getSelector();
1305       SourceRange SelectorRange(LParenLoc.getLocWithOffset(1),
1306                                 RParenLoc.getLocWithOffset(-1));
1307       Diag(SelLoc, diag::warn_undeclared_selector_with_typo)
1308         << Sel << MatchedSel
1309         << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString());
1310 
1311     } else
1312         Diag(SelLoc, diag::warn_undeclared_selector) << Sel;
1313   } else {
1314     DiagnoseMismatchedSelectors(*this, AtLoc, Method, LParenLoc, RParenLoc,
1315                                 WarnMultipleSelectors);
1316 
1317     bool onlyDirect = true;
1318     bool anyDirect = false;
1319     ObjCMethodDecl *GlobalDirectMethod =
1320         LookupDirectMethodInGlobalPool(*this, Sel, onlyDirect, anyDirect);
1321 
1322     if (onlyDirect) {
1323       Diag(AtLoc, diag::err_direct_selector_expression)
1324           << Method->getSelector();
1325       Diag(Method->getLocation(), diag::note_direct_method_declared_at)
1326           << Method->getDeclName();
1327     } else if (anyDirect) {
1328       // If we saw any direct methods, see if we see a direct member of the
1329       // current class. If so, the @selector will likely be used to refer to
1330       // this direct method.
1331       ObjCMethodDecl *LikelyTargetMethod = findMethodInCurrentClass(*this, Sel);
1332       if (LikelyTargetMethod && LikelyTargetMethod->isDirectMethod()) {
1333         Diag(AtLoc, diag::warn_potentially_direct_selector_expression) << Sel;
1334         Diag(LikelyTargetMethod->getLocation(),
1335              diag::note_direct_method_declared_at)
1336             << LikelyTargetMethod->getDeclName();
1337       } else if (!LikelyTargetMethod) {
1338         // Otherwise, emit the "strict" variant of this diagnostic, unless
1339         // LikelyTargetMethod is non-direct.
1340         Diag(AtLoc, diag::warn_strict_potentially_direct_selector_expression)
1341             << Sel;
1342         Diag(GlobalDirectMethod->getLocation(),
1343              diag::note_direct_method_declared_at)
1344             << GlobalDirectMethod->getDeclName();
1345       }
1346     }
1347   }
1348 
1349   if (Method &&
1350       Method->getImplementationControl() !=
1351           ObjCImplementationControl::Optional &&
1352       !getSourceManager().isInSystemHeader(Method->getLocation()))
1353     ReferencedSelectors.insert(std::make_pair(Sel, AtLoc));
1354 
1355   // In ARC, forbid the user from using @selector for
1356   // retain/release/autorelease/dealloc/retainCount.
1357   if (getLangOpts().ObjCAutoRefCount) {
1358     switch (Sel.getMethodFamily()) {
1359     case OMF_retain:
1360     case OMF_release:
1361     case OMF_autorelease:
1362     case OMF_retainCount:
1363     case OMF_dealloc:
1364       Diag(AtLoc, diag::err_arc_illegal_selector) <<
1365         Sel << SourceRange(LParenLoc, RParenLoc);
1366       break;
1367 
1368     case OMF_None:
1369     case OMF_alloc:
1370     case OMF_copy:
1371     case OMF_finalize:
1372     case OMF_init:
1373     case OMF_mutableCopy:
1374     case OMF_new:
1375     case OMF_self:
1376     case OMF_initialize:
1377     case OMF_performSelector:
1378       break;
1379     }
1380   }
1381   QualType Ty = Context.getObjCSelType();
1382   return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc);
1383 }
1384 
1385 ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
1386                                              SourceLocation AtLoc,
1387                                              SourceLocation ProtoLoc,
1388                                              SourceLocation LParenLoc,
1389                                              SourceLocation ProtoIdLoc,
1390                                              SourceLocation RParenLoc) {
1391   ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoIdLoc);
1392   if (!PDecl) {
1393     Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;
1394     return true;
1395   }
1396   if (PDecl->isNonRuntimeProtocol())
1397     Diag(ProtoLoc, diag::err_objc_non_runtime_protocol_in_protocol_expr)
1398         << PDecl;
1399   if (!PDecl->hasDefinition()) {
1400     Diag(ProtoLoc, diag::err_atprotocol_protocol) << PDecl;
1401     Diag(PDecl->getLocation(), diag::note_entity_declared_at) << PDecl;
1402   } else {
1403     PDecl = PDecl->getDefinition();
1404   }
1405 
1406   QualType Ty = Context.getObjCProtoType();
1407   if (Ty.isNull())
1408     return true;
1409   Ty = Context.getObjCObjectPointerType(Ty);
1410   return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, ProtoIdLoc, RParenLoc);
1411 }
1412 
1413 /// Try to capture an implicit reference to 'self'.
1414 ObjCMethodDecl *Sema::tryCaptureObjCSelf(SourceLocation Loc) {
1415   DeclContext *DC = getFunctionLevelDeclContext();
1416 
1417   // If we're not in an ObjC method, error out.  Note that, unlike the
1418   // C++ case, we don't require an instance method --- class methods
1419   // still have a 'self', and we really do still need to capture it!
1420   ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(DC);
1421   if (!method)
1422     return nullptr;
1423 
1424   tryCaptureVariable(method->getSelfDecl(), Loc);
1425 
1426   return method;
1427 }
1428 
1429 static QualType stripObjCInstanceType(ASTContext &Context, QualType T) {
1430   QualType origType = T;
1431   if (auto nullability = AttributedType::stripOuterNullability(T)) {
1432     if (T == Context.getObjCInstanceType()) {
1433       return Context.getAttributedType(
1434                AttributedType::getNullabilityAttrKind(*nullability),
1435                Context.getObjCIdType(),
1436                Context.getObjCIdType());
1437     }
1438 
1439     return origType;
1440   }
1441 
1442   if (T == Context.getObjCInstanceType())
1443     return Context.getObjCIdType();
1444 
1445   return origType;
1446 }
1447 
1448 /// Determine the result type of a message send based on the receiver type,
1449 /// method, and the kind of message send.
1450 ///
1451 /// This is the "base" result type, which will still need to be adjusted
1452 /// to account for nullability.
1453 static QualType getBaseMessageSendResultType(Sema &S,
1454                                              QualType ReceiverType,
1455                                              ObjCMethodDecl *Method,
1456                                              bool isClassMessage,
1457                                              bool isSuperMessage) {
1458   assert(Method && "Must have a method");
1459   if (!Method->hasRelatedResultType())
1460     return Method->getSendResultType(ReceiverType);
1461 
1462   ASTContext &Context = S.Context;
1463 
1464   // Local function that transfers the nullability of the method's
1465   // result type to the returned result.
1466   auto transferNullability = [&](QualType type) -> QualType {
1467     // If the method's result type has nullability, extract it.
1468     if (auto nullability =
1469             Method->getSendResultType(ReceiverType)->getNullability()) {
1470       // Strip off any outer nullability sugar from the provided type.
1471       (void)AttributedType::stripOuterNullability(type);
1472 
1473       // Form a new attributed type using the method result type's nullability.
1474       return Context.getAttributedType(
1475                AttributedType::getNullabilityAttrKind(*nullability),
1476                type,
1477                type);
1478     }
1479 
1480     return type;
1481   };
1482 
1483   // If a method has a related return type:
1484   //   - if the method found is an instance method, but the message send
1485   //     was a class message send, T is the declared return type of the method
1486   //     found
1487   if (Method->isInstanceMethod() && isClassMessage)
1488     return stripObjCInstanceType(Context,
1489                                  Method->getSendResultType(ReceiverType));
1490 
1491   //   - if the receiver is super, T is a pointer to the class of the
1492   //     enclosing method definition
1493   if (isSuperMessage) {
1494     if (ObjCMethodDecl *CurMethod = S.getCurMethodDecl())
1495       if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface()) {
1496         return transferNullability(
1497                  Context.getObjCObjectPointerType(
1498                    Context.getObjCInterfaceType(Class)));
1499       }
1500   }
1501 
1502   //   - if the receiver is the name of a class U, T is a pointer to U
1503   if (ReceiverType->getAsObjCInterfaceType())
1504     return transferNullability(Context.getObjCObjectPointerType(ReceiverType));
1505   //   - if the receiver is of type Class or qualified Class type,
1506   //     T is the declared return type of the method.
1507   if (ReceiverType->isObjCClassType() ||
1508       ReceiverType->isObjCQualifiedClassType())
1509     return stripObjCInstanceType(Context,
1510                                  Method->getSendResultType(ReceiverType));
1511 
1512   //   - if the receiver is id, qualified id, Class, or qualified Class, T
1513   //     is the receiver type, otherwise
1514   //   - T is the type of the receiver expression.
1515   return transferNullability(ReceiverType);
1516 }
1517 
1518 QualType Sema::getMessageSendResultType(const Expr *Receiver,
1519                                         QualType ReceiverType,
1520                                         ObjCMethodDecl *Method,
1521                                         bool isClassMessage,
1522                                         bool isSuperMessage) {
1523   // Produce the result type.
1524   QualType resultType = getBaseMessageSendResultType(*this, ReceiverType,
1525                                                      Method,
1526                                                      isClassMessage,
1527                                                      isSuperMessage);
1528 
1529   // If this is a class message, ignore the nullability of the receiver.
1530   if (isClassMessage) {
1531     // In a class method, class messages to 'self' that return instancetype can
1532     // be typed as the current class.  We can safely do this in ARC because self
1533     // can't be reassigned, and we do it unsafely outside of ARC because in
1534     // practice people never reassign self in class methods and there's some
1535     // virtue in not being aggressively pedantic.
1536     if (Receiver && Receiver->isObjCSelfExpr()) {
1537       assert(ReceiverType->isObjCClassType() && "expected a Class self");
1538       QualType T = Method->getSendResultType(ReceiverType);
1539       AttributedType::stripOuterNullability(T);
1540       if (T == Context.getObjCInstanceType()) {
1541         const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(
1542             cast<ImplicitParamDecl>(
1543                 cast<DeclRefExpr>(Receiver->IgnoreParenImpCasts())->getDecl())
1544                 ->getDeclContext());
1545         assert(MD->isClassMethod() && "expected a class method");
1546         QualType NewResultType = Context.getObjCObjectPointerType(
1547             Context.getObjCInterfaceType(MD->getClassInterface()));
1548         if (auto Nullability = resultType->getNullability())
1549           NewResultType = Context.getAttributedType(
1550               AttributedType::getNullabilityAttrKind(*Nullability),
1551               NewResultType, NewResultType);
1552         return NewResultType;
1553       }
1554     }
1555     return resultType;
1556   }
1557 
1558   // There is nothing left to do if the result type cannot have a nullability
1559   // specifier.
1560   if (!resultType->canHaveNullability())
1561     return resultType;
1562 
1563   // Map the nullability of the result into a table index.
1564   unsigned receiverNullabilityIdx = 0;
1565   if (std::optional<NullabilityKind> nullability =
1566           ReceiverType->getNullability()) {
1567     if (*nullability == NullabilityKind::NullableResult)
1568       nullability = NullabilityKind::Nullable;
1569     receiverNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
1570   }
1571 
1572   unsigned resultNullabilityIdx = 0;
1573   if (std::optional<NullabilityKind> nullability =
1574           resultType->getNullability()) {
1575     if (*nullability == NullabilityKind::NullableResult)
1576       nullability = NullabilityKind::Nullable;
1577     resultNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
1578   }
1579 
1580   // The table of nullability mappings, indexed by the receiver's nullability
1581   // and then the result type's nullability.
1582   static const uint8_t None = 0;
1583   static const uint8_t NonNull = 1;
1584   static const uint8_t Nullable = 2;
1585   static const uint8_t Unspecified = 3;
1586   static const uint8_t nullabilityMap[4][4] = {
1587     //                  None        NonNull       Nullable    Unspecified
1588     /* None */        { None,       None,         Nullable,   None },
1589     /* NonNull */     { None,       NonNull,      Nullable,   Unspecified },
1590     /* Nullable */    { Nullable,   Nullable,     Nullable,   Nullable },
1591     /* Unspecified */ { None,       Unspecified,  Nullable,   Unspecified }
1592   };
1593 
1594   unsigned newResultNullabilityIdx
1595     = nullabilityMap[receiverNullabilityIdx][resultNullabilityIdx];
1596   if (newResultNullabilityIdx == resultNullabilityIdx)
1597     return resultType;
1598 
1599   // Strip off the existing nullability. This removes as little type sugar as
1600   // possible.
1601   do {
1602     if (auto attributed = dyn_cast<AttributedType>(resultType.getTypePtr())) {
1603       resultType = attributed->getModifiedType();
1604     } else {
1605       resultType = resultType.getDesugaredType(Context);
1606     }
1607   } while (resultType->getNullability());
1608 
1609   // Add nullability back if needed.
1610   if (newResultNullabilityIdx > 0) {
1611     auto newNullability
1612       = static_cast<NullabilityKind>(newResultNullabilityIdx-1);
1613     return Context.getAttributedType(
1614              AttributedType::getNullabilityAttrKind(newNullability),
1615              resultType, resultType);
1616   }
1617 
1618   return resultType;
1619 }
1620 
1621 /// Look for an ObjC method whose result type exactly matches the given type.
1622 static const ObjCMethodDecl *
1623 findExplicitInstancetypeDeclarer(const ObjCMethodDecl *MD,
1624                                  QualType instancetype) {
1625   if (MD->getReturnType() == instancetype)
1626     return MD;
1627 
1628   // For these purposes, a method in an @implementation overrides a
1629   // declaration in the @interface.
1630   if (const ObjCImplDecl *impl =
1631         dyn_cast<ObjCImplDecl>(MD->getDeclContext())) {
1632     const ObjCContainerDecl *iface;
1633     if (const ObjCCategoryImplDecl *catImpl =
1634           dyn_cast<ObjCCategoryImplDecl>(impl)) {
1635       iface = catImpl->getCategoryDecl();
1636     } else {
1637       iface = impl->getClassInterface();
1638     }
1639 
1640     const ObjCMethodDecl *ifaceMD =
1641       iface->getMethod(MD->getSelector(), MD->isInstanceMethod());
1642     if (ifaceMD) return findExplicitInstancetypeDeclarer(ifaceMD, instancetype);
1643   }
1644 
1645   SmallVector<const ObjCMethodDecl *, 4> overrides;
1646   MD->getOverriddenMethods(overrides);
1647   for (unsigned i = 0, e = overrides.size(); i != e; ++i) {
1648     if (const ObjCMethodDecl *result =
1649           findExplicitInstancetypeDeclarer(overrides[i], instancetype))
1650       return result;
1651   }
1652 
1653   return nullptr;
1654 }
1655 
1656 void Sema::EmitRelatedResultTypeNoteForReturn(QualType destType) {
1657   // Only complain if we're in an ObjC method and the required return
1658   // type doesn't match the method's declared return type.
1659   ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurContext);
1660   if (!MD || !MD->hasRelatedResultType() ||
1661       Context.hasSameUnqualifiedType(destType, MD->getReturnType()))
1662     return;
1663 
1664   // Look for a method overridden by this method which explicitly uses
1665   // 'instancetype'.
1666   if (const ObjCMethodDecl *overridden =
1667         findExplicitInstancetypeDeclarer(MD, Context.getObjCInstanceType())) {
1668     SourceRange range = overridden->getReturnTypeSourceRange();
1669     SourceLocation loc = range.getBegin();
1670     if (loc.isInvalid())
1671       loc = overridden->getLocation();
1672     Diag(loc, diag::note_related_result_type_explicit)
1673       << /*current method*/ 1 << range;
1674     return;
1675   }
1676 
1677   // Otherwise, if we have an interesting method family, note that.
1678   // This should always trigger if the above didn't.
1679   if (ObjCMethodFamily family = MD->getMethodFamily())
1680     Diag(MD->getLocation(), diag::note_related_result_type_family)
1681       << /*current method*/ 1
1682       << family;
1683 }
1684 
1685 void Sema::EmitRelatedResultTypeNote(const Expr *E) {
1686   E = E->IgnoreParenImpCasts();
1687   const ObjCMessageExpr *MsgSend = dyn_cast<ObjCMessageExpr>(E);
1688   if (!MsgSend)
1689     return;
1690 
1691   const ObjCMethodDecl *Method = MsgSend->getMethodDecl();
1692   if (!Method)
1693     return;
1694 
1695   if (!Method->hasRelatedResultType())
1696     return;
1697 
1698   if (Context.hasSameUnqualifiedType(
1699           Method->getReturnType().getNonReferenceType(), MsgSend->getType()))
1700     return;
1701 
1702   if (!Context.hasSameUnqualifiedType(Method->getReturnType(),
1703                                       Context.getObjCInstanceType()))
1704     return;
1705 
1706   Diag(Method->getLocation(), diag::note_related_result_type_inferred)
1707     << Method->isInstanceMethod() << Method->getSelector()
1708     << MsgSend->getType();
1709 }
1710 
1711 bool Sema::CheckMessageArgumentTypes(
1712     const Expr *Receiver, QualType ReceiverType, MultiExprArg Args,
1713     Selector Sel, ArrayRef<SourceLocation> SelectorLocs, ObjCMethodDecl *Method,
1714     bool isClassMessage, bool isSuperMessage, SourceLocation lbrac,
1715     SourceLocation rbrac, SourceRange RecRange, QualType &ReturnType,
1716     ExprValueKind &VK) {
1717   SourceLocation SelLoc;
1718   if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
1719     SelLoc = SelectorLocs.front();
1720   else
1721     SelLoc = lbrac;
1722 
1723   if (!Method) {
1724     // Apply default argument promotion as for (C99 6.5.2.2p6).
1725     for (unsigned i = 0, e = Args.size(); i != e; i++) {
1726       if (Args[i]->isTypeDependent())
1727         continue;
1728 
1729       ExprResult result;
1730       if (getLangOpts().DebuggerSupport) {
1731         QualType paramTy; // ignored
1732         result = checkUnknownAnyArg(SelLoc, Args[i], paramTy);
1733       } else {
1734         result = DefaultArgumentPromotion(Args[i]);
1735       }
1736       if (result.isInvalid())
1737         return true;
1738       Args[i] = result.get();
1739     }
1740 
1741     unsigned DiagID;
1742     if (getLangOpts().ObjCAutoRefCount)
1743       DiagID = diag::err_arc_method_not_found;
1744     else
1745       DiagID = isClassMessage ? diag::warn_class_method_not_found
1746                               : diag::warn_inst_method_not_found;
1747     if (!getLangOpts().DebuggerSupport) {
1748       const ObjCMethodDecl *OMD = SelectorsForTypoCorrection(Sel, ReceiverType);
1749       if (OMD && !OMD->isInvalidDecl()) {
1750         if (getLangOpts().ObjCAutoRefCount)
1751           DiagID = diag::err_method_not_found_with_typo;
1752         else
1753           DiagID = isClassMessage ? diag::warn_class_method_not_found_with_typo
1754                                   : diag::warn_instance_method_not_found_with_typo;
1755         Selector MatchedSel = OMD->getSelector();
1756         SourceRange SelectorRange(SelectorLocs.front(), SelectorLocs.back());
1757         if (MatchedSel.isUnarySelector())
1758           Diag(SelLoc, DiagID)
1759             << Sel<< isClassMessage << MatchedSel
1760             << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString());
1761         else
1762           Diag(SelLoc, DiagID) << Sel<< isClassMessage << MatchedSel;
1763       }
1764       else
1765         Diag(SelLoc, DiagID)
1766           << Sel << isClassMessage << SourceRange(SelectorLocs.front(),
1767                                                 SelectorLocs.back());
1768       // Find the class to which we are sending this message.
1769       if (auto *ObjPT = ReceiverType->getAs<ObjCObjectPointerType>()) {
1770         if (ObjCInterfaceDecl *ThisClass = ObjPT->getInterfaceDecl()) {
1771           Diag(ThisClass->getLocation(), diag::note_receiver_class_declared);
1772           if (!RecRange.isInvalid())
1773             if (ThisClass->lookupClassMethod(Sel))
1774               Diag(RecRange.getBegin(), diag::note_receiver_expr_here)
1775                   << FixItHint::CreateReplacement(RecRange,
1776                                                   ThisClass->getNameAsString());
1777         }
1778       }
1779     }
1780 
1781     // In debuggers, we want to use __unknown_anytype for these
1782     // results so that clients can cast them.
1783     if (getLangOpts().DebuggerSupport) {
1784       ReturnType = Context.UnknownAnyTy;
1785     } else {
1786       ReturnType = Context.getObjCIdType();
1787     }
1788     VK = VK_PRValue;
1789     return false;
1790   }
1791 
1792   ReturnType = getMessageSendResultType(Receiver, ReceiverType, Method,
1793                                         isClassMessage, isSuperMessage);
1794   VK = Expr::getValueKindForType(Method->getReturnType());
1795 
1796   unsigned NumNamedArgs = Sel.getNumArgs();
1797   // Method might have more arguments than selector indicates. This is due
1798   // to addition of c-style arguments in method.
1799   if (Method->param_size() > Sel.getNumArgs())
1800     NumNamedArgs = Method->param_size();
1801   // FIXME. This need be cleaned up.
1802   if (Args.size() < NumNamedArgs) {
1803     Diag(SelLoc, diag::err_typecheck_call_too_few_args)
1804         << 2 << NumNamedArgs << static_cast<unsigned>(Args.size())
1805         << /*is non object*/ 0;
1806     return false;
1807   }
1808 
1809   // Compute the set of type arguments to be substituted into each parameter
1810   // type.
1811   std::optional<ArrayRef<QualType>> typeArgs =
1812       ReceiverType->getObjCSubstitutions(Method->getDeclContext());
1813   bool IsError = false;
1814   for (unsigned i = 0; i < NumNamedArgs; i++) {
1815     // We can't do any type-checking on a type-dependent argument.
1816     if (Args[i]->isTypeDependent())
1817       continue;
1818 
1819     Expr *argExpr = Args[i];
1820 
1821     ParmVarDecl *param = Method->parameters()[i];
1822     assert(argExpr && "CheckMessageArgumentTypes(): missing expression");
1823 
1824     if (param->hasAttr<NoEscapeAttr>() &&
1825         param->getType()->isBlockPointerType())
1826       if (auto *BE = dyn_cast<BlockExpr>(
1827               argExpr->IgnoreParenNoopCasts(Context)))
1828         BE->getBlockDecl()->setDoesNotEscape();
1829 
1830     // Strip the unbridged-cast placeholder expression off unless it's
1831     // a consumed argument.
1832     if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
1833         !param->hasAttr<CFConsumedAttr>())
1834       argExpr = stripARCUnbridgedCast(argExpr);
1835 
1836     // If the parameter is __unknown_anytype, infer its type
1837     // from the argument.
1838     if (param->getType() == Context.UnknownAnyTy) {
1839       QualType paramType;
1840       ExprResult argE = checkUnknownAnyArg(SelLoc, argExpr, paramType);
1841       if (argE.isInvalid()) {
1842         IsError = true;
1843       } else {
1844         Args[i] = argE.get();
1845 
1846         // Update the parameter type in-place.
1847         param->setType(paramType);
1848       }
1849       continue;
1850     }
1851 
1852     QualType origParamType = param->getType();
1853     QualType paramType = param->getType();
1854     if (typeArgs)
1855       paramType = paramType.substObjCTypeArgs(
1856                     Context,
1857                     *typeArgs,
1858                     ObjCSubstitutionContext::Parameter);
1859 
1860     if (RequireCompleteType(argExpr->getSourceRange().getBegin(),
1861                             paramType,
1862                             diag::err_call_incomplete_argument, argExpr))
1863       return true;
1864 
1865     InitializedEntity Entity
1866       = InitializedEntity::InitializeParameter(Context, param, paramType);
1867     ExprResult ArgE = PerformCopyInitialization(Entity, SourceLocation(), argExpr);
1868     if (ArgE.isInvalid())
1869       IsError = true;
1870     else {
1871       Args[i] = ArgE.getAs<Expr>();
1872 
1873       // If we are type-erasing a block to a block-compatible
1874       // Objective-C pointer type, we may need to extend the lifetime
1875       // of the block object.
1876       if (typeArgs && Args[i]->isPRValue() && paramType->isBlockPointerType() &&
1877           Args[i]->getType()->isBlockPointerType() &&
1878           origParamType->isObjCObjectPointerType()) {
1879         ExprResult arg = Args[i];
1880         maybeExtendBlockObject(arg);
1881         Args[i] = arg.get();
1882       }
1883     }
1884   }
1885 
1886   // Promote additional arguments to variadic methods.
1887   if (Method->isVariadic()) {
1888     for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
1889       if (Args[i]->isTypeDependent())
1890         continue;
1891 
1892       ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
1893                                                         nullptr);
1894       IsError |= Arg.isInvalid();
1895       Args[i] = Arg.get();
1896     }
1897   } else {
1898     // Check for extra arguments to non-variadic methods.
1899     if (Args.size() != NumNamedArgs) {
1900       Diag(Args[NumNamedArgs]->getBeginLoc(),
1901            diag::err_typecheck_call_too_many_args)
1902           << 2 /*method*/ << NumNamedArgs << static_cast<unsigned>(Args.size())
1903           << Method->getSourceRange() << /*is non object*/ 0
1904           << SourceRange(Args[NumNamedArgs]->getBeginLoc(),
1905                          Args.back()->getEndLoc());
1906     }
1907   }
1908 
1909   DiagnoseSentinelCalls(Method, SelLoc, Args);
1910 
1911   // Do additional checkings on method.
1912   IsError |=
1913       CheckObjCMethodCall(Method, SelLoc, ArrayRef(Args.data(), Args.size()));
1914 
1915   return IsError;
1916 }
1917 
1918 bool Sema::isSelfExpr(Expr *RExpr) {
1919   // 'self' is objc 'self' in an objc method only.
1920   ObjCMethodDecl *Method =
1921       dyn_cast_or_null<ObjCMethodDecl>(CurContext->getNonClosureAncestor());
1922   return isSelfExpr(RExpr, Method);
1923 }
1924 
1925 bool Sema::isSelfExpr(Expr *receiver, const ObjCMethodDecl *method) {
1926   if (!method) return false;
1927 
1928   receiver = receiver->IgnoreParenLValueCasts();
1929   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(receiver))
1930     if (DRE->getDecl() == method->getSelfDecl())
1931       return true;
1932   return false;
1933 }
1934 
1935 /// LookupMethodInType - Look up a method in an ObjCObjectType.
1936 ObjCMethodDecl *Sema::LookupMethodInObjectType(Selector sel, QualType type,
1937                                                bool isInstance) {
1938   const ObjCObjectType *objType = type->castAs<ObjCObjectType>();
1939   if (ObjCInterfaceDecl *iface = objType->getInterface()) {
1940     // Look it up in the main interface (and categories, etc.)
1941     if (ObjCMethodDecl *method = iface->lookupMethod(sel, isInstance))
1942       return method;
1943 
1944     // Okay, look for "private" methods declared in any
1945     // @implementations we've seen.
1946     if (ObjCMethodDecl *method = iface->lookupPrivateMethod(sel, isInstance))
1947       return method;
1948   }
1949 
1950   // Check qualifiers.
1951   for (const auto *I : objType->quals())
1952     if (ObjCMethodDecl *method = I->lookupMethod(sel, isInstance))
1953       return method;
1954 
1955   return nullptr;
1956 }
1957 
1958 /// LookupMethodInQualifiedType - Lookups up a method in protocol qualifier
1959 /// list of a qualified objective pointer type.
1960 ObjCMethodDecl *Sema::LookupMethodInQualifiedType(Selector Sel,
1961                                               const ObjCObjectPointerType *OPT,
1962                                               bool Instance)
1963 {
1964   ObjCMethodDecl *MD = nullptr;
1965   for (const auto *PROTO : OPT->quals()) {
1966     if ((MD = PROTO->lookupMethod(Sel, Instance))) {
1967       return MD;
1968     }
1969   }
1970   return nullptr;
1971 }
1972 
1973 /// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an
1974 /// objective C interface.  This is a property reference expression.
1975 ExprResult Sema::
1976 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
1977                           Expr *BaseExpr, SourceLocation OpLoc,
1978                           DeclarationName MemberName,
1979                           SourceLocation MemberLoc,
1980                           SourceLocation SuperLoc, QualType SuperType,
1981                           bool Super) {
1982   const ObjCInterfaceType *IFaceT = OPT->getInterfaceType();
1983   ObjCInterfaceDecl *IFace = IFaceT->getDecl();
1984 
1985   if (!MemberName.isIdentifier()) {
1986     Diag(MemberLoc, diag::err_invalid_property_name)
1987       << MemberName << QualType(OPT, 0);
1988     return ExprError();
1989   }
1990 
1991   IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1992 
1993   SourceRange BaseRange = Super? SourceRange(SuperLoc)
1994                                : BaseExpr->getSourceRange();
1995   if (RequireCompleteType(MemberLoc, OPT->getPointeeType(),
1996                           diag::err_property_not_found_forward_class,
1997                           MemberName, BaseRange))
1998     return ExprError();
1999 
2000   if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(
2001           Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
2002     // Check whether we can reference this property.
2003     if (DiagnoseUseOfDecl(PD, MemberLoc))
2004       return ExprError();
2005     if (Super)
2006       return new (Context)
2007           ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue,
2008                               OK_ObjCProperty, MemberLoc, SuperLoc, SuperType);
2009     else
2010       return new (Context)
2011           ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue,
2012                               OK_ObjCProperty, MemberLoc, BaseExpr);
2013   }
2014   // Check protocols on qualified interfaces.
2015   for (const auto *I : OPT->quals())
2016     if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration(
2017             Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
2018       // Check whether we can reference this property.
2019       if (DiagnoseUseOfDecl(PD, MemberLoc))
2020         return ExprError();
2021 
2022       if (Super)
2023         return new (Context) ObjCPropertyRefExpr(
2024             PD, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty, MemberLoc,
2025             SuperLoc, SuperType);
2026       else
2027         return new (Context)
2028             ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue,
2029                                 OK_ObjCProperty, MemberLoc, BaseExpr);
2030     }
2031   // If that failed, look for an "implicit" property by seeing if the nullary
2032   // selector is implemented.
2033 
2034   // FIXME: The logic for looking up nullary and unary selectors should be
2035   // shared with the code in ActOnInstanceMessage.
2036 
2037   Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
2038   ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
2039 
2040   // May be found in property's qualified list.
2041   if (!Getter)
2042     Getter = LookupMethodInQualifiedType(Sel, OPT, true);
2043 
2044   // If this reference is in an @implementation, check for 'private' methods.
2045   if (!Getter)
2046     Getter = IFace->lookupPrivateMethod(Sel);
2047 
2048   if (Getter) {
2049     // Check if we can reference this property.
2050     if (DiagnoseUseOfDecl(Getter, MemberLoc))
2051       return ExprError();
2052   }
2053   // If we found a getter then this may be a valid dot-reference, we
2054   // will look for the matching setter, in case it is needed.
2055   Selector SetterSel =
2056     SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
2057                                            PP.getSelectorTable(), Member);
2058   ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
2059 
2060   // May be found in property's qualified list.
2061   if (!Setter)
2062     Setter = LookupMethodInQualifiedType(SetterSel, OPT, true);
2063 
2064   if (!Setter) {
2065     // If this reference is in an @implementation, also check for 'private'
2066     // methods.
2067     Setter = IFace->lookupPrivateMethod(SetterSel);
2068   }
2069 
2070   if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2071     return ExprError();
2072 
2073   // Special warning if member name used in a property-dot for a setter accessor
2074   // does not use a property with same name; e.g. obj.X = ... for a property with
2075   // name 'x'.
2076   if (Setter && Setter->isImplicit() && Setter->isPropertyAccessor() &&
2077       !IFace->FindPropertyDeclaration(
2078           Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
2079       if (const ObjCPropertyDecl *PDecl = Setter->findPropertyDecl()) {
2080         // Do not warn if user is using property-dot syntax to make call to
2081         // user named setter.
2082         if (!(PDecl->getPropertyAttributes() &
2083               ObjCPropertyAttribute::kind_setter))
2084           Diag(MemberLoc,
2085                diag::warn_property_access_suggest)
2086           << MemberName << QualType(OPT, 0) << PDecl->getName()
2087           << FixItHint::CreateReplacement(MemberLoc, PDecl->getName());
2088       }
2089   }
2090 
2091   if (Getter || Setter) {
2092     if (Super)
2093       return new (Context)
2094           ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
2095                               OK_ObjCProperty, MemberLoc, SuperLoc, SuperType);
2096     else
2097       return new (Context)
2098           ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
2099                               OK_ObjCProperty, MemberLoc, BaseExpr);
2100 
2101   }
2102 
2103   // Attempt to correct for typos in property names.
2104   DeclFilterCCC<ObjCPropertyDecl> CCC{};
2105   if (TypoCorrection Corrected = CorrectTypo(
2106           DeclarationNameInfo(MemberName, MemberLoc), LookupOrdinaryName,
2107           nullptr, nullptr, CCC, CTK_ErrorRecovery, IFace, false, OPT)) {
2108     DeclarationName TypoResult = Corrected.getCorrection();
2109     if (TypoResult.isIdentifier() &&
2110         TypoResult.getAsIdentifierInfo() == Member) {
2111       // There is no need to try the correction if it is the same.
2112       NamedDecl *ChosenDecl =
2113         Corrected.isKeyword() ? nullptr : Corrected.getFoundDecl();
2114       if (ChosenDecl && isa<ObjCPropertyDecl>(ChosenDecl))
2115         if (cast<ObjCPropertyDecl>(ChosenDecl)->isClassProperty()) {
2116           // This is a class property, we should not use the instance to
2117           // access it.
2118           Diag(MemberLoc, diag::err_class_property_found) << MemberName
2119           << OPT->getInterfaceDecl()->getName()
2120           << FixItHint::CreateReplacement(BaseExpr->getSourceRange(),
2121                                           OPT->getInterfaceDecl()->getName());
2122           return ExprError();
2123         }
2124     } else {
2125       diagnoseTypo(Corrected, PDiag(diag::err_property_not_found_suggest)
2126                                 << MemberName << QualType(OPT, 0));
2127       return HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc,
2128                                        TypoResult, MemberLoc,
2129                                        SuperLoc, SuperType, Super);
2130     }
2131   }
2132   ObjCInterfaceDecl *ClassDeclared;
2133   if (ObjCIvarDecl *Ivar =
2134       IFace->lookupInstanceVariable(Member, ClassDeclared)) {
2135     QualType T = Ivar->getType();
2136     if (const ObjCObjectPointerType * OBJPT =
2137         T->getAsObjCInterfacePointerType()) {
2138       if (RequireCompleteType(MemberLoc, OBJPT->getPointeeType(),
2139                               diag::err_property_not_as_forward_class,
2140                               MemberName, BaseExpr))
2141         return ExprError();
2142     }
2143     Diag(MemberLoc,
2144          diag::err_ivar_access_using_property_syntax_suggest)
2145     << MemberName << QualType(OPT, 0) << Ivar->getDeclName()
2146     << FixItHint::CreateReplacement(OpLoc, "->");
2147     return ExprError();
2148   }
2149 
2150   Diag(MemberLoc, diag::err_property_not_found)
2151     << MemberName << QualType(OPT, 0);
2152   if (Setter)
2153     Diag(Setter->getLocation(), diag::note_getter_unavailable)
2154           << MemberName << BaseExpr->getSourceRange();
2155   return ExprError();
2156 }
2157 
2158 ExprResult Sema::
2159 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
2160                           IdentifierInfo &propertyName,
2161                           SourceLocation receiverNameLoc,
2162                           SourceLocation propertyNameLoc) {
2163 
2164   IdentifierInfo *receiverNamePtr = &receiverName;
2165   ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(receiverNamePtr,
2166                                                   receiverNameLoc);
2167 
2168   QualType SuperType;
2169   if (!IFace) {
2170     // If the "receiver" is 'super' in a method, handle it as an expression-like
2171     // property reference.
2172     if (receiverNamePtr->isStr("super")) {
2173       if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) {
2174         if (auto classDecl = CurMethod->getClassInterface()) {
2175           SuperType = QualType(classDecl->getSuperClassType(), 0);
2176           if (CurMethod->isInstanceMethod()) {
2177             if (SuperType.isNull()) {
2178               // The current class does not have a superclass.
2179               Diag(receiverNameLoc, diag::err_root_class_cannot_use_super)
2180                 << CurMethod->getClassInterface()->getIdentifier();
2181               return ExprError();
2182             }
2183             QualType T = Context.getObjCObjectPointerType(SuperType);
2184 
2185             return HandleExprPropertyRefExpr(T->castAs<ObjCObjectPointerType>(),
2186                                              /*BaseExpr*/nullptr,
2187                                              SourceLocation()/*OpLoc*/,
2188                                              &propertyName,
2189                                              propertyNameLoc,
2190                                              receiverNameLoc, T, true);
2191           }
2192 
2193           // Otherwise, if this is a class method, try dispatching to our
2194           // superclass.
2195           IFace = CurMethod->getClassInterface()->getSuperClass();
2196         }
2197       }
2198     }
2199 
2200     if (!IFace) {
2201       Diag(receiverNameLoc, diag::err_expected_either) << tok::identifier
2202                                                        << tok::l_paren;
2203       return ExprError();
2204     }
2205   }
2206 
2207   Selector GetterSel;
2208   Selector SetterSel;
2209   if (auto PD = IFace->FindPropertyDeclaration(
2210           &propertyName, ObjCPropertyQueryKind::OBJC_PR_query_class)) {
2211     GetterSel = PD->getGetterName();
2212     SetterSel = PD->getSetterName();
2213   } else {
2214     GetterSel = PP.getSelectorTable().getNullarySelector(&propertyName);
2215     SetterSel = SelectorTable::constructSetterSelector(
2216         PP.getIdentifierTable(), PP.getSelectorTable(), &propertyName);
2217   }
2218 
2219   // Search for a declared property first.
2220   ObjCMethodDecl *Getter = IFace->lookupClassMethod(GetterSel);
2221 
2222   // If this reference is in an @implementation, check for 'private' methods.
2223   if (!Getter)
2224     Getter = IFace->lookupPrivateClassMethod(GetterSel);
2225 
2226   if (Getter) {
2227     // FIXME: refactor/share with ActOnMemberReference().
2228     // Check if we can reference this property.
2229     if (DiagnoseUseOfDecl(Getter, propertyNameLoc))
2230       return ExprError();
2231   }
2232 
2233   // Look for the matching setter, in case it is needed.
2234   ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
2235   if (!Setter) {
2236     // If this reference is in an @implementation, also check for 'private'
2237     // methods.
2238     Setter = IFace->lookupPrivateClassMethod(SetterSel);
2239   }
2240   // Look through local category implementations associated with the class.
2241   if (!Setter)
2242     Setter = IFace->getCategoryClassMethod(SetterSel);
2243 
2244   if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc))
2245     return ExprError();
2246 
2247   if (Getter || Setter) {
2248     if (!SuperType.isNull())
2249       return new (Context)
2250           ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
2251                               OK_ObjCProperty, propertyNameLoc, receiverNameLoc,
2252                               SuperType);
2253 
2254     return new (Context) ObjCPropertyRefExpr(
2255         Getter, Setter, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty,
2256         propertyNameLoc, receiverNameLoc, IFace);
2257   }
2258   return ExprError(Diag(propertyNameLoc, diag::err_property_not_found)
2259                      << &propertyName << Context.getObjCInterfaceType(IFace));
2260 }
2261 
2262 namespace {
2263 
2264 class ObjCInterfaceOrSuperCCC final : public CorrectionCandidateCallback {
2265  public:
2266   ObjCInterfaceOrSuperCCC(ObjCMethodDecl *Method) {
2267     // Determine whether "super" is acceptable in the current context.
2268     if (Method && Method->getClassInterface())
2269       WantObjCSuper = Method->getClassInterface()->getSuperClass();
2270   }
2271 
2272   bool ValidateCandidate(const TypoCorrection &candidate) override {
2273     return candidate.getCorrectionDeclAs<ObjCInterfaceDecl>() ||
2274         candidate.isKeyword("super");
2275   }
2276 
2277   std::unique_ptr<CorrectionCandidateCallback> clone() override {
2278     return std::make_unique<ObjCInterfaceOrSuperCCC>(*this);
2279   }
2280 };
2281 
2282 } // end anonymous namespace
2283 
2284 Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S,
2285                                                IdentifierInfo *Name,
2286                                                SourceLocation NameLoc,
2287                                                bool IsSuper,
2288                                                bool HasTrailingDot,
2289                                                ParsedType &ReceiverType) {
2290   ReceiverType = nullptr;
2291 
2292   // If the identifier is "super" and there is no trailing dot, we're
2293   // messaging super. If the identifier is "super" and there is a
2294   // trailing dot, it's an instance message.
2295   if (IsSuper && S->isInObjcMethodScope())
2296     return HasTrailingDot? ObjCInstanceMessage : ObjCSuperMessage;
2297 
2298   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
2299   LookupName(Result, S);
2300 
2301   switch (Result.getResultKind()) {
2302   case LookupResult::NotFound:
2303     // Normal name lookup didn't find anything. If we're in an
2304     // Objective-C method, look for ivars. If we find one, we're done!
2305     // FIXME: This is a hack. Ivar lookup should be part of normal
2306     // lookup.
2307     if (ObjCMethodDecl *Method = getCurMethodDecl()) {
2308       if (!Method->getClassInterface()) {
2309         // Fall back: let the parser try to parse it as an instance message.
2310         return ObjCInstanceMessage;
2311       }
2312 
2313       ObjCInterfaceDecl *ClassDeclared;
2314       if (Method->getClassInterface()->lookupInstanceVariable(Name,
2315                                                               ClassDeclared))
2316         return ObjCInstanceMessage;
2317     }
2318 
2319     // Break out; we'll perform typo correction below.
2320     break;
2321 
2322   case LookupResult::NotFoundInCurrentInstantiation:
2323   case LookupResult::FoundOverloaded:
2324   case LookupResult::FoundUnresolvedValue:
2325   case LookupResult::Ambiguous:
2326     Result.suppressDiagnostics();
2327     return ObjCInstanceMessage;
2328 
2329   case LookupResult::Found: {
2330     // If the identifier is a class or not, and there is a trailing dot,
2331     // it's an instance message.
2332     if (HasTrailingDot)
2333       return ObjCInstanceMessage;
2334     // We found something. If it's a type, then we have a class
2335     // message. Otherwise, it's an instance message.
2336     NamedDecl *ND = Result.getFoundDecl();
2337     QualType T;
2338     if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(ND))
2339       T = Context.getObjCInterfaceType(Class);
2340     else if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) {
2341       T = Context.getTypeDeclType(Type);
2342       DiagnoseUseOfDecl(Type, NameLoc);
2343     }
2344     else
2345       return ObjCInstanceMessage;
2346 
2347     //  We have a class message, and T is the type we're
2348     //  messaging. Build source-location information for it.
2349     TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
2350     ReceiverType = CreateParsedType(T, TSInfo);
2351     return ObjCClassMessage;
2352   }
2353   }
2354 
2355   ObjCInterfaceOrSuperCCC CCC(getCurMethodDecl());
2356   if (TypoCorrection Corrected = CorrectTypo(
2357           Result.getLookupNameInfo(), Result.getLookupKind(), S, nullptr, CCC,
2358           CTK_ErrorRecovery, nullptr, false, nullptr, false)) {
2359     if (Corrected.isKeyword()) {
2360       // If we've found the keyword "super" (the only keyword that would be
2361       // returned by CorrectTypo), this is a send to super.
2362       diagnoseTypo(Corrected,
2363                    PDiag(diag::err_unknown_receiver_suggest) << Name);
2364       return ObjCSuperMessage;
2365     } else if (ObjCInterfaceDecl *Class =
2366                    Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
2367       // If we found a declaration, correct when it refers to an Objective-C
2368       // class.
2369       diagnoseTypo(Corrected,
2370                    PDiag(diag::err_unknown_receiver_suggest) << Name);
2371       QualType T = Context.getObjCInterfaceType(Class);
2372       TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
2373       ReceiverType = CreateParsedType(T, TSInfo);
2374       return ObjCClassMessage;
2375     }
2376   }
2377 
2378   // Fall back: let the parser try to parse it as an instance message.
2379   return ObjCInstanceMessage;
2380 }
2381 
2382 ExprResult Sema::ActOnSuperMessage(Scope *S,
2383                                    SourceLocation SuperLoc,
2384                                    Selector Sel,
2385                                    SourceLocation LBracLoc,
2386                                    ArrayRef<SourceLocation> SelectorLocs,
2387                                    SourceLocation RBracLoc,
2388                                    MultiExprArg Args) {
2389   // Determine whether we are inside a method or not.
2390   ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc);
2391   if (!Method) {
2392     Diag(SuperLoc, diag::err_invalid_receiver_to_message_super);
2393     return ExprError();
2394   }
2395 
2396   ObjCInterfaceDecl *Class = Method->getClassInterface();
2397   if (!Class) {
2398     Diag(SuperLoc, diag::err_no_super_class_message)
2399       << Method->getDeclName();
2400     return ExprError();
2401   }
2402 
2403   QualType SuperTy(Class->getSuperClassType(), 0);
2404   if (SuperTy.isNull()) {
2405     // The current class does not have a superclass.
2406     Diag(SuperLoc, diag::err_root_class_cannot_use_super)
2407       << Class->getIdentifier();
2408     return ExprError();
2409   }
2410 
2411   // We are in a method whose class has a superclass, so 'super'
2412   // is acting as a keyword.
2413   if (Method->getSelector() == Sel)
2414     getCurFunction()->ObjCShouldCallSuper = false;
2415 
2416   if (Method->isInstanceMethod()) {
2417     // Since we are in an instance method, this is an instance
2418     // message to the superclass instance.
2419     SuperTy = Context.getObjCObjectPointerType(SuperTy);
2420     return BuildInstanceMessage(nullptr, SuperTy, SuperLoc,
2421                                 Sel, /*Method=*/nullptr,
2422                                 LBracLoc, SelectorLocs, RBracLoc, Args);
2423   }
2424 
2425   // Since we are in a class method, this is a class message to
2426   // the superclass.
2427   return BuildClassMessage(/*ReceiverTypeInfo=*/nullptr,
2428                            SuperTy,
2429                            SuperLoc, Sel, /*Method=*/nullptr,
2430                            LBracLoc, SelectorLocs, RBracLoc, Args);
2431 }
2432 
2433 ExprResult Sema::BuildClassMessageImplicit(QualType ReceiverType,
2434                                            bool isSuperReceiver,
2435                                            SourceLocation Loc,
2436                                            Selector Sel,
2437                                            ObjCMethodDecl *Method,
2438                                            MultiExprArg Args) {
2439   TypeSourceInfo *receiverTypeInfo = nullptr;
2440   if (!ReceiverType.isNull())
2441     receiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType);
2442 
2443   assert(((isSuperReceiver && Loc.isValid()) || receiverTypeInfo) &&
2444          "Either the super receiver location needs to be valid or the receiver "
2445          "needs valid type source information");
2446   return BuildClassMessage(receiverTypeInfo, ReceiverType,
2447                           /*SuperLoc=*/isSuperReceiver ? Loc : SourceLocation(),
2448                            Sel, Method, Loc, Loc, Loc, Args,
2449                            /*isImplicit=*/true);
2450 }
2451 
2452 static void applyCocoaAPICheck(Sema &S, const ObjCMessageExpr *Msg,
2453                                unsigned DiagID,
2454                                bool (*refactor)(const ObjCMessageExpr *,
2455                                               const NSAPI &, edit::Commit &)) {
2456   SourceLocation MsgLoc = Msg->getExprLoc();
2457   if (S.Diags.isIgnored(DiagID, MsgLoc))
2458     return;
2459 
2460   SourceManager &SM = S.SourceMgr;
2461   edit::Commit ECommit(SM, S.LangOpts);
2462   if (refactor(Msg,*S.NSAPIObj, ECommit)) {
2463     auto Builder = S.Diag(MsgLoc, DiagID)
2464                    << Msg->getSelector() << Msg->getSourceRange();
2465     // FIXME: Don't emit diagnostic at all if fixits are non-commitable.
2466     if (!ECommit.isCommitable())
2467       return;
2468     for (edit::Commit::edit_iterator
2469            I = ECommit.edit_begin(), E = ECommit.edit_end(); I != E; ++I) {
2470       const edit::Commit::Edit &Edit = *I;
2471       switch (Edit.Kind) {
2472       case edit::Commit::Act_Insert:
2473         Builder.AddFixItHint(FixItHint::CreateInsertion(Edit.OrigLoc,
2474                                                         Edit.Text,
2475                                                         Edit.BeforePrev));
2476         break;
2477       case edit::Commit::Act_InsertFromRange:
2478         Builder.AddFixItHint(
2479             FixItHint::CreateInsertionFromRange(Edit.OrigLoc,
2480                                                 Edit.getInsertFromRange(SM),
2481                                                 Edit.BeforePrev));
2482         break;
2483       case edit::Commit::Act_Remove:
2484         Builder.AddFixItHint(FixItHint::CreateRemoval(Edit.getFileRange(SM)));
2485         break;
2486       }
2487     }
2488   }
2489 }
2490 
2491 static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) {
2492   applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use,
2493                      edit::rewriteObjCRedundantCallWithLiteral);
2494 }
2495 
2496 static void checkFoundationAPI(Sema &S, SourceLocation Loc,
2497                                const ObjCMethodDecl *Method,
2498                                ArrayRef<Expr *> Args, QualType ReceiverType,
2499                                bool IsClassObjectCall) {
2500   // Check if this is a performSelector method that uses a selector that returns
2501   // a record or a vector type.
2502   if (Method->getSelector().getMethodFamily() != OMF_performSelector ||
2503       Args.empty())
2504     return;
2505   const auto *SE = dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens());
2506   if (!SE)
2507     return;
2508   ObjCMethodDecl *ImpliedMethod;
2509   if (!IsClassObjectCall) {
2510     const auto *OPT = ReceiverType->getAs<ObjCObjectPointerType>();
2511     if (!OPT || !OPT->getInterfaceDecl())
2512       return;
2513     ImpliedMethod =
2514         OPT->getInterfaceDecl()->lookupInstanceMethod(SE->getSelector());
2515     if (!ImpliedMethod)
2516       ImpliedMethod =
2517           OPT->getInterfaceDecl()->lookupPrivateMethod(SE->getSelector());
2518   } else {
2519     const auto *IT = ReceiverType->getAs<ObjCInterfaceType>();
2520     if (!IT)
2521       return;
2522     ImpliedMethod = IT->getDecl()->lookupClassMethod(SE->getSelector());
2523     if (!ImpliedMethod)
2524       ImpliedMethod =
2525           IT->getDecl()->lookupPrivateClassMethod(SE->getSelector());
2526   }
2527   if (!ImpliedMethod)
2528     return;
2529   QualType Ret = ImpliedMethod->getReturnType();
2530   if (Ret->isRecordType() || Ret->isVectorType() || Ret->isExtVectorType()) {
2531     S.Diag(Loc, diag::warn_objc_unsafe_perform_selector)
2532         << Method->getSelector()
2533         << (!Ret->isRecordType()
2534                 ? /*Vector*/ 2
2535                 : Ret->isUnionType() ? /*Union*/ 1 : /*Struct*/ 0);
2536     S.Diag(ImpliedMethod->getBeginLoc(),
2537            diag::note_objc_unsafe_perform_selector_method_declared_here)
2538         << ImpliedMethod->getSelector() << Ret;
2539   }
2540 }
2541 
2542 /// Diagnose use of %s directive in an NSString which is being passed
2543 /// as formatting string to formatting method.
2544 static void
2545 DiagnoseCStringFormatDirectiveInObjCAPI(Sema &S,
2546                                         ObjCMethodDecl *Method,
2547                                         Selector Sel,
2548                                         Expr **Args, unsigned NumArgs) {
2549   unsigned Idx = 0;
2550   bool Format = false;
2551   ObjCStringFormatFamily SFFamily = Sel.getStringFormatFamily();
2552   if (SFFamily == ObjCStringFormatFamily::SFF_NSString) {
2553     Idx = 0;
2554     Format = true;
2555   }
2556   else if (Method) {
2557     for (const auto *I : Method->specific_attrs<FormatAttr>()) {
2558       if (S.GetFormatNSStringIdx(I, Idx)) {
2559         Format = true;
2560         break;
2561       }
2562     }
2563   }
2564   if (!Format || NumArgs <= Idx)
2565     return;
2566 
2567   Expr *FormatExpr = Args[Idx];
2568   if (ObjCStringLiteral *OSL =
2569       dyn_cast<ObjCStringLiteral>(FormatExpr->IgnoreParenImpCasts())) {
2570     StringLiteral *FormatString = OSL->getString();
2571     if (S.FormatStringHasSArg(FormatString)) {
2572       S.Diag(FormatExpr->getExprLoc(), diag::warn_objc_cdirective_format_string)
2573         << "%s" << 0 << 0;
2574       if (Method)
2575         S.Diag(Method->getLocation(), diag::note_method_declared_at)
2576           << Method->getDeclName();
2577     }
2578   }
2579 }
2580 
2581 /// Build an Objective-C class message expression.
2582 ///
2583 /// This routine takes care of both normal class messages and
2584 /// class messages to the superclass.
2585 ///
2586 /// \param ReceiverTypeInfo Type source information that describes the
2587 /// receiver of this message. This may be NULL, in which case we are
2588 /// sending to the superclass and \p SuperLoc must be a valid source
2589 /// location.
2590 
2591 /// \param ReceiverType The type of the object receiving the
2592 /// message. When \p ReceiverTypeInfo is non-NULL, this is the same
2593 /// type as that refers to. For a superclass send, this is the type of
2594 /// the superclass.
2595 ///
2596 /// \param SuperLoc The location of the "super" keyword in a
2597 /// superclass message.
2598 ///
2599 /// \param Sel The selector to which the message is being sent.
2600 ///
2601 /// \param Method The method that this class message is invoking, if
2602 /// already known.
2603 ///
2604 /// \param LBracLoc The location of the opening square bracket ']'.
2605 ///
2606 /// \param RBracLoc The location of the closing square bracket ']'.
2607 ///
2608 /// \param ArgsIn The message arguments.
2609 ExprResult Sema::BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
2610                                    QualType ReceiverType,
2611                                    SourceLocation SuperLoc,
2612                                    Selector Sel,
2613                                    ObjCMethodDecl *Method,
2614                                    SourceLocation LBracLoc,
2615                                    ArrayRef<SourceLocation> SelectorLocs,
2616                                    SourceLocation RBracLoc,
2617                                    MultiExprArg ArgsIn,
2618                                    bool isImplicit) {
2619   SourceLocation Loc = SuperLoc.isValid()? SuperLoc
2620     : ReceiverTypeInfo->getTypeLoc().getSourceRange().getBegin();
2621   if (LBracLoc.isInvalid()) {
2622     Diag(Loc, diag::err_missing_open_square_message_send)
2623       << FixItHint::CreateInsertion(Loc, "[");
2624     LBracLoc = Loc;
2625   }
2626   ArrayRef<SourceLocation> SelectorSlotLocs;
2627   if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2628     SelectorSlotLocs = SelectorLocs;
2629   else
2630     SelectorSlotLocs = Loc;
2631   SourceLocation SelLoc = SelectorSlotLocs.front();
2632 
2633   if (ReceiverType->isDependentType()) {
2634     // If the receiver type is dependent, we can't type-check anything
2635     // at this point. Build a dependent expression.
2636     unsigned NumArgs = ArgsIn.size();
2637     Expr **Args = ArgsIn.data();
2638     assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2639     return ObjCMessageExpr::Create(Context, ReceiverType, VK_PRValue, LBracLoc,
2640                                    ReceiverTypeInfo, Sel, SelectorLocs,
2641                                    /*Method=*/nullptr, ArrayRef(Args, NumArgs),
2642                                    RBracLoc, isImplicit);
2643   }
2644 
2645   // Find the class to which we are sending this message.
2646   ObjCInterfaceDecl *Class = nullptr;
2647   const ObjCObjectType *ClassType = ReceiverType->getAs<ObjCObjectType>();
2648   if (!ClassType || !(Class = ClassType->getInterface())) {
2649     Diag(Loc, diag::err_invalid_receiver_class_message)
2650       << ReceiverType;
2651     return ExprError();
2652   }
2653   assert(Class && "We don't know which class we're messaging?");
2654   // objc++ diagnoses during typename annotation.
2655   if (!getLangOpts().CPlusPlus)
2656     (void)DiagnoseUseOfDecl(Class, SelectorSlotLocs);
2657   // Find the method we are messaging.
2658   if (!Method) {
2659     SourceRange TypeRange
2660       = SuperLoc.isValid()? SourceRange(SuperLoc)
2661                           : ReceiverTypeInfo->getTypeLoc().getSourceRange();
2662     if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class),
2663                             (getLangOpts().ObjCAutoRefCount
2664                                ? diag::err_arc_receiver_forward_class
2665                                : diag::warn_receiver_forward_class),
2666                             TypeRange)) {
2667       // A forward class used in messaging is treated as a 'Class'
2668       Method = LookupFactoryMethodInGlobalPool(Sel,
2669                                                SourceRange(LBracLoc, RBracLoc));
2670       if (Method && !getLangOpts().ObjCAutoRefCount)
2671         Diag(Method->getLocation(), diag::note_method_sent_forward_class)
2672           << Method->getDeclName();
2673     }
2674     if (!Method)
2675       Method = Class->lookupClassMethod(Sel);
2676 
2677     // If we have an implementation in scope, check "private" methods.
2678     if (!Method)
2679       Method = Class->lookupPrivateClassMethod(Sel);
2680 
2681     if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs,
2682                                     nullptr, false, false, Class))
2683       return ExprError();
2684   }
2685 
2686   // Check the argument types and determine the result type.
2687   QualType ReturnType;
2688   ExprValueKind VK = VK_PRValue;
2689 
2690   unsigned NumArgs = ArgsIn.size();
2691   Expr **Args = ArgsIn.data();
2692   if (CheckMessageArgumentTypes(/*Receiver=*/nullptr, ReceiverType,
2693                                 MultiExprArg(Args, NumArgs), Sel, SelectorLocs,
2694                                 Method, true, SuperLoc.isValid(), LBracLoc,
2695                                 RBracLoc, SourceRange(), ReturnType, VK))
2696     return ExprError();
2697 
2698   if (Method && !Method->getReturnType()->isVoidType() &&
2699       RequireCompleteType(LBracLoc, Method->getReturnType(),
2700                           diag::err_illegal_message_expr_incomplete_type))
2701     return ExprError();
2702 
2703   if (Method && Method->isDirectMethod() && SuperLoc.isValid()) {
2704     Diag(SuperLoc, diag::err_messaging_super_with_direct_method)
2705         << FixItHint::CreateReplacement(
2706                SuperLoc, getLangOpts().ObjCAutoRefCount
2707                              ? "self"
2708                              : Method->getClassInterface()->getName());
2709     Diag(Method->getLocation(), diag::note_direct_method_declared_at)
2710         << Method->getDeclName();
2711   }
2712 
2713   // Warn about explicit call of +initialize on its own class. But not on 'super'.
2714   if (Method && Method->getMethodFamily() == OMF_initialize) {
2715     if (!SuperLoc.isValid()) {
2716       const ObjCInterfaceDecl *ID =
2717         dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext());
2718       if (ID == Class) {
2719         Diag(Loc, diag::warn_direct_initialize_call);
2720         Diag(Method->getLocation(), diag::note_method_declared_at)
2721           << Method->getDeclName();
2722       }
2723     }
2724     else if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2725       // [super initialize] is allowed only within an +initialize implementation
2726       if (CurMeth->getMethodFamily() != OMF_initialize) {
2727         Diag(Loc, diag::warn_direct_super_initialize_call);
2728         Diag(Method->getLocation(), diag::note_method_declared_at)
2729           << Method->getDeclName();
2730         Diag(CurMeth->getLocation(), diag::note_method_declared_at)
2731         << CurMeth->getDeclName();
2732       }
2733     }
2734   }
2735 
2736   DiagnoseCStringFormatDirectiveInObjCAPI(*this, Method, Sel, Args, NumArgs);
2737 
2738   // Construct the appropriate ObjCMessageExpr.
2739   ObjCMessageExpr *Result;
2740   if (SuperLoc.isValid())
2741     Result = ObjCMessageExpr::Create(
2742         Context, ReturnType, VK, LBracLoc, SuperLoc, /*IsInstanceSuper=*/false,
2743         ReceiverType, Sel, SelectorLocs, Method, ArrayRef(Args, NumArgs),
2744         RBracLoc, isImplicit);
2745   else {
2746     Result = ObjCMessageExpr::Create(
2747         Context, ReturnType, VK, LBracLoc, ReceiverTypeInfo, Sel, SelectorLocs,
2748         Method, ArrayRef(Args, NumArgs), RBracLoc, isImplicit);
2749     if (!isImplicit)
2750       checkCocoaAPI(*this, Result);
2751   }
2752   if (Method)
2753     checkFoundationAPI(*this, SelLoc, Method, ArrayRef(Args, NumArgs),
2754                        ReceiverType, /*IsClassObjectCall=*/true);
2755   return MaybeBindToTemporary(Result);
2756 }
2757 
2758 // ActOnClassMessage - used for both unary and keyword messages.
2759 // ArgExprs is optional - if it is present, the number of expressions
2760 // is obtained from Sel.getNumArgs().
2761 ExprResult Sema::ActOnClassMessage(Scope *S,
2762                                    ParsedType Receiver,
2763                                    Selector Sel,
2764                                    SourceLocation LBracLoc,
2765                                    ArrayRef<SourceLocation> SelectorLocs,
2766                                    SourceLocation RBracLoc,
2767                                    MultiExprArg Args) {
2768   TypeSourceInfo *ReceiverTypeInfo;
2769   QualType ReceiverType = GetTypeFromParser(Receiver, &ReceiverTypeInfo);
2770   if (ReceiverType.isNull())
2771     return ExprError();
2772 
2773   if (!ReceiverTypeInfo)
2774     ReceiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType, LBracLoc);
2775 
2776   return BuildClassMessage(ReceiverTypeInfo, ReceiverType,
2777                            /*SuperLoc=*/SourceLocation(), Sel,
2778                            /*Method=*/nullptr, LBracLoc, SelectorLocs, RBracLoc,
2779                            Args);
2780 }
2781 
2782 ExprResult Sema::BuildInstanceMessageImplicit(Expr *Receiver,
2783                                               QualType ReceiverType,
2784                                               SourceLocation Loc,
2785                                               Selector Sel,
2786                                               ObjCMethodDecl *Method,
2787                                               MultiExprArg Args) {
2788   return BuildInstanceMessage(Receiver, ReceiverType,
2789                               /*SuperLoc=*/!Receiver ? Loc : SourceLocation(),
2790                               Sel, Method, Loc, Loc, Loc, Args,
2791                               /*isImplicit=*/true);
2792 }
2793 
2794 static bool isMethodDeclaredInRootProtocol(Sema &S, const ObjCMethodDecl *M) {
2795   if (!S.NSAPIObj)
2796     return false;
2797   const auto *Protocol = dyn_cast<ObjCProtocolDecl>(M->getDeclContext());
2798   if (!Protocol)
2799     return false;
2800   const IdentifierInfo *II = S.NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
2801   if (const auto *RootClass = dyn_cast_or_null<ObjCInterfaceDecl>(
2802           S.LookupSingleName(S.TUScope, II, Protocol->getBeginLoc(),
2803                              Sema::LookupOrdinaryName))) {
2804     for (const ObjCProtocolDecl *P : RootClass->all_referenced_protocols()) {
2805       if (P->getCanonicalDecl() == Protocol->getCanonicalDecl())
2806         return true;
2807     }
2808   }
2809   return false;
2810 }
2811 
2812 /// Build an Objective-C instance message expression.
2813 ///
2814 /// This routine takes care of both normal instance messages and
2815 /// instance messages to the superclass instance.
2816 ///
2817 /// \param Receiver The expression that computes the object that will
2818 /// receive this message. This may be empty, in which case we are
2819 /// sending to the superclass instance and \p SuperLoc must be a valid
2820 /// source location.
2821 ///
2822 /// \param ReceiverType The (static) type of the object receiving the
2823 /// message. When a \p Receiver expression is provided, this is the
2824 /// same type as that expression. For a superclass instance send, this
2825 /// is a pointer to the type of the superclass.
2826 ///
2827 /// \param SuperLoc The location of the "super" keyword in a
2828 /// superclass instance message.
2829 ///
2830 /// \param Sel The selector to which the message is being sent.
2831 ///
2832 /// \param Method The method that this instance message is invoking, if
2833 /// already known.
2834 ///
2835 /// \param LBracLoc The location of the opening square bracket ']'.
2836 ///
2837 /// \param RBracLoc The location of the closing square bracket ']'.
2838 ///
2839 /// \param ArgsIn The message arguments.
2840 ExprResult Sema::BuildInstanceMessage(Expr *Receiver,
2841                                       QualType ReceiverType,
2842                                       SourceLocation SuperLoc,
2843                                       Selector Sel,
2844                                       ObjCMethodDecl *Method,
2845                                       SourceLocation LBracLoc,
2846                                       ArrayRef<SourceLocation> SelectorLocs,
2847                                       SourceLocation RBracLoc,
2848                                       MultiExprArg ArgsIn,
2849                                       bool isImplicit) {
2850   assert((Receiver || SuperLoc.isValid()) && "If the Receiver is null, the "
2851                                              "SuperLoc must be valid so we can "
2852                                              "use it instead.");
2853 
2854   // The location of the receiver.
2855   SourceLocation Loc = SuperLoc.isValid() ? SuperLoc : Receiver->getBeginLoc();
2856   SourceRange RecRange =
2857       SuperLoc.isValid()? SuperLoc : Receiver->getSourceRange();
2858   ArrayRef<SourceLocation> SelectorSlotLocs;
2859   if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2860     SelectorSlotLocs = SelectorLocs;
2861   else
2862     SelectorSlotLocs = Loc;
2863   SourceLocation SelLoc = SelectorSlotLocs.front();
2864 
2865   if (LBracLoc.isInvalid()) {
2866     Diag(Loc, diag::err_missing_open_square_message_send)
2867       << FixItHint::CreateInsertion(Loc, "[");
2868     LBracLoc = Loc;
2869   }
2870 
2871   // If we have a receiver expression, perform appropriate promotions
2872   // and determine receiver type.
2873   if (Receiver) {
2874     if (Receiver->hasPlaceholderType()) {
2875       ExprResult Result;
2876       if (Receiver->getType() == Context.UnknownAnyTy)
2877         Result = forceUnknownAnyToType(Receiver, Context.getObjCIdType());
2878       else
2879         Result = CheckPlaceholderExpr(Receiver);
2880       if (Result.isInvalid()) return ExprError();
2881       Receiver = Result.get();
2882     }
2883 
2884     if (Receiver->isTypeDependent()) {
2885       // If the receiver is type-dependent, we can't type-check anything
2886       // at this point. Build a dependent expression.
2887       unsigned NumArgs = ArgsIn.size();
2888       Expr **Args = ArgsIn.data();
2889       assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2890       return ObjCMessageExpr::Create(
2891           Context, Context.DependentTy, VK_PRValue, LBracLoc, Receiver, Sel,
2892           SelectorLocs, /*Method=*/nullptr, ArrayRef(Args, NumArgs), RBracLoc,
2893           isImplicit);
2894     }
2895 
2896     // If necessary, apply function/array conversion to the receiver.
2897     // C99 6.7.5.3p[7,8].
2898     ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver);
2899     if (Result.isInvalid())
2900       return ExprError();
2901     Receiver = Result.get();
2902     ReceiverType = Receiver->getType();
2903 
2904     // If the receiver is an ObjC pointer, a block pointer, or an
2905     // __attribute__((NSObject)) pointer, we don't need to do any
2906     // special conversion in order to look up a receiver.
2907     if (ReceiverType->isObjCRetainableType()) {
2908       // do nothing
2909     } else if (!getLangOpts().ObjCAutoRefCount &&
2910                !Context.getObjCIdType().isNull() &&
2911                (ReceiverType->isPointerType() ||
2912                 ReceiverType->isIntegerType())) {
2913       // Implicitly convert integers and pointers to 'id' but emit a warning.
2914       // But not in ARC.
2915       Diag(Loc, diag::warn_bad_receiver_type) << ReceiverType << RecRange;
2916       if (ReceiverType->isPointerType()) {
2917         Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2918                                      CK_CPointerToObjCPointerCast).get();
2919       } else {
2920         // TODO: specialized warning on null receivers?
2921         bool IsNull = Receiver->isNullPointerConstant(Context,
2922                                               Expr::NPC_ValueDependentIsNull);
2923         CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer;
2924         Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2925                                      Kind).get();
2926       }
2927       ReceiverType = Receiver->getType();
2928     } else if (getLangOpts().CPlusPlus) {
2929       // The receiver must be a complete type.
2930       if (RequireCompleteType(Loc, Receiver->getType(),
2931                               diag::err_incomplete_receiver_type))
2932         return ExprError();
2933 
2934       ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver);
2935       if (result.isUsable()) {
2936         Receiver = result.get();
2937         ReceiverType = Receiver->getType();
2938       }
2939     }
2940   }
2941 
2942   // There's a somewhat weird interaction here where we assume that we
2943   // won't actually have a method unless we also don't need to do some
2944   // of the more detailed type-checking on the receiver.
2945 
2946   if (!Method) {
2947     // Handle messages to id and __kindof types (where we use the
2948     // global method pool).
2949     const ObjCObjectType *typeBound = nullptr;
2950     bool receiverIsIdLike = ReceiverType->isObjCIdOrObjectKindOfType(Context,
2951                                                                      typeBound);
2952     if (receiverIsIdLike || ReceiverType->isBlockPointerType() ||
2953         (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) {
2954       SmallVector<ObjCMethodDecl*, 4> Methods;
2955       // If we have a type bound, further filter the methods.
2956       CollectMultipleMethodsInGlobalPool(Sel, Methods, true/*InstanceFirst*/,
2957                                          true/*CheckTheOther*/, typeBound);
2958       if (!Methods.empty()) {
2959         // We choose the first method as the initial candidate, then try to
2960         // select a better one.
2961         Method = Methods[0];
2962 
2963         if (ObjCMethodDecl *BestMethod =
2964             SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(), Methods))
2965           Method = BestMethod;
2966 
2967         if (!AreMultipleMethodsInGlobalPool(Sel, Method,
2968                                             SourceRange(LBracLoc, RBracLoc),
2969                                             receiverIsIdLike, Methods))
2970           DiagnoseUseOfDecl(Method, SelectorSlotLocs);
2971       }
2972     } else if (ReceiverType->isObjCClassOrClassKindOfType() ||
2973                ReceiverType->isObjCQualifiedClassType()) {
2974       // Handle messages to Class.
2975       // We allow sending a message to a qualified Class ("Class<foo>"), which
2976       // is ok as long as one of the protocols implements the selector (if not,
2977       // warn).
2978       if (!ReceiverType->isObjCClassOrClassKindOfType()) {
2979         const ObjCObjectPointerType *QClassTy
2980           = ReceiverType->getAsObjCQualifiedClassType();
2981         // Search protocols for class methods.
2982         Method = LookupMethodInQualifiedType(Sel, QClassTy, false);
2983         if (!Method) {
2984           Method = LookupMethodInQualifiedType(Sel, QClassTy, true);
2985           // warn if instance method found for a Class message.
2986           if (Method && !isMethodDeclaredInRootProtocol(*this, Method)) {
2987             Diag(SelLoc, diag::warn_instance_method_on_class_found)
2988               << Method->getSelector() << Sel;
2989             Diag(Method->getLocation(), diag::note_method_declared_at)
2990               << Method->getDeclName();
2991           }
2992         }
2993       } else {
2994         if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2995           if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) {
2996             // As a guess, try looking for the method in the current interface.
2997             // This very well may not produce the "right" method.
2998 
2999             // First check the public methods in the class interface.
3000             Method = ClassDecl->lookupClassMethod(Sel);
3001 
3002             if (!Method)
3003               Method = ClassDecl->lookupPrivateClassMethod(Sel);
3004 
3005             if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs))
3006               return ExprError();
3007           }
3008         }
3009         if (!Method) {
3010           // If not messaging 'self', look for any factory method named 'Sel'.
3011           if (!Receiver || !isSelfExpr(Receiver)) {
3012             // If no class (factory) method was found, check if an _instance_
3013             // method of the same name exists in the root class only.
3014             SmallVector<ObjCMethodDecl*, 4> Methods;
3015             CollectMultipleMethodsInGlobalPool(Sel, Methods,
3016                                                false/*InstanceFirst*/,
3017                                                true/*CheckTheOther*/);
3018             if (!Methods.empty()) {
3019               // We choose the first method as the initial candidate, then try
3020               // to select a better one.
3021               Method = Methods[0];
3022 
3023               // If we find an instance method, emit warning.
3024               if (Method->isInstanceMethod()) {
3025                 if (const ObjCInterfaceDecl *ID =
3026                     dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
3027                   if (ID->getSuperClass())
3028                     Diag(SelLoc, diag::warn_root_inst_method_not_found)
3029                         << Sel << SourceRange(LBracLoc, RBracLoc);
3030                 }
3031               }
3032 
3033              if (ObjCMethodDecl *BestMethod =
3034                  SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(),
3035                                   Methods))
3036                Method = BestMethod;
3037             }
3038           }
3039         }
3040       }
3041     } else {
3042       ObjCInterfaceDecl *ClassDecl = nullptr;
3043 
3044       // We allow sending a message to a qualified ID ("id<foo>"), which is ok as
3045       // long as one of the protocols implements the selector (if not, warn).
3046       // And as long as message is not deprecated/unavailable (warn if it is).
3047       if (const ObjCObjectPointerType *QIdTy
3048                                    = ReceiverType->getAsObjCQualifiedIdType()) {
3049         // Search protocols for instance methods.
3050         Method = LookupMethodInQualifiedType(Sel, QIdTy, true);
3051         if (!Method)
3052           Method = LookupMethodInQualifiedType(Sel, QIdTy, false);
3053         if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs))
3054           return ExprError();
3055       } else if (const ObjCObjectPointerType *OCIType
3056                    = ReceiverType->getAsObjCInterfacePointerType()) {
3057         // We allow sending a message to a pointer to an interface (an object).
3058         ClassDecl = OCIType->getInterfaceDecl();
3059 
3060         // Try to complete the type. Under ARC, this is a hard error from which
3061         // we don't try to recover.
3062         // FIXME: In the non-ARC case, this will still be a hard error if the
3063         // definition is found in a module that's not visible.
3064         const ObjCInterfaceDecl *forwardClass = nullptr;
3065         if (RequireCompleteType(Loc, OCIType->getPointeeType(),
3066                                 getLangOpts().ObjCAutoRefCount
3067                                     ? diag::err_arc_receiver_forward_instance
3068                                     : diag::warn_receiver_forward_instance,
3069                                 RecRange)) {
3070           if (getLangOpts().ObjCAutoRefCount)
3071             return ExprError();
3072 
3073           forwardClass = OCIType->getInterfaceDecl();
3074           Diag(Receiver ? Receiver->getBeginLoc() : SuperLoc,
3075                diag::note_receiver_is_id);
3076           Method = nullptr;
3077         } else {
3078           Method = ClassDecl->lookupInstanceMethod(Sel);
3079         }
3080 
3081         if (!Method)
3082           // Search protocol qualifiers.
3083           Method = LookupMethodInQualifiedType(Sel, OCIType, true);
3084 
3085         if (!Method) {
3086           // If we have implementations in scope, check "private" methods.
3087           Method = ClassDecl->lookupPrivateMethod(Sel);
3088 
3089           if (!Method && getLangOpts().ObjCAutoRefCount) {
3090             Diag(SelLoc, diag::err_arc_may_not_respond)
3091               << OCIType->getPointeeType() << Sel << RecRange
3092               << SourceRange(SelectorLocs.front(), SelectorLocs.back());
3093             return ExprError();
3094           }
3095 
3096           if (!Method && (!Receiver || !isSelfExpr(Receiver))) {
3097             // If we still haven't found a method, look in the global pool. This
3098             // behavior isn't very desirable, however we need it for GCC
3099             // compatibility. FIXME: should we deviate??
3100             if (OCIType->qual_empty()) {
3101               SmallVector<ObjCMethodDecl*, 4> Methods;
3102               CollectMultipleMethodsInGlobalPool(Sel, Methods,
3103                                                  true/*InstanceFirst*/,
3104                                                  false/*CheckTheOther*/);
3105               if (!Methods.empty()) {
3106                 // We choose the first method as the initial candidate, then try
3107                 // to select a better one.
3108                 Method = Methods[0];
3109 
3110                 if (ObjCMethodDecl *BestMethod =
3111                     SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(),
3112                                      Methods))
3113                   Method = BestMethod;
3114 
3115                 AreMultipleMethodsInGlobalPool(Sel, Method,
3116                                                SourceRange(LBracLoc, RBracLoc),
3117                                                true/*receiverIdOrClass*/,
3118                                                Methods);
3119               }
3120               if (Method && !forwardClass)
3121                 Diag(SelLoc, diag::warn_maynot_respond)
3122                   << OCIType->getInterfaceDecl()->getIdentifier()
3123                   << Sel << RecRange;
3124             }
3125           }
3126         }
3127         if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs, forwardClass))
3128           return ExprError();
3129       } else {
3130         // Reject other random receiver types (e.g. structs).
3131         Diag(Loc, diag::err_bad_receiver_type) << ReceiverType << RecRange;
3132         return ExprError();
3133       }
3134     }
3135   }
3136 
3137   FunctionScopeInfo *DIFunctionScopeInfo =
3138     (Method && Method->getMethodFamily() == OMF_init)
3139       ? getEnclosingFunction() : nullptr;
3140 
3141   if (Method && Method->isDirectMethod()) {
3142     if (ReceiverType->isObjCIdType() && !isImplicit) {
3143       Diag(Receiver->getExprLoc(),
3144            diag::err_messaging_unqualified_id_with_direct_method);
3145       Diag(Method->getLocation(), diag::note_direct_method_declared_at)
3146           << Method->getDeclName();
3147     }
3148 
3149     // Under ARC, self can't be assigned, and doing a direct call to `self`
3150     // when it's a Class is hence safe.  For other cases, we can't trust `self`
3151     // is what we think it is, so we reject it.
3152     if (ReceiverType->isObjCClassType() && !isImplicit &&
3153         !(Receiver->isObjCSelfExpr() && getLangOpts().ObjCAutoRefCount)) {
3154       {
3155         auto Builder = Diag(Receiver->getExprLoc(),
3156                             diag::err_messaging_class_with_direct_method);
3157         if (Receiver->isObjCSelfExpr()) {
3158           Builder.AddFixItHint(FixItHint::CreateReplacement(
3159               RecRange, Method->getClassInterface()->getName()));
3160         }
3161       }
3162       Diag(Method->getLocation(), diag::note_direct_method_declared_at)
3163           << Method->getDeclName();
3164     }
3165 
3166     if (SuperLoc.isValid()) {
3167       {
3168         auto Builder =
3169             Diag(SuperLoc, diag::err_messaging_super_with_direct_method);
3170         if (ReceiverType->isObjCClassType()) {
3171           Builder.AddFixItHint(FixItHint::CreateReplacement(
3172               SuperLoc, Method->getClassInterface()->getName()));
3173         } else {
3174           Builder.AddFixItHint(FixItHint::CreateReplacement(SuperLoc, "self"));
3175         }
3176       }
3177       Diag(Method->getLocation(), diag::note_direct_method_declared_at)
3178           << Method->getDeclName();
3179     }
3180   } else if (ReceiverType->isObjCIdType() && !isImplicit) {
3181     Diag(Receiver->getExprLoc(), diag::warn_messaging_unqualified_id);
3182   }
3183 
3184   if (DIFunctionScopeInfo &&
3185       DIFunctionScopeInfo->ObjCIsDesignatedInit &&
3186       (SuperLoc.isValid() || isSelfExpr(Receiver))) {
3187     bool isDesignatedInitChain = false;
3188     if (SuperLoc.isValid()) {
3189       if (const ObjCObjectPointerType *
3190             OCIType = ReceiverType->getAsObjCInterfacePointerType()) {
3191         if (const ObjCInterfaceDecl *ID = OCIType->getInterfaceDecl()) {
3192           // Either we know this is a designated initializer or we
3193           // conservatively assume it because we don't know for sure.
3194           if (!ID->declaresOrInheritsDesignatedInitializers() ||
3195               ID->isDesignatedInitializer(Sel)) {
3196             isDesignatedInitChain = true;
3197             DIFunctionScopeInfo->ObjCWarnForNoDesignatedInitChain = false;
3198           }
3199         }
3200       }
3201     }
3202     if (!isDesignatedInitChain) {
3203       const ObjCMethodDecl *InitMethod = nullptr;
3204       bool isDesignated =
3205         getCurMethodDecl()->isDesignatedInitializerForTheInterface(&InitMethod);
3206       assert(isDesignated && InitMethod);
3207       (void)isDesignated;
3208       Diag(SelLoc, SuperLoc.isValid() ?
3209              diag::warn_objc_designated_init_non_designated_init_call :
3210              diag::warn_objc_designated_init_non_super_designated_init_call);
3211       Diag(InitMethod->getLocation(),
3212            diag::note_objc_designated_init_marked_here);
3213     }
3214   }
3215 
3216   if (DIFunctionScopeInfo &&
3217       DIFunctionScopeInfo->ObjCIsSecondaryInit &&
3218       (SuperLoc.isValid() || isSelfExpr(Receiver))) {
3219     if (SuperLoc.isValid()) {
3220       Diag(SelLoc, diag::warn_objc_secondary_init_super_init_call);
3221     } else {
3222       DIFunctionScopeInfo->ObjCWarnForNoInitDelegation = false;
3223     }
3224   }
3225 
3226   // Check the message arguments.
3227   unsigned NumArgs = ArgsIn.size();
3228   Expr **Args = ArgsIn.data();
3229   QualType ReturnType;
3230   ExprValueKind VK = VK_PRValue;
3231   bool ClassMessage = (ReceiverType->isObjCClassType() ||
3232                        ReceiverType->isObjCQualifiedClassType());
3233   if (CheckMessageArgumentTypes(Receiver, ReceiverType,
3234                                 MultiExprArg(Args, NumArgs), Sel, SelectorLocs,
3235                                 Method, ClassMessage, SuperLoc.isValid(),
3236                                 LBracLoc, RBracLoc, RecRange, ReturnType, VK))
3237     return ExprError();
3238 
3239   if (Method && !Method->getReturnType()->isVoidType() &&
3240       RequireCompleteType(LBracLoc, Method->getReturnType(),
3241                           diag::err_illegal_message_expr_incomplete_type))
3242     return ExprError();
3243 
3244   // In ARC, forbid the user from sending messages to
3245   // retain/release/autorelease/dealloc/retainCount explicitly.
3246   if (getLangOpts().ObjCAutoRefCount) {
3247     ObjCMethodFamily family =
3248       (Method ? Method->getMethodFamily() : Sel.getMethodFamily());
3249     switch (family) {
3250     case OMF_init:
3251       if (Method)
3252         checkInitMethod(Method, ReceiverType);
3253       break;
3254 
3255     case OMF_None:
3256     case OMF_alloc:
3257     case OMF_copy:
3258     case OMF_finalize:
3259     case OMF_mutableCopy:
3260     case OMF_new:
3261     case OMF_self:
3262     case OMF_initialize:
3263       break;
3264 
3265     case OMF_dealloc:
3266     case OMF_retain:
3267     case OMF_release:
3268     case OMF_autorelease:
3269     case OMF_retainCount:
3270       Diag(SelLoc, diag::err_arc_illegal_explicit_message)
3271         << Sel << RecRange;
3272       break;
3273 
3274     case OMF_performSelector:
3275       if (Method && NumArgs >= 1) {
3276         if (const auto *SelExp =
3277                 dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens())) {
3278           Selector ArgSel = SelExp->getSelector();
3279           ObjCMethodDecl *SelMethod =
3280             LookupInstanceMethodInGlobalPool(ArgSel,
3281                                              SelExp->getSourceRange());
3282           if (!SelMethod)
3283             SelMethod =
3284               LookupFactoryMethodInGlobalPool(ArgSel,
3285                                               SelExp->getSourceRange());
3286           if (SelMethod) {
3287             ObjCMethodFamily SelFamily = SelMethod->getMethodFamily();
3288             switch (SelFamily) {
3289               case OMF_alloc:
3290               case OMF_copy:
3291               case OMF_mutableCopy:
3292               case OMF_new:
3293               case OMF_init:
3294                 // Issue error, unless ns_returns_not_retained.
3295                 if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
3296                   // selector names a +1 method
3297                   Diag(SelLoc,
3298                        diag::err_arc_perform_selector_retains);
3299                   Diag(SelMethod->getLocation(), diag::note_method_declared_at)
3300                     << SelMethod->getDeclName();
3301                 }
3302                 break;
3303               default:
3304                 // +0 call. OK. unless ns_returns_retained.
3305                 if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) {
3306                   // selector names a +1 method
3307                   Diag(SelLoc,
3308                        diag::err_arc_perform_selector_retains);
3309                   Diag(SelMethod->getLocation(), diag::note_method_declared_at)
3310                     << SelMethod->getDeclName();
3311                 }
3312                 break;
3313             }
3314           }
3315         } else {
3316           // error (may leak).
3317           Diag(SelLoc, diag::warn_arc_perform_selector_leaks);
3318           Diag(Args[0]->getExprLoc(), diag::note_used_here);
3319         }
3320       }
3321       break;
3322     }
3323   }
3324 
3325   DiagnoseCStringFormatDirectiveInObjCAPI(*this, Method, Sel, Args, NumArgs);
3326 
3327   // Construct the appropriate ObjCMessageExpr instance.
3328   ObjCMessageExpr *Result;
3329   if (SuperLoc.isValid())
3330     Result = ObjCMessageExpr::Create(
3331         Context, ReturnType, VK, LBracLoc, SuperLoc, /*IsInstanceSuper=*/true,
3332         ReceiverType, Sel, SelectorLocs, Method, ArrayRef(Args, NumArgs),
3333         RBracLoc, isImplicit);
3334   else {
3335     Result = ObjCMessageExpr::Create(
3336         Context, ReturnType, VK, LBracLoc, Receiver, Sel, SelectorLocs, Method,
3337         ArrayRef(Args, NumArgs), RBracLoc, isImplicit);
3338     if (!isImplicit)
3339       checkCocoaAPI(*this, Result);
3340   }
3341   if (Method) {
3342     bool IsClassObjectCall = ClassMessage;
3343     // 'self' message receivers in class methods should be treated as message
3344     // sends to the class object in order for the semantic checks to be
3345     // performed correctly. Messages to 'super' already count as class messages,
3346     // so they don't need to be handled here.
3347     if (Receiver && isSelfExpr(Receiver)) {
3348       if (const auto *OPT = ReceiverType->getAs<ObjCObjectPointerType>()) {
3349         if (OPT->getObjectType()->isObjCClass()) {
3350           if (const auto *CurMeth = getCurMethodDecl()) {
3351             IsClassObjectCall = true;
3352             ReceiverType =
3353                 Context.getObjCInterfaceType(CurMeth->getClassInterface());
3354           }
3355         }
3356       }
3357     }
3358     checkFoundationAPI(*this, SelLoc, Method, ArrayRef(Args, NumArgs),
3359                        ReceiverType, IsClassObjectCall);
3360   }
3361 
3362   if (getLangOpts().ObjCAutoRefCount) {
3363     // In ARC, annotate delegate init calls.
3364     if (Result->getMethodFamily() == OMF_init &&
3365         (SuperLoc.isValid() || isSelfExpr(Receiver))) {
3366       // Only consider init calls *directly* in init implementations,
3367       // not within blocks.
3368       ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(CurContext);
3369       if (method && method->getMethodFamily() == OMF_init) {
3370         // The implicit assignment to self means we also don't want to
3371         // consume the result.
3372         Result->setDelegateInitCall(true);
3373         return Result;
3374       }
3375     }
3376 
3377     // In ARC, check for message sends which are likely to introduce
3378     // retain cycles.
3379     checkRetainCycles(Result);
3380   }
3381 
3382   if (getLangOpts().ObjCWeak) {
3383     if (!isImplicit && Method) {
3384       if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {
3385         bool IsWeak =
3386             Prop->getPropertyAttributes() & ObjCPropertyAttribute::kind_weak;
3387         if (!IsWeak && Sel.isUnarySelector())
3388           IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak;
3389         if (IsWeak && !isUnevaluatedContext() &&
3390             !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, LBracLoc))
3391           getCurFunction()->recordUseOfWeak(Result, Prop);
3392       }
3393     }
3394   }
3395 
3396   CheckObjCCircularContainer(Result);
3397 
3398   return MaybeBindToTemporary(Result);
3399 }
3400 
3401 static void RemoveSelectorFromWarningCache(Sema &S, Expr* Arg) {
3402   if (ObjCSelectorExpr *OSE =
3403       dyn_cast<ObjCSelectorExpr>(Arg->IgnoreParenCasts())) {
3404     Selector Sel = OSE->getSelector();
3405     SourceLocation Loc = OSE->getAtLoc();
3406     auto Pos = S.ReferencedSelectors.find(Sel);
3407     if (Pos != S.ReferencedSelectors.end() && Pos->second == Loc)
3408       S.ReferencedSelectors.erase(Pos);
3409   }
3410 }
3411 
3412 // ActOnInstanceMessage - used for both unary and keyword messages.
3413 // ArgExprs is optional - if it is present, the number of expressions
3414 // is obtained from Sel.getNumArgs().
3415 ExprResult Sema::ActOnInstanceMessage(Scope *S,
3416                                       Expr *Receiver,
3417                                       Selector Sel,
3418                                       SourceLocation LBracLoc,
3419                                       ArrayRef<SourceLocation> SelectorLocs,
3420                                       SourceLocation RBracLoc,
3421                                       MultiExprArg Args) {
3422   if (!Receiver)
3423     return ExprError();
3424 
3425   // A ParenListExpr can show up while doing error recovery with invalid code.
3426   if (isa<ParenListExpr>(Receiver)) {
3427     ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver);
3428     if (Result.isInvalid()) return ExprError();
3429     Receiver = Result.get();
3430   }
3431 
3432   if (RespondsToSelectorSel.isNull()) {
3433     IdentifierInfo *SelectorId = &Context.Idents.get("respondsToSelector");
3434     RespondsToSelectorSel = Context.Selectors.getUnarySelector(SelectorId);
3435   }
3436   if (Sel == RespondsToSelectorSel)
3437     RemoveSelectorFromWarningCache(*this, Args[0]);
3438 
3439   return BuildInstanceMessage(Receiver, Receiver->getType(),
3440                               /*SuperLoc=*/SourceLocation(), Sel,
3441                               /*Method=*/nullptr, LBracLoc, SelectorLocs,
3442                               RBracLoc, Args);
3443 }
3444 
3445 enum ARCConversionTypeClass {
3446   /// int, void, struct A
3447   ACTC_none,
3448 
3449   /// id, void (^)()
3450   ACTC_retainable,
3451 
3452   /// id*, id***, void (^*)(),
3453   ACTC_indirectRetainable,
3454 
3455   /// void* might be a normal C type, or it might a CF type.
3456   ACTC_voidPtr,
3457 
3458   /// struct A*
3459   ACTC_coreFoundation
3460 };
3461 
3462 static bool isAnyRetainable(ARCConversionTypeClass ACTC) {
3463   return (ACTC == ACTC_retainable ||
3464           ACTC == ACTC_coreFoundation ||
3465           ACTC == ACTC_voidPtr);
3466 }
3467 
3468 static bool isAnyCLike(ARCConversionTypeClass ACTC) {
3469   return ACTC == ACTC_none ||
3470          ACTC == ACTC_voidPtr ||
3471          ACTC == ACTC_coreFoundation;
3472 }
3473 
3474 static ARCConversionTypeClass classifyTypeForARCConversion(QualType type) {
3475   bool isIndirect = false;
3476 
3477   // Ignore an outermost reference type.
3478   if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
3479     type = ref->getPointeeType();
3480     isIndirect = true;
3481   }
3482 
3483   // Drill through pointers and arrays recursively.
3484   while (true) {
3485     if (const PointerType *ptr = type->getAs<PointerType>()) {
3486       type = ptr->getPointeeType();
3487 
3488       // The first level of pointer may be the innermost pointer on a CF type.
3489       if (!isIndirect) {
3490         if (type->isVoidType()) return ACTC_voidPtr;
3491         if (type->isRecordType()) return ACTC_coreFoundation;
3492       }
3493     } else if (const ArrayType *array = type->getAsArrayTypeUnsafe()) {
3494       type = QualType(array->getElementType()->getBaseElementTypeUnsafe(), 0);
3495     } else {
3496       break;
3497     }
3498     isIndirect = true;
3499   }
3500 
3501   if (isIndirect) {
3502     if (type->isObjCARCBridgableType())
3503       return ACTC_indirectRetainable;
3504     return ACTC_none;
3505   }
3506 
3507   if (type->isObjCARCBridgableType())
3508     return ACTC_retainable;
3509 
3510   return ACTC_none;
3511 }
3512 
3513 namespace {
3514   /// A result from the cast checker.
3515   enum ACCResult {
3516     /// Cannot be casted.
3517     ACC_invalid,
3518 
3519     /// Can be safely retained or not retained.
3520     ACC_bottom,
3521 
3522     /// Can be casted at +0.
3523     ACC_plusZero,
3524 
3525     /// Can be casted at +1.
3526     ACC_plusOne
3527   };
3528   ACCResult merge(ACCResult left, ACCResult right) {
3529     if (left == right) return left;
3530     if (left == ACC_bottom) return right;
3531     if (right == ACC_bottom) return left;
3532     return ACC_invalid;
3533   }
3534 
3535   /// A checker which white-lists certain expressions whose conversion
3536   /// to or from retainable type would otherwise be forbidden in ARC.
3537   class ARCCastChecker : public StmtVisitor<ARCCastChecker, ACCResult> {
3538     typedef StmtVisitor<ARCCastChecker, ACCResult> super;
3539 
3540     ASTContext &Context;
3541     ARCConversionTypeClass SourceClass;
3542     ARCConversionTypeClass TargetClass;
3543     bool Diagnose;
3544 
3545     static bool isCFType(QualType type) {
3546       // Someday this can use ns_bridged.  For now, it has to do this.
3547       return type->isCARCBridgableType();
3548     }
3549 
3550   public:
3551     ARCCastChecker(ASTContext &Context, ARCConversionTypeClass source,
3552                    ARCConversionTypeClass target, bool diagnose)
3553       : Context(Context), SourceClass(source), TargetClass(target),
3554         Diagnose(diagnose) {}
3555 
3556     using super::Visit;
3557     ACCResult Visit(Expr *e) {
3558       return super::Visit(e->IgnoreParens());
3559     }
3560 
3561     ACCResult VisitStmt(Stmt *s) {
3562       return ACC_invalid;
3563     }
3564 
3565     /// Null pointer constants can be casted however you please.
3566     ACCResult VisitExpr(Expr *e) {
3567       if (e->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull))
3568         return ACC_bottom;
3569       return ACC_invalid;
3570     }
3571 
3572     /// Objective-C string literals can be safely casted.
3573     ACCResult VisitObjCStringLiteral(ObjCStringLiteral *e) {
3574       // If we're casting to any retainable type, go ahead.  Global
3575       // strings are immune to retains, so this is bottom.
3576       if (isAnyRetainable(TargetClass)) return ACC_bottom;
3577 
3578       return ACC_invalid;
3579     }
3580 
3581     /// Look through certain implicit and explicit casts.
3582     ACCResult VisitCastExpr(CastExpr *e) {
3583       switch (e->getCastKind()) {
3584         case CK_NullToPointer:
3585           return ACC_bottom;
3586 
3587         case CK_NoOp:
3588         case CK_LValueToRValue:
3589         case CK_BitCast:
3590         case CK_CPointerToObjCPointerCast:
3591         case CK_BlockPointerToObjCPointerCast:
3592         case CK_AnyPointerToBlockPointerCast:
3593           return Visit(e->getSubExpr());
3594 
3595         default:
3596           return ACC_invalid;
3597       }
3598     }
3599 
3600     /// Look through unary extension.
3601     ACCResult VisitUnaryExtension(UnaryOperator *e) {
3602       return Visit(e->getSubExpr());
3603     }
3604 
3605     /// Ignore the LHS of a comma operator.
3606     ACCResult VisitBinComma(BinaryOperator *e) {
3607       return Visit(e->getRHS());
3608     }
3609 
3610     /// Conditional operators are okay if both sides are okay.
3611     ACCResult VisitConditionalOperator(ConditionalOperator *e) {
3612       ACCResult left = Visit(e->getTrueExpr());
3613       if (left == ACC_invalid) return ACC_invalid;
3614       return merge(left, Visit(e->getFalseExpr()));
3615     }
3616 
3617     /// Look through pseudo-objects.
3618     ACCResult VisitPseudoObjectExpr(PseudoObjectExpr *e) {
3619       // If we're getting here, we should always have a result.
3620       return Visit(e->getResultExpr());
3621     }
3622 
3623     /// Statement expressions are okay if their result expression is okay.
3624     ACCResult VisitStmtExpr(StmtExpr *e) {
3625       return Visit(e->getSubStmt()->body_back());
3626     }
3627 
3628     /// Some declaration references are okay.
3629     ACCResult VisitDeclRefExpr(DeclRefExpr *e) {
3630       VarDecl *var = dyn_cast<VarDecl>(e->getDecl());
3631       // References to global constants are okay.
3632       if (isAnyRetainable(TargetClass) &&
3633           isAnyRetainable(SourceClass) &&
3634           var &&
3635           !var->hasDefinition(Context) &&
3636           var->getType().isConstQualified()) {
3637 
3638         // In system headers, they can also be assumed to be immune to retains.
3639         // These are things like 'kCFStringTransformToLatin'.
3640         if (Context.getSourceManager().isInSystemHeader(var->getLocation()))
3641           return ACC_bottom;
3642 
3643         return ACC_plusZero;
3644       }
3645 
3646       // Nothing else.
3647       return ACC_invalid;
3648     }
3649 
3650     /// Some calls are okay.
3651     ACCResult VisitCallExpr(CallExpr *e) {
3652       if (FunctionDecl *fn = e->getDirectCallee())
3653         if (ACCResult result = checkCallToFunction(fn))
3654           return result;
3655 
3656       return super::VisitCallExpr(e);
3657     }
3658 
3659     ACCResult checkCallToFunction(FunctionDecl *fn) {
3660       // Require a CF*Ref return type.
3661       if (!isCFType(fn->getReturnType()))
3662         return ACC_invalid;
3663 
3664       if (!isAnyRetainable(TargetClass))
3665         return ACC_invalid;
3666 
3667       // Honor an explicit 'not retained' attribute.
3668       if (fn->hasAttr<CFReturnsNotRetainedAttr>())
3669         return ACC_plusZero;
3670 
3671       // Honor an explicit 'retained' attribute, except that for
3672       // now we're not going to permit implicit handling of +1 results,
3673       // because it's a bit frightening.
3674       if (fn->hasAttr<CFReturnsRetainedAttr>())
3675         return Diagnose ? ACC_plusOne
3676                         : ACC_invalid; // ACC_plusOne if we start accepting this
3677 
3678       // Recognize this specific builtin function, which is used by CFSTR.
3679       unsigned builtinID = fn->getBuiltinID();
3680       if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString)
3681         return ACC_bottom;
3682 
3683       // Otherwise, don't do anything implicit with an unaudited function.
3684       if (!fn->hasAttr<CFAuditedTransferAttr>())
3685         return ACC_invalid;
3686 
3687       // Otherwise, it's +0 unless it follows the create convention.
3688       if (ento::coreFoundation::followsCreateRule(fn))
3689         return Diagnose ? ACC_plusOne
3690                         : ACC_invalid; // ACC_plusOne if we start accepting this
3691 
3692       return ACC_plusZero;
3693     }
3694 
3695     ACCResult VisitObjCMessageExpr(ObjCMessageExpr *e) {
3696       return checkCallToMethod(e->getMethodDecl());
3697     }
3698 
3699     ACCResult VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *e) {
3700       ObjCMethodDecl *method;
3701       if (e->isExplicitProperty())
3702         method = e->getExplicitProperty()->getGetterMethodDecl();
3703       else
3704         method = e->getImplicitPropertyGetter();
3705       return checkCallToMethod(method);
3706     }
3707 
3708     ACCResult checkCallToMethod(ObjCMethodDecl *method) {
3709       if (!method) return ACC_invalid;
3710 
3711       // Check for message sends to functions returning CF types.  We
3712       // just obey the Cocoa conventions with these, even though the
3713       // return type is CF.
3714       if (!isAnyRetainable(TargetClass) || !isCFType(method->getReturnType()))
3715         return ACC_invalid;
3716 
3717       // If the method is explicitly marked not-retained, it's +0.
3718       if (method->hasAttr<CFReturnsNotRetainedAttr>())
3719         return ACC_plusZero;
3720 
3721       // If the method is explicitly marked as returning retained, or its
3722       // selector follows a +1 Cocoa convention, treat it as +1.
3723       if (method->hasAttr<CFReturnsRetainedAttr>())
3724         return ACC_plusOne;
3725 
3726       switch (method->getSelector().getMethodFamily()) {
3727       case OMF_alloc:
3728       case OMF_copy:
3729       case OMF_mutableCopy:
3730       case OMF_new:
3731         return ACC_plusOne;
3732 
3733       default:
3734         // Otherwise, treat it as +0.
3735         return ACC_plusZero;
3736       }
3737     }
3738   };
3739 } // end anonymous namespace
3740 
3741 bool Sema::isKnownName(StringRef name) {
3742   if (name.empty())
3743     return false;
3744   LookupResult R(*this, &Context.Idents.get(name), SourceLocation(),
3745                  Sema::LookupOrdinaryName);
3746   return LookupName(R, TUScope, false);
3747 }
3748 
3749 template <typename DiagBuilderT>
3750 static void addFixitForObjCARCConversion(
3751     Sema &S, DiagBuilderT &DiagB, Sema::CheckedConversionKind CCK,
3752     SourceLocation afterLParen, QualType castType, Expr *castExpr,
3753     Expr *realCast, const char *bridgeKeyword, const char *CFBridgeName) {
3754   // We handle C-style and implicit casts here.
3755   switch (CCK) {
3756   case Sema::CCK_ImplicitConversion:
3757   case Sema::CCK_ForBuiltinOverloadedOp:
3758   case Sema::CCK_CStyleCast:
3759   case Sema::CCK_OtherCast:
3760     break;
3761   case Sema::CCK_FunctionalCast:
3762     return;
3763   }
3764 
3765   if (CFBridgeName) {
3766     if (CCK == Sema::CCK_OtherCast) {
3767       if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
3768         SourceRange range(NCE->getOperatorLoc(),
3769                           NCE->getAngleBrackets().getEnd());
3770         SmallString<32> BridgeCall;
3771 
3772         SourceManager &SM = S.getSourceManager();
3773         char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
3774         if (Lexer::isAsciiIdentifierContinueChar(PrevChar, S.getLangOpts()))
3775           BridgeCall += ' ';
3776 
3777         BridgeCall += CFBridgeName;
3778         DiagB.AddFixItHint(FixItHint::CreateReplacement(range, BridgeCall));
3779       }
3780       return;
3781     }
3782     Expr *castedE = castExpr;
3783     if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(castedE))
3784       castedE = CCE->getSubExpr();
3785     castedE = castedE->IgnoreImpCasts();
3786     SourceRange range = castedE->getSourceRange();
3787 
3788     SmallString<32> BridgeCall;
3789 
3790     SourceManager &SM = S.getSourceManager();
3791     char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
3792     if (Lexer::isAsciiIdentifierContinueChar(PrevChar, S.getLangOpts()))
3793       BridgeCall += ' ';
3794 
3795     BridgeCall += CFBridgeName;
3796 
3797     if (isa<ParenExpr>(castedE)) {
3798       DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3799                          BridgeCall));
3800     } else {
3801       BridgeCall += '(';
3802       DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3803                                                     BridgeCall));
3804       DiagB.AddFixItHint(FixItHint::CreateInsertion(
3805                                        S.getLocForEndOfToken(range.getEnd()),
3806                                        ")"));
3807     }
3808     return;
3809   }
3810 
3811   if (CCK == Sema::CCK_CStyleCast) {
3812     DiagB.AddFixItHint(FixItHint::CreateInsertion(afterLParen, bridgeKeyword));
3813   } else if (CCK == Sema::CCK_OtherCast) {
3814     if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
3815       std::string castCode = "(";
3816       castCode += bridgeKeyword;
3817       castCode += castType.getAsString();
3818       castCode += ")";
3819       SourceRange Range(NCE->getOperatorLoc(),
3820                         NCE->getAngleBrackets().getEnd());
3821       DiagB.AddFixItHint(FixItHint::CreateReplacement(Range, castCode));
3822     }
3823   } else {
3824     std::string castCode = "(";
3825     castCode += bridgeKeyword;
3826     castCode += castType.getAsString();
3827     castCode += ")";
3828     Expr *castedE = castExpr->IgnoreImpCasts();
3829     SourceRange range = castedE->getSourceRange();
3830     if (isa<ParenExpr>(castedE)) {
3831       DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3832                          castCode));
3833     } else {
3834       castCode += "(";
3835       DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3836                                                     castCode));
3837       DiagB.AddFixItHint(FixItHint::CreateInsertion(
3838                                        S.getLocForEndOfToken(range.getEnd()),
3839                                        ")"));
3840     }
3841   }
3842 }
3843 
3844 template <typename T>
3845 static inline T *getObjCBridgeAttr(const TypedefType *TD) {
3846   TypedefNameDecl *TDNDecl = TD->getDecl();
3847   QualType QT = TDNDecl->getUnderlyingType();
3848   if (QT->isPointerType()) {
3849     QT = QT->getPointeeType();
3850     if (const RecordType *RT = QT->getAs<RecordType>()) {
3851       for (auto *Redecl : RT->getDecl()->getMostRecentDecl()->redecls()) {
3852         if (auto *attr = Redecl->getAttr<T>())
3853           return attr;
3854       }
3855     }
3856   }
3857   return nullptr;
3858 }
3859 
3860 static ObjCBridgeRelatedAttr *ObjCBridgeRelatedAttrFromType(QualType T,
3861                                                             TypedefNameDecl *&TDNDecl) {
3862   while (const auto *TD = T->getAs<TypedefType>()) {
3863     TDNDecl = TD->getDecl();
3864     if (ObjCBridgeRelatedAttr *ObjCBAttr =
3865         getObjCBridgeAttr<ObjCBridgeRelatedAttr>(TD))
3866       return ObjCBAttr;
3867     T = TDNDecl->getUnderlyingType();
3868   }
3869   return nullptr;
3870 }
3871 
3872 static void
3873 diagnoseObjCARCConversion(Sema &S, SourceRange castRange,
3874                           QualType castType, ARCConversionTypeClass castACTC,
3875                           Expr *castExpr, Expr *realCast,
3876                           ARCConversionTypeClass exprACTC,
3877                           Sema::CheckedConversionKind CCK) {
3878   SourceLocation loc =
3879     (castRange.isValid() ? castRange.getBegin() : castExpr->getExprLoc());
3880 
3881   if (S.makeUnavailableInSystemHeader(loc,
3882                                  UnavailableAttr::IR_ARCForbiddenConversion))
3883     return;
3884 
3885   QualType castExprType = castExpr->getType();
3886   // Defer emitting a diagnostic for bridge-related casts; that will be
3887   // handled by CheckObjCBridgeRelatedConversions.
3888   TypedefNameDecl *TDNDecl = nullptr;
3889   if ((castACTC == ACTC_coreFoundation &&  exprACTC == ACTC_retainable &&
3890        ObjCBridgeRelatedAttrFromType(castType, TDNDecl)) ||
3891       (exprACTC == ACTC_coreFoundation && castACTC == ACTC_retainable &&
3892        ObjCBridgeRelatedAttrFromType(castExprType, TDNDecl)))
3893     return;
3894 
3895   unsigned srcKind = 0;
3896   switch (exprACTC) {
3897   case ACTC_none:
3898   case ACTC_coreFoundation:
3899   case ACTC_voidPtr:
3900     srcKind = (castExprType->isPointerType() ? 1 : 0);
3901     break;
3902   case ACTC_retainable:
3903     srcKind = (castExprType->isBlockPointerType() ? 2 : 3);
3904     break;
3905   case ACTC_indirectRetainable:
3906     srcKind = 4;
3907     break;
3908   }
3909 
3910   // Check whether this could be fixed with a bridge cast.
3911   SourceLocation afterLParen = S.getLocForEndOfToken(castRange.getBegin());
3912   SourceLocation noteLoc = afterLParen.isValid() ? afterLParen : loc;
3913 
3914   unsigned convKindForDiag = Sema::isCast(CCK) ? 0 : 1;
3915 
3916   // Bridge from an ARC type to a CF type.
3917   if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {
3918 
3919     S.Diag(loc, diag::err_arc_cast_requires_bridge)
3920       << convKindForDiag
3921       << 2 // of C pointer type
3922       << castExprType
3923       << unsigned(castType->isBlockPointerType()) // to ObjC|block type
3924       << castType
3925       << castRange
3926       << castExpr->getSourceRange();
3927     bool br = S.isKnownName("CFBridgingRelease");
3928     ACCResult CreateRule =
3929       ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3930     assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3931     if (CreateRule != ACC_plusOne)
3932     {
3933       auto DiagB = (CCK != Sema::CCK_OtherCast)
3934                        ? S.Diag(noteLoc, diag::note_arc_bridge)
3935                        : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3936 
3937       addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3938                                    castType, castExpr, realCast, "__bridge ",
3939                                    nullptr);
3940     }
3941     if (CreateRule != ACC_plusZero)
3942     {
3943       auto DiagB = (CCK == Sema::CCK_OtherCast && !br)
3944                        ? S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer)
3945                              << castExprType
3946                        : S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3947                                 diag::note_arc_bridge_transfer)
3948                              << castExprType << br;
3949 
3950       addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3951                                    castType, castExpr, realCast, "__bridge_transfer ",
3952                                    br ? "CFBridgingRelease" : nullptr);
3953     }
3954 
3955     return;
3956   }
3957 
3958   // Bridge from a CF type to an ARC type.
3959   if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {
3960     bool br = S.isKnownName("CFBridgingRetain");
3961     S.Diag(loc, diag::err_arc_cast_requires_bridge)
3962       << convKindForDiag
3963       << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type
3964       << castExprType
3965       << 2 // to C pointer type
3966       << castType
3967       << castRange
3968       << castExpr->getSourceRange();
3969     ACCResult CreateRule =
3970       ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3971     assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3972     if (CreateRule != ACC_plusOne)
3973     {
3974       auto DiagB = (CCK != Sema::CCK_OtherCast)
3975                        ? S.Diag(noteLoc, diag::note_arc_bridge)
3976                        : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3977       addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3978                                    castType, castExpr, realCast, "__bridge ",
3979                                    nullptr);
3980     }
3981     if (CreateRule != ACC_plusZero)
3982     {
3983       auto DiagB = (CCK == Sema::CCK_OtherCast && !br)
3984                        ? S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained)
3985                              << castType
3986                        : S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3987                                 diag::note_arc_bridge_retained)
3988                              << castType << br;
3989 
3990       addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3991                                    castType, castExpr, realCast, "__bridge_retained ",
3992                                    br ? "CFBridgingRetain" : nullptr);
3993     }
3994 
3995     return;
3996   }
3997 
3998   S.Diag(loc, diag::err_arc_mismatched_cast)
3999     << !convKindForDiag
4000     << srcKind << castExprType << castType
4001     << castRange << castExpr->getSourceRange();
4002 }
4003 
4004 template <typename TB>
4005 static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr,
4006                                   bool &HadTheAttribute, bool warn) {
4007   QualType T = castExpr->getType();
4008   HadTheAttribute = false;
4009   while (const auto *TD = T->getAs<TypedefType>()) {
4010     TypedefNameDecl *TDNDecl = TD->getDecl();
4011     if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {
4012       if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {
4013         HadTheAttribute = true;
4014         if (Parm->isStr("id"))
4015           return true;
4016 
4017         // Check for an existing type with this name.
4018         LookupResult R(S, DeclarationName(Parm), SourceLocation(),
4019                        Sema::LookupOrdinaryName);
4020         if (S.LookupName(R, S.TUScope)) {
4021           NamedDecl *Target = R.getFoundDecl();
4022           if (Target && isa<ObjCInterfaceDecl>(Target)) {
4023             ObjCInterfaceDecl *ExprClass = cast<ObjCInterfaceDecl>(Target);
4024             if (const ObjCObjectPointerType *InterfacePointerType =
4025                   castType->getAsObjCInterfacePointerType()) {
4026               ObjCInterfaceDecl *CastClass
4027                 = InterfacePointerType->getObjectType()->getInterface();
4028               if ((CastClass == ExprClass) ||
4029                   (CastClass && CastClass->isSuperClassOf(ExprClass)))
4030                 return true;
4031               if (warn)
4032                 S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge)
4033                     << T << Target->getName() << castType->getPointeeType();
4034               return false;
4035             } else if (castType->isObjCIdType() ||
4036                        (S.Context.ObjCObjectAdoptsQTypeProtocols(
4037                           castType, ExprClass)))
4038               // ok to cast to 'id'.
4039               // casting to id<p-list> is ok if bridge type adopts all of
4040               // p-list protocols.
4041               return true;
4042             else {
4043               if (warn) {
4044                 S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge)
4045                     << T << Target->getName() << castType;
4046                 S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4047                 S.Diag(Target->getBeginLoc(), diag::note_declared_at);
4048               }
4049               return false;
4050            }
4051           }
4052         } else if (!castType->isObjCIdType()) {
4053           S.Diag(castExpr->getBeginLoc(),
4054                  diag::err_objc_cf_bridged_not_interface)
4055               << castExpr->getType() << Parm;
4056           S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4057         }
4058         return true;
4059       }
4060       return false;
4061     }
4062     T = TDNDecl->getUnderlyingType();
4063   }
4064   return true;
4065 }
4066 
4067 template <typename TB>
4068 static bool CheckObjCBridgeCFCast(Sema &S, QualType castType, Expr *castExpr,
4069                                   bool &HadTheAttribute, bool warn) {
4070   QualType T = castType;
4071   HadTheAttribute = false;
4072   while (const auto *TD = T->getAs<TypedefType>()) {
4073     TypedefNameDecl *TDNDecl = TD->getDecl();
4074     if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {
4075       if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {
4076         HadTheAttribute = true;
4077         if (Parm->isStr("id"))
4078           return true;
4079 
4080         NamedDecl *Target = nullptr;
4081         // Check for an existing type with this name.
4082         LookupResult R(S, DeclarationName(Parm), SourceLocation(),
4083                        Sema::LookupOrdinaryName);
4084         if (S.LookupName(R, S.TUScope)) {
4085           Target = R.getFoundDecl();
4086           if (Target && isa<ObjCInterfaceDecl>(Target)) {
4087             ObjCInterfaceDecl *CastClass = cast<ObjCInterfaceDecl>(Target);
4088             if (const ObjCObjectPointerType *InterfacePointerType =
4089                   castExpr->getType()->getAsObjCInterfacePointerType()) {
4090               ObjCInterfaceDecl *ExprClass
4091                 = InterfacePointerType->getObjectType()->getInterface();
4092               if ((CastClass == ExprClass) ||
4093                   (ExprClass && CastClass->isSuperClassOf(ExprClass)))
4094                 return true;
4095               if (warn) {
4096                 S.Diag(castExpr->getBeginLoc(),
4097                        diag::warn_objc_invalid_bridge_to_cf)
4098                     << castExpr->getType()->getPointeeType() << T;
4099                 S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4100               }
4101               return false;
4102             } else if (castExpr->getType()->isObjCIdType() ||
4103                        (S.Context.QIdProtocolsAdoptObjCObjectProtocols(
4104                           castExpr->getType(), CastClass)))
4105               // ok to cast an 'id' expression to a CFtype.
4106               // ok to cast an 'id<plist>' expression to CFtype provided plist
4107               // adopts all of CFtype's ObjetiveC's class plist.
4108               return true;
4109             else {
4110               if (warn) {
4111                 S.Diag(castExpr->getBeginLoc(),
4112                        diag::warn_objc_invalid_bridge_to_cf)
4113                     << castExpr->getType() << castType;
4114                 S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4115                 S.Diag(Target->getBeginLoc(), diag::note_declared_at);
4116               }
4117               return false;
4118             }
4119           }
4120         }
4121         S.Diag(castExpr->getBeginLoc(),
4122                diag::err_objc_ns_bridged_invalid_cfobject)
4123             << castExpr->getType() << castType;
4124         S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4125         if (Target)
4126           S.Diag(Target->getBeginLoc(), diag::note_declared_at);
4127         return true;
4128       }
4129       return false;
4130     }
4131     T = TDNDecl->getUnderlyingType();
4132   }
4133   return true;
4134 }
4135 
4136 void Sema::CheckTollFreeBridgeCast(QualType castType, Expr *castExpr) {
4137   if (!getLangOpts().ObjC)
4138     return;
4139   // warn in presence of __bridge casting to or from a toll free bridge cast.
4140   ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExpr->getType());
4141   ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType);
4142   if (castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) {
4143     bool HasObjCBridgeAttr;
4144     bool ObjCBridgeAttrWillNotWarn =
4145       CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
4146                                             false);
4147     if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr)
4148       return;
4149     bool HasObjCBridgeMutableAttr;
4150     bool ObjCBridgeMutableAttrWillNotWarn =
4151       CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
4152                                                    HasObjCBridgeMutableAttr, false);
4153     if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr)
4154       return;
4155 
4156     if (HasObjCBridgeAttr)
4157       CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
4158                                             true);
4159     else if (HasObjCBridgeMutableAttr)
4160       CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
4161                                                    HasObjCBridgeMutableAttr, true);
4162   }
4163   else if (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable) {
4164     bool HasObjCBridgeAttr;
4165     bool ObjCBridgeAttrWillNotWarn =
4166       CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
4167                                             false);
4168     if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr)
4169       return;
4170     bool HasObjCBridgeMutableAttr;
4171     bool ObjCBridgeMutableAttrWillNotWarn =
4172       CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
4173                                                    HasObjCBridgeMutableAttr, false);
4174     if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr)
4175       return;
4176 
4177     if (HasObjCBridgeAttr)
4178       CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
4179                                             true);
4180     else if (HasObjCBridgeMutableAttr)
4181       CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
4182                                                    HasObjCBridgeMutableAttr, true);
4183   }
4184 }
4185 
4186 void Sema::CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr) {
4187   QualType SrcType = castExpr->getType();
4188   if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(castExpr)) {
4189     if (PRE->isExplicitProperty()) {
4190       if (ObjCPropertyDecl *PDecl = PRE->getExplicitProperty())
4191         SrcType = PDecl->getType();
4192     }
4193     else if (PRE->isImplicitProperty()) {
4194       if (ObjCMethodDecl *Getter = PRE->getImplicitPropertyGetter())
4195         SrcType = Getter->getReturnType();
4196     }
4197   }
4198 
4199   ARCConversionTypeClass srcExprACTC = classifyTypeForARCConversion(SrcType);
4200   ARCConversionTypeClass castExprACTC = classifyTypeForARCConversion(castType);
4201   if (srcExprACTC != ACTC_retainable || castExprACTC != ACTC_coreFoundation)
4202     return;
4203   CheckObjCBridgeRelatedConversions(castExpr->getBeginLoc(), castType, SrcType,
4204                                     castExpr);
4205 }
4206 
4207 bool Sema::CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
4208                                          CastKind &Kind) {
4209   if (!getLangOpts().ObjC)
4210     return false;
4211   ARCConversionTypeClass exprACTC =
4212     classifyTypeForARCConversion(castExpr->getType());
4213   ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType);
4214   if ((castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) ||
4215       (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable)) {
4216     CheckTollFreeBridgeCast(castType, castExpr);
4217     Kind = (castACTC == ACTC_coreFoundation) ? CK_BitCast
4218                                              : CK_CPointerToObjCPointerCast;
4219     return true;
4220   }
4221   return false;
4222 }
4223 
4224 bool Sema::checkObjCBridgeRelatedComponents(SourceLocation Loc,
4225                                             QualType DestType, QualType SrcType,
4226                                             ObjCInterfaceDecl *&RelatedClass,
4227                                             ObjCMethodDecl *&ClassMethod,
4228                                             ObjCMethodDecl *&InstanceMethod,
4229                                             TypedefNameDecl *&TDNDecl,
4230                                             bool CfToNs, bool Diagnose) {
4231   QualType T = CfToNs ? SrcType : DestType;
4232   ObjCBridgeRelatedAttr *ObjCBAttr = ObjCBridgeRelatedAttrFromType(T, TDNDecl);
4233   if (!ObjCBAttr)
4234     return false;
4235 
4236   IdentifierInfo *RCId = ObjCBAttr->getRelatedClass();
4237   IdentifierInfo *CMId = ObjCBAttr->getClassMethod();
4238   IdentifierInfo *IMId = ObjCBAttr->getInstanceMethod();
4239   if (!RCId)
4240     return false;
4241   NamedDecl *Target = nullptr;
4242   // Check for an existing type with this name.
4243   LookupResult R(*this, DeclarationName(RCId), SourceLocation(),
4244                  Sema::LookupOrdinaryName);
4245   if (!LookupName(R, TUScope)) {
4246     if (Diagnose) {
4247       Diag(Loc, diag::err_objc_bridged_related_invalid_class) << RCId
4248             << SrcType << DestType;
4249       Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4250     }
4251     return false;
4252   }
4253   Target = R.getFoundDecl();
4254   if (Target && isa<ObjCInterfaceDecl>(Target))
4255     RelatedClass = cast<ObjCInterfaceDecl>(Target);
4256   else {
4257     if (Diagnose) {
4258       Diag(Loc, diag::err_objc_bridged_related_invalid_class_name) << RCId
4259             << SrcType << DestType;
4260       Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4261       if (Target)
4262         Diag(Target->getBeginLoc(), diag::note_declared_at);
4263     }
4264     return false;
4265   }
4266 
4267   // Check for an existing class method with the given selector name.
4268   if (CfToNs && CMId) {
4269     Selector Sel = Context.Selectors.getUnarySelector(CMId);
4270     ClassMethod = RelatedClass->lookupMethod(Sel, false);
4271     if (!ClassMethod) {
4272       if (Diagnose) {
4273         Diag(Loc, diag::err_objc_bridged_related_known_method)
4274               << SrcType << DestType << Sel << false;
4275         Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4276       }
4277       return false;
4278     }
4279   }
4280 
4281   // Check for an existing instance method with the given selector name.
4282   if (!CfToNs && IMId) {
4283     Selector Sel = Context.Selectors.getNullarySelector(IMId);
4284     InstanceMethod = RelatedClass->lookupMethod(Sel, true);
4285     if (!InstanceMethod) {
4286       if (Diagnose) {
4287         Diag(Loc, diag::err_objc_bridged_related_known_method)
4288               << SrcType << DestType << Sel << true;
4289         Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4290       }
4291       return false;
4292     }
4293   }
4294   return true;
4295 }
4296 
4297 bool
4298 Sema::CheckObjCBridgeRelatedConversions(SourceLocation Loc,
4299                                         QualType DestType, QualType SrcType,
4300                                         Expr *&SrcExpr, bool Diagnose) {
4301   ARCConversionTypeClass rhsExprACTC = classifyTypeForARCConversion(SrcType);
4302   ARCConversionTypeClass lhsExprACTC = classifyTypeForARCConversion(DestType);
4303   bool CfToNs = (rhsExprACTC == ACTC_coreFoundation && lhsExprACTC == ACTC_retainable);
4304   bool NsToCf = (rhsExprACTC == ACTC_retainable && lhsExprACTC == ACTC_coreFoundation);
4305   if (!CfToNs && !NsToCf)
4306     return false;
4307 
4308   ObjCInterfaceDecl *RelatedClass;
4309   ObjCMethodDecl *ClassMethod = nullptr;
4310   ObjCMethodDecl *InstanceMethod = nullptr;
4311   TypedefNameDecl *TDNDecl = nullptr;
4312   if (!checkObjCBridgeRelatedComponents(Loc, DestType, SrcType, RelatedClass,
4313                                         ClassMethod, InstanceMethod, TDNDecl,
4314                                         CfToNs, Diagnose))
4315     return false;
4316 
4317   if (CfToNs) {
4318     // Implicit conversion from CF to ObjC object is needed.
4319     if (ClassMethod) {
4320       if (Diagnose) {
4321         std::string ExpressionString = "[";
4322         ExpressionString += RelatedClass->getNameAsString();
4323         ExpressionString += " ";
4324         ExpressionString += ClassMethod->getSelector().getAsString();
4325         SourceLocation SrcExprEndLoc =
4326             getLocForEndOfToken(SrcExpr->getEndLoc());
4327         // Provide a fixit: [RelatedClass ClassMethod SrcExpr]
4328         Diag(Loc, diag::err_objc_bridged_related_known_method)
4329             << SrcType << DestType << ClassMethod->getSelector() << false
4330             << FixItHint::CreateInsertion(SrcExpr->getBeginLoc(),
4331                                           ExpressionString)
4332             << FixItHint::CreateInsertion(SrcExprEndLoc, "]");
4333         Diag(RelatedClass->getBeginLoc(), diag::note_declared_at);
4334         Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4335 
4336         QualType receiverType = Context.getObjCInterfaceType(RelatedClass);
4337         // Argument.
4338         Expr *args[] = { SrcExpr };
4339         ExprResult msg = BuildClassMessageImplicit(receiverType, false,
4340                                       ClassMethod->getLocation(),
4341                                       ClassMethod->getSelector(), ClassMethod,
4342                                       MultiExprArg(args, 1));
4343         SrcExpr = msg.get();
4344       }
4345       return true;
4346     }
4347   }
4348   else {
4349     // Implicit conversion from ObjC type to CF object is needed.
4350     if (InstanceMethod) {
4351       if (Diagnose) {
4352         std::string ExpressionString;
4353         SourceLocation SrcExprEndLoc =
4354             getLocForEndOfToken(SrcExpr->getEndLoc());
4355         if (InstanceMethod->isPropertyAccessor())
4356           if (const ObjCPropertyDecl *PDecl =
4357                   InstanceMethod->findPropertyDecl()) {
4358             // fixit: ObjectExpr.propertyname when it is  aproperty accessor.
4359             ExpressionString = ".";
4360             ExpressionString += PDecl->getNameAsString();
4361             Diag(Loc, diag::err_objc_bridged_related_known_method)
4362                 << SrcType << DestType << InstanceMethod->getSelector() << true
4363                 << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString);
4364           }
4365         if (ExpressionString.empty()) {
4366           // Provide a fixit: [ObjectExpr InstanceMethod]
4367           ExpressionString = " ";
4368           ExpressionString += InstanceMethod->getSelector().getAsString();
4369           ExpressionString += "]";
4370 
4371           Diag(Loc, diag::err_objc_bridged_related_known_method)
4372               << SrcType << DestType << InstanceMethod->getSelector() << true
4373               << FixItHint::CreateInsertion(SrcExpr->getBeginLoc(), "[")
4374               << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString);
4375         }
4376         Diag(RelatedClass->getBeginLoc(), diag::note_declared_at);
4377         Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4378 
4379         ExprResult msg = BuildInstanceMessageImplicit(
4380             SrcExpr, SrcType, InstanceMethod->getLocation(),
4381             InstanceMethod->getSelector(), InstanceMethod, std::nullopt);
4382         SrcExpr = msg.get();
4383       }
4384       return true;
4385     }
4386   }
4387   return false;
4388 }
4389 
4390 Sema::ARCConversionResult
4391 Sema::CheckObjCConversion(SourceRange castRange, QualType castType,
4392                           Expr *&castExpr, CheckedConversionKind CCK,
4393                           bool Diagnose, bool DiagnoseCFAudited,
4394                           BinaryOperatorKind Opc) {
4395   QualType castExprType = castExpr->getType();
4396 
4397   // For the purposes of the classification, we assume reference types
4398   // will bind to temporaries.
4399   QualType effCastType = castType;
4400   if (const ReferenceType *ref = castType->getAs<ReferenceType>())
4401     effCastType = ref->getPointeeType();
4402 
4403   ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExprType);
4404   ARCConversionTypeClass castACTC = classifyTypeForARCConversion(effCastType);
4405   if (exprACTC == castACTC) {
4406     // Check for viability and report error if casting an rvalue to a
4407     // life-time qualifier.
4408     if (castACTC == ACTC_retainable &&
4409         (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) &&
4410         castType != castExprType) {
4411       const Type *DT = castType.getTypePtr();
4412       QualType QDT = castType;
4413       // We desugar some types but not others. We ignore those
4414       // that cannot happen in a cast; i.e. auto, and those which
4415       // should not be de-sugared; i.e typedef.
4416       if (const ParenType *PT = dyn_cast<ParenType>(DT))
4417         QDT = PT->desugar();
4418       else if (const TypeOfType *TP = dyn_cast<TypeOfType>(DT))
4419         QDT = TP->desugar();
4420       else if (const AttributedType *AT = dyn_cast<AttributedType>(DT))
4421         QDT = AT->desugar();
4422       if (QDT != castType &&
4423           QDT.getObjCLifetime() !=  Qualifiers::OCL_None) {
4424         if (Diagnose) {
4425           SourceLocation loc = (castRange.isValid() ? castRange.getBegin()
4426                                                     : castExpr->getExprLoc());
4427           Diag(loc, diag::err_arc_nolifetime_behavior);
4428         }
4429         return ACR_error;
4430       }
4431     }
4432     return ACR_okay;
4433   }
4434 
4435   // The life-time qualifier cast check above is all we need for ObjCWeak.
4436   // ObjCAutoRefCount has more restrictions on what is legal.
4437   if (!getLangOpts().ObjCAutoRefCount)
4438     return ACR_okay;
4439 
4440   if (isAnyCLike(exprACTC) && isAnyCLike(castACTC)) return ACR_okay;
4441 
4442   // Allow all of these types to be cast to integer types (but not
4443   // vice-versa).
4444   if (castACTC == ACTC_none && castType->isIntegralType(Context))
4445     return ACR_okay;
4446 
4447   // Allow casts between pointers to lifetime types (e.g., __strong id*)
4448   // and pointers to void (e.g., cv void *). Casting from void* to lifetime*
4449   // must be explicit.
4450   // Allow conversions between pointers to lifetime types and coreFoundation
4451   // pointers too, but only when the conversions are explicit.
4452   if (exprACTC == ACTC_indirectRetainable &&
4453       (castACTC == ACTC_voidPtr ||
4454        (castACTC == ACTC_coreFoundation && isCast(CCK))))
4455     return ACR_okay;
4456   if (castACTC == ACTC_indirectRetainable &&
4457       (exprACTC == ACTC_voidPtr || exprACTC == ACTC_coreFoundation) &&
4458       isCast(CCK))
4459     return ACR_okay;
4460 
4461   switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) {
4462   // For invalid casts, fall through.
4463   case ACC_invalid:
4464     break;
4465 
4466   // Do nothing for both bottom and +0.
4467   case ACC_bottom:
4468   case ACC_plusZero:
4469     return ACR_okay;
4470 
4471   // If the result is +1, consume it here.
4472   case ACC_plusOne:
4473     castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(),
4474                                         CK_ARCConsumeObject, castExpr, nullptr,
4475                                         VK_PRValue, FPOptionsOverride());
4476     Cleanup.setExprNeedsCleanups(true);
4477     return ACR_okay;
4478   }
4479 
4480   // If this is a non-implicit cast from id or block type to a
4481   // CoreFoundation type, delay complaining in case the cast is used
4482   // in an acceptable context.
4483   if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) && isCast(CCK))
4484     return ACR_unbridged;
4485 
4486   // Issue a diagnostic about a missing @-sign when implicit casting a cstring
4487   // to 'NSString *', instead of falling through to report a "bridge cast"
4488   // diagnostic.
4489   if (castACTC == ACTC_retainable && exprACTC == ACTC_none &&
4490       CheckConversionToObjCLiteral(castType, castExpr, Diagnose))
4491     return ACR_error;
4492 
4493   // Do not issue "bridge cast" diagnostic when implicit casting
4494   // a retainable object to a CF type parameter belonging to an audited
4495   // CF API function. Let caller issue a normal type mismatched diagnostic
4496   // instead.
4497   if ((!DiagnoseCFAudited || exprACTC != ACTC_retainable ||
4498        castACTC != ACTC_coreFoundation) &&
4499       !(exprACTC == ACTC_voidPtr && castACTC == ACTC_retainable &&
4500         (Opc == BO_NE || Opc == BO_EQ))) {
4501     if (Diagnose)
4502       diagnoseObjCARCConversion(*this, castRange, castType, castACTC, castExpr,
4503                                 castExpr, exprACTC, CCK);
4504     return ACR_error;
4505   }
4506   return ACR_okay;
4507 }
4508 
4509 /// Given that we saw an expression with the ARCUnbridgedCastTy
4510 /// placeholder type, complain bitterly.
4511 void Sema::diagnoseARCUnbridgedCast(Expr *e) {
4512   // We expect the spurious ImplicitCastExpr to already have been stripped.
4513   assert(!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
4514   CastExpr *realCast = cast<CastExpr>(e->IgnoreParens());
4515 
4516   SourceRange castRange;
4517   QualType castType;
4518   CheckedConversionKind CCK;
4519 
4520   if (CStyleCastExpr *cast = dyn_cast<CStyleCastExpr>(realCast)) {
4521     castRange = SourceRange(cast->getLParenLoc(), cast->getRParenLoc());
4522     castType = cast->getTypeAsWritten();
4523     CCK = CCK_CStyleCast;
4524   } else if (ExplicitCastExpr *cast = dyn_cast<ExplicitCastExpr>(realCast)) {
4525     castRange = cast->getTypeInfoAsWritten()->getTypeLoc().getSourceRange();
4526     castType = cast->getTypeAsWritten();
4527     CCK = CCK_OtherCast;
4528   } else {
4529     llvm_unreachable("Unexpected ImplicitCastExpr");
4530   }
4531 
4532   ARCConversionTypeClass castACTC =
4533     classifyTypeForARCConversion(castType.getNonReferenceType());
4534 
4535   Expr *castExpr = realCast->getSubExpr();
4536   assert(classifyTypeForARCConversion(castExpr->getType()) == ACTC_retainable);
4537 
4538   diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
4539                             castExpr, realCast, ACTC_retainable, CCK);
4540 }
4541 
4542 /// stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast
4543 /// type, remove the placeholder cast.
4544 Expr *Sema::stripARCUnbridgedCast(Expr *e) {
4545   assert(e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
4546 
4547   if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) {
4548     Expr *sub = stripARCUnbridgedCast(pe->getSubExpr());
4549     return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub);
4550   } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) {
4551     assert(uo->getOpcode() == UO_Extension);
4552     Expr *sub = stripARCUnbridgedCast(uo->getSubExpr());
4553     return UnaryOperator::Create(Context, sub, UO_Extension, sub->getType(),
4554                                  sub->getValueKind(), sub->getObjectKind(),
4555                                  uo->getOperatorLoc(), false,
4556                                  CurFPFeatureOverrides());
4557   } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
4558     assert(!gse->isResultDependent());
4559     assert(!gse->isTypePredicate());
4560 
4561     unsigned n = gse->getNumAssocs();
4562     SmallVector<Expr *, 4> subExprs;
4563     SmallVector<TypeSourceInfo *, 4> subTypes;
4564     subExprs.reserve(n);
4565     subTypes.reserve(n);
4566     for (const GenericSelectionExpr::Association assoc : gse->associations()) {
4567       subTypes.push_back(assoc.getTypeSourceInfo());
4568       Expr *sub = assoc.getAssociationExpr();
4569       if (assoc.isSelected())
4570         sub = stripARCUnbridgedCast(sub);
4571       subExprs.push_back(sub);
4572     }
4573 
4574     return GenericSelectionExpr::Create(
4575         Context, gse->getGenericLoc(), gse->getControllingExpr(), subTypes,
4576         subExprs, gse->getDefaultLoc(), gse->getRParenLoc(),
4577         gse->containsUnexpandedParameterPack(), gse->getResultIndex());
4578   } else {
4579     assert(isa<ImplicitCastExpr>(e) && "bad form of unbridged cast!");
4580     return cast<ImplicitCastExpr>(e)->getSubExpr();
4581   }
4582 }
4583 
4584 bool Sema::CheckObjCARCUnavailableWeakConversion(QualType castType,
4585                                                  QualType exprType) {
4586   QualType canCastType =
4587     Context.getCanonicalType(castType).getUnqualifiedType();
4588   QualType canExprType =
4589     Context.getCanonicalType(exprType).getUnqualifiedType();
4590   if (isa<ObjCObjectPointerType>(canCastType) &&
4591       castType.getObjCLifetime() == Qualifiers::OCL_Weak &&
4592       canExprType->isObjCObjectPointerType()) {
4593     if (const ObjCObjectPointerType *ObjT =
4594         canExprType->getAs<ObjCObjectPointerType>())
4595       if (const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl())
4596         return !ObjI->isArcWeakrefUnavailable();
4597   }
4598   return true;
4599 }
4600 
4601 /// Look for an ObjCReclaimReturnedObject cast and destroy it.
4602 static Expr *maybeUndoReclaimObject(Expr *e) {
4603   Expr *curExpr = e, *prevExpr = nullptr;
4604 
4605   // Walk down the expression until we hit an implicit cast of kind
4606   // ARCReclaimReturnedObject or an Expr that is neither a Paren nor a Cast.
4607   while (true) {
4608     if (auto *pe = dyn_cast<ParenExpr>(curExpr)) {
4609       prevExpr = curExpr;
4610       curExpr = pe->getSubExpr();
4611       continue;
4612     }
4613 
4614     if (auto *ce = dyn_cast<CastExpr>(curExpr)) {
4615       if (auto *ice = dyn_cast<ImplicitCastExpr>(ce))
4616         if (ice->getCastKind() == CK_ARCReclaimReturnedObject) {
4617           if (!prevExpr)
4618             return ice->getSubExpr();
4619           if (auto *pe = dyn_cast<ParenExpr>(prevExpr))
4620             pe->setSubExpr(ice->getSubExpr());
4621           else
4622             cast<CastExpr>(prevExpr)->setSubExpr(ice->getSubExpr());
4623           return e;
4624         }
4625 
4626       prevExpr = curExpr;
4627       curExpr = ce->getSubExpr();
4628       continue;
4629     }
4630 
4631     // Break out of the loop if curExpr is neither a Paren nor a Cast.
4632     break;
4633   }
4634 
4635   return e;
4636 }
4637 
4638 ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc,
4639                                       ObjCBridgeCastKind Kind,
4640                                       SourceLocation BridgeKeywordLoc,
4641                                       TypeSourceInfo *TSInfo,
4642                                       Expr *SubExpr) {
4643   ExprResult SubResult = UsualUnaryConversions(SubExpr);
4644   if (SubResult.isInvalid()) return ExprError();
4645   SubExpr = SubResult.get();
4646 
4647   QualType T = TSInfo->getType();
4648   QualType FromType = SubExpr->getType();
4649 
4650   CastKind CK;
4651 
4652   bool MustConsume = false;
4653   if (T->isDependentType() || SubExpr->isTypeDependent()) {
4654     // Okay: we'll build a dependent expression type.
4655     CK = CK_Dependent;
4656   } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {
4657     // Casting CF -> id
4658     CK = (T->isBlockPointerType() ? CK_AnyPointerToBlockPointerCast
4659                                   : CK_CPointerToObjCPointerCast);
4660     switch (Kind) {
4661     case OBC_Bridge:
4662       break;
4663 
4664     case OBC_BridgeRetained: {
4665       bool br = isKnownName("CFBridgingRelease");
4666       Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
4667         << 2
4668         << FromType
4669         << (T->isBlockPointerType()? 1 : 0)
4670         << T
4671         << SubExpr->getSourceRange()
4672         << Kind;
4673       Diag(BridgeKeywordLoc, diag::note_arc_bridge)
4674         << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge");
4675       Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer)
4676         << FromType << br
4677         << FixItHint::CreateReplacement(BridgeKeywordLoc,
4678                                         br ? "CFBridgingRelease "
4679                                            : "__bridge_transfer ");
4680 
4681       Kind = OBC_Bridge;
4682       break;
4683     }
4684 
4685     case OBC_BridgeTransfer:
4686       // We must consume the Objective-C object produced by the cast.
4687       MustConsume = true;
4688       break;
4689     }
4690   } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {
4691     // Okay: id -> CF
4692     CK = CK_BitCast;
4693     switch (Kind) {
4694     case OBC_Bridge:
4695       // Reclaiming a value that's going to be __bridge-casted to CF
4696       // is very dangerous, so we don't do it.
4697       SubExpr = maybeUndoReclaimObject(SubExpr);
4698       break;
4699 
4700     case OBC_BridgeRetained:
4701       // Produce the object before casting it.
4702       SubExpr = ImplicitCastExpr::Create(Context, FromType, CK_ARCProduceObject,
4703                                          SubExpr, nullptr, VK_PRValue,
4704                                          FPOptionsOverride());
4705       break;
4706 
4707     case OBC_BridgeTransfer: {
4708       bool br = isKnownName("CFBridgingRetain");
4709       Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
4710         << (FromType->isBlockPointerType()? 1 : 0)
4711         << FromType
4712         << 2
4713         << T
4714         << SubExpr->getSourceRange()
4715         << Kind;
4716 
4717       Diag(BridgeKeywordLoc, diag::note_arc_bridge)
4718         << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge ");
4719       Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained)
4720         << T << br
4721         << FixItHint::CreateReplacement(BridgeKeywordLoc,
4722                           br ? "CFBridgingRetain " : "__bridge_retained");
4723 
4724       Kind = OBC_Bridge;
4725       break;
4726     }
4727     }
4728   } else {
4729     Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible)
4730       << FromType << T << Kind
4731       << SubExpr->getSourceRange()
4732       << TSInfo->getTypeLoc().getSourceRange();
4733     return ExprError();
4734   }
4735 
4736   Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK,
4737                                                    BridgeKeywordLoc,
4738                                                    TSInfo, SubExpr);
4739 
4740   if (MustConsume) {
4741     Cleanup.setExprNeedsCleanups(true);
4742     Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result,
4743                                       nullptr, VK_PRValue, FPOptionsOverride());
4744   }
4745 
4746   return Result;
4747 }
4748 
4749 ExprResult Sema::ActOnObjCBridgedCast(Scope *S,
4750                                       SourceLocation LParenLoc,
4751                                       ObjCBridgeCastKind Kind,
4752                                       SourceLocation BridgeKeywordLoc,
4753                                       ParsedType Type,
4754                                       SourceLocation RParenLoc,
4755                                       Expr *SubExpr) {
4756   TypeSourceInfo *TSInfo = nullptr;
4757   QualType T = GetTypeFromParser(Type, &TSInfo);
4758   if (Kind == OBC_Bridge)
4759     CheckTollFreeBridgeCast(T, SubExpr);
4760   if (!TSInfo)
4761     TSInfo = Context.getTrivialTypeSourceInfo(T, LParenLoc);
4762   return BuildObjCBridgedCast(LParenLoc, Kind, BridgeKeywordLoc, TSInfo,
4763                               SubExpr);
4764 }
4765