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