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