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