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