clang  9.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.CharTy;
1101  // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
1102  if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings)
1103  StrTy.addConst();
1104  StrTy = Context.getConstantArrayType(StrTy, llvm::APInt(32, Str.size()+1),
1105  ArrayType::Normal, 0);
1106  }
1107 
1108  return new (Context) ObjCEncodeExpr(StrTy, EncodedTypeInfo, AtLoc, RParenLoc);
1109 }
1110 
1112  SourceLocation EncodeLoc,
1113  SourceLocation LParenLoc,
1114  ParsedType ty,
1115  SourceLocation RParenLoc) {
1116  // FIXME: Preserve type source info ?
1117  TypeSourceInfo *TInfo;
1118  QualType EncodedType = GetTypeFromParser(ty, &TInfo);
1119  if (!TInfo)
1120  TInfo = Context.getTrivialTypeSourceInfo(EncodedType,
1121  getLocForEndOfToken(LParenLoc));
1122 
1123  return BuildObjCEncodeExpression(AtLoc, TInfo, RParenLoc);
1124 }
1125 
1127  SourceLocation AtLoc,
1128  SourceLocation LParenLoc,
1129  SourceLocation RParenLoc,
1130  ObjCMethodDecl *Method,
1131  ObjCMethodList &MethList) {
1132  ObjCMethodList *M = &MethList;
1133  bool Warned = false;
1134  for (M = M->getNext(); M; M=M->getNext()) {
1135  ObjCMethodDecl *MatchingMethodDecl = M->getMethod();
1136  if (MatchingMethodDecl == Method ||
1137  isa<ObjCImplDecl>(MatchingMethodDecl->getDeclContext()) ||
1138  MatchingMethodDecl->getSelector() != Method->getSelector())
1139  continue;
1140  if (!S.MatchTwoMethodDeclarations(Method,
1141  MatchingMethodDecl, Sema::MMS_loose)) {
1142  if (!Warned) {
1143  Warned = true;
1144  S.Diag(AtLoc, diag::warn_multiple_selectors)
1145  << Method->getSelector() << FixItHint::CreateInsertion(LParenLoc, "(")
1146  << FixItHint::CreateInsertion(RParenLoc, ")");
1147  S.Diag(Method->getLocation(), diag::note_method_declared_at)
1148  << Method->getDeclName();
1149  }
1150  S.Diag(MatchingMethodDecl->getLocation(), diag::note_method_declared_at)
1151  << MatchingMethodDecl->getDeclName();
1152  }
1153  }
1154  return Warned;
1155 }
1156 
1158  ObjCMethodDecl *Method,
1159  SourceLocation LParenLoc,
1160  SourceLocation RParenLoc,
1161  bool WarnMultipleSelectors) {
1162  if (!WarnMultipleSelectors ||
1163  S.Diags.isIgnored(diag::warn_multiple_selectors, SourceLocation()))
1164  return;
1165  bool Warned = false;
1166  for (Sema::GlobalMethodPool::iterator b = S.MethodPool.begin(),
1167  e = S.MethodPool.end(); b != e; b++) {
1168  // first, instance methods
1169  ObjCMethodList &InstMethList = b->second.first;
1170  if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc,
1171  Method, InstMethList))
1172  Warned = true;
1173 
1174  // second, class methods
1175  ObjCMethodList &ClsMethList = b->second.second;
1176  if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc,
1177  Method, ClsMethList) || Warned)
1178  return;
1179  }
1180 }
1181 
1183  SourceLocation AtLoc,
1184  SourceLocation SelLoc,
1185  SourceLocation LParenLoc,
1186  SourceLocation RParenLoc,
1187  bool WarnMultipleSelectors) {
1188  ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel,
1189  SourceRange(LParenLoc, RParenLoc));
1190  if (!Method)
1191  Method = LookupFactoryMethodInGlobalPool(Sel,
1192  SourceRange(LParenLoc, RParenLoc));
1193  if (!Method) {
1194  if (const ObjCMethodDecl *OM = SelectorsForTypoCorrection(Sel)) {
1195  Selector MatchedSel = OM->getSelector();
1196  SourceRange SelectorRange(LParenLoc.getLocWithOffset(1),
1197  RParenLoc.getLocWithOffset(-1));
1198  Diag(SelLoc, diag::warn_undeclared_selector_with_typo)
1199  << Sel << MatchedSel
1200  << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString());
1201 
1202  } else
1203  Diag(SelLoc, diag::warn_undeclared_selector) << Sel;
1204  } else
1205  DiagnoseMismatchedSelectors(*this, AtLoc, Method, LParenLoc, RParenLoc,
1206  WarnMultipleSelectors);
1207 
1208  if (Method &&
1210  !getSourceManager().isInSystemHeader(Method->getLocation()))
1211  ReferencedSelectors.insert(std::make_pair(Sel, AtLoc));
1212 
1213  // In ARC, forbid the user from using @selector for
1214  // retain/release/autorelease/dealloc/retainCount.
1215  if (getLangOpts().ObjCAutoRefCount) {
1216  switch (Sel.getMethodFamily()) {
1217  case OMF_retain:
1218  case OMF_release:
1219  case OMF_autorelease:
1220  case OMF_retainCount:
1221  case OMF_dealloc:
1222  Diag(AtLoc, diag::err_arc_illegal_selector) <<
1223  Sel << SourceRange(LParenLoc, RParenLoc);
1224  break;
1225 
1226  case OMF_None:
1227  case OMF_alloc:
1228  case OMF_copy:
1229  case OMF_finalize:
1230  case OMF_init:
1231  case OMF_mutableCopy:
1232  case OMF_new:
1233  case OMF_self:
1234  case OMF_initialize:
1235  case OMF_performSelector:
1236  break;
1237  }
1238  }
1239  QualType Ty = Context.getObjCSelType();
1240  return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc);
1241 }
1242 
1244  SourceLocation AtLoc,
1245  SourceLocation ProtoLoc,
1246  SourceLocation LParenLoc,
1247  SourceLocation ProtoIdLoc,
1248  SourceLocation RParenLoc) {
1249  ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoIdLoc);
1250  if (!PDecl) {
1251  Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;
1252  return true;
1253  }
1254  if (!PDecl->hasDefinition()) {
1255  Diag(ProtoLoc, diag::err_atprotocol_protocol) << PDecl;
1256  Diag(PDecl->getLocation(), diag::note_entity_declared_at) << PDecl;
1257  } else {
1258  PDecl = PDecl->getDefinition();
1259  }
1260 
1261  QualType Ty = Context.getObjCProtoType();
1262  if (Ty.isNull())
1263  return true;
1264  Ty = Context.getObjCObjectPointerType(Ty);
1265  return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, ProtoIdLoc, RParenLoc);
1266 }
1267 
1268 /// Try to capture an implicit reference to 'self'.
1270  DeclContext *DC = getFunctionLevelDeclContext();
1271 
1272  // If we're not in an ObjC method, error out. Note that, unlike the
1273  // C++ case, we don't require an instance method --- class methods
1274  // still have a 'self', and we really do still need to capture it!
1275  ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(DC);
1276  if (!method)
1277  return nullptr;
1278 
1279  tryCaptureVariable(method->getSelfDecl(), Loc);
1280 
1281  return method;
1282 }
1283 
1285  QualType origType = T;
1286  if (auto nullability = AttributedType::stripOuterNullability(T)) {
1287  if (T == Context.getObjCInstanceType()) {
1288  return Context.getAttributedType(
1290  Context.getObjCIdType(),
1291  Context.getObjCIdType());
1292  }
1293 
1294  return origType;
1295  }
1296 
1297  if (T == Context.getObjCInstanceType())
1298  return Context.getObjCIdType();
1299 
1300  return origType;
1301 }
1302 
1303 /// Determine the result type of a message send based on the receiver type,
1304 /// method, and the kind of message send.
1305 ///
1306 /// This is the "base" result type, which will still need to be adjusted
1307 /// to account for nullability.
1309  QualType ReceiverType,
1310  ObjCMethodDecl *Method,
1311  bool isClassMessage,
1312  bool isSuperMessage) {
1313  assert(Method && "Must have a method");
1314  if (!Method->hasRelatedResultType())
1315  return Method->getSendResultType(ReceiverType);
1316 
1317  ASTContext &Context = S.Context;
1318 
1319  // Local function that transfers the nullability of the method's
1320  // result type to the returned result.
1321  auto transferNullability = [&](QualType type) -> QualType {
1322  // If the method's result type has nullability, extract it.
1323  if (auto nullability = Method->getSendResultType(ReceiverType)
1324  ->getNullability(Context)){
1325  // Strip off any outer nullability sugar from the provided type.
1327 
1328  // Form a new attributed type using the method result type's nullability.
1329  return Context.getAttributedType(
1331  type,
1332  type);
1333  }
1334 
1335  return type;
1336  };
1337 
1338  // If a method has a related return type:
1339  // - if the method found is an instance method, but the message send
1340  // was a class message send, T is the declared return type of the method
1341  // found
1342  if (Method->isInstanceMethod() && isClassMessage)
1343  return stripObjCInstanceType(Context,
1344  Method->getSendResultType(ReceiverType));
1345 
1346  // - if the receiver is super, T is a pointer to the class of the
1347  // enclosing method definition
1348  if (isSuperMessage) {
1349  if (ObjCMethodDecl *CurMethod = S.getCurMethodDecl())
1350  if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface()) {
1351  return transferNullability(
1352  Context.getObjCObjectPointerType(
1353  Context.getObjCInterfaceType(Class)));
1354  }
1355  }
1356 
1357  // - if the receiver is the name of a class U, T is a pointer to U
1358  if (ReceiverType->getAsObjCInterfaceType())
1359  return transferNullability(Context.getObjCObjectPointerType(ReceiverType));
1360  // - if the receiver is of type Class or qualified Class type,
1361  // T is the declared return type of the method.
1362  if (ReceiverType->isObjCClassType() ||
1363  ReceiverType->isObjCQualifiedClassType())
1364  return stripObjCInstanceType(Context,
1365  Method->getSendResultType(ReceiverType));
1366 
1367  // - if the receiver is id, qualified id, Class, or qualified Class, T
1368  // is the receiver type, otherwise
1369  // - T is the type of the receiver expression.
1370  return transferNullability(ReceiverType);
1371 }
1372 
1374  QualType ReceiverType,
1375  ObjCMethodDecl *Method,
1376  bool isClassMessage,
1377  bool isSuperMessage) {
1378  // Produce the result type.
1379  QualType resultType = getBaseMessageSendResultType(*this, ReceiverType,
1380  Method,
1381  isClassMessage,
1382  isSuperMessage);
1383 
1384  // If this is a class message, ignore the nullability of the receiver.
1385  if (isClassMessage) {
1386  // In a class method, class messages to 'self' that return instancetype can
1387  // be typed as the current class. We can safely do this in ARC because self
1388  // can't be reassigned, and we do it unsafely outside of ARC because in
1389  // practice people never reassign self in class methods and there's some
1390  // virtue in not being aggressively pedantic.
1391  if (Receiver && Receiver->isObjCSelfExpr()) {
1392  assert(ReceiverType->isObjCClassType() && "expected a Class self");
1393  QualType T = Method->getSendResultType(ReceiverType);
1395  if (T == Context.getObjCInstanceType()) {
1396  const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(
1397  cast<ImplicitParamDecl>(
1398  cast<DeclRefExpr>(Receiver->IgnoreParenImpCasts())->getDecl())
1399  ->getDeclContext());
1400  assert(MD->isClassMethod() && "expected a class method");
1401  QualType NewResultType = Context.getObjCObjectPointerType(
1402  Context.getObjCInterfaceType(MD->getClassInterface()));
1403  if (auto Nullability = resultType->getNullability(Context))
1404  NewResultType = Context.getAttributedType(
1406  NewResultType, NewResultType);
1407  return NewResultType;
1408  }
1409  }
1410  return resultType;
1411  }
1412 
1413  // There is nothing left to do if the result type cannot have a nullability
1414  // specifier.
1415  if (!resultType->canHaveNullability())
1416  return resultType;
1417 
1418  // Map the nullability of the result into a table index.
1419  unsigned receiverNullabilityIdx = 0;
1420  if (auto nullability = ReceiverType->getNullability(Context))
1421  receiverNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
1422 
1423  unsigned resultNullabilityIdx = 0;
1424  if (auto nullability = resultType->getNullability(Context))
1425  resultNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
1426 
1427  // The table of nullability mappings, indexed by the receiver's nullability
1428  // and then the result type's nullability.
1429  static const uint8_t None = 0;
1430  static const uint8_t NonNull = 1;
1431  static const uint8_t Nullable = 2;
1432  static const uint8_t Unspecified = 3;
1433  static const uint8_t nullabilityMap[4][4] = {
1434  // None NonNull Nullable Unspecified
1435  /* None */ { None, None, Nullable, None },
1436  /* NonNull */ { None, NonNull, Nullable, Unspecified },
1437  /* Nullable */ { Nullable, Nullable, Nullable, Nullable },
1438  /* Unspecified */ { None, Unspecified, Nullable, Unspecified }
1439  };
1440 
1441  unsigned newResultNullabilityIdx
1442  = nullabilityMap[receiverNullabilityIdx][resultNullabilityIdx];
1443  if (newResultNullabilityIdx == resultNullabilityIdx)
1444  return resultType;
1445 
1446  // Strip off the existing nullability. This removes as little type sugar as
1447  // possible.
1448  do {
1449  if (auto attributed = dyn_cast<AttributedType>(resultType.getTypePtr())) {
1450  resultType = attributed->getModifiedType();
1451  } else {
1452  resultType = resultType.getDesugaredType(Context);
1453  }
1454  } while (resultType->getNullability(Context));
1455 
1456  // Add nullability back if needed.
1457  if (newResultNullabilityIdx > 0) {
1458  auto newNullability
1459  = static_cast<NullabilityKind>(newResultNullabilityIdx-1);
1460  return Context.getAttributedType(
1462  resultType, resultType);
1463  }
1464 
1465  return resultType;
1466 }
1467 
1468 /// Look for an ObjC method whose result type exactly matches the given type.
1469 static const ObjCMethodDecl *
1471  QualType instancetype) {
1472  if (MD->getReturnType() == instancetype)
1473  return MD;
1474 
1475  // For these purposes, a method in an @implementation overrides a
1476  // declaration in the @interface.
1477  if (const ObjCImplDecl *impl =
1478  dyn_cast<ObjCImplDecl>(MD->getDeclContext())) {
1479  const ObjCContainerDecl *iface;
1480  if (const ObjCCategoryImplDecl *catImpl =
1481  dyn_cast<ObjCCategoryImplDecl>(impl)) {
1482  iface = catImpl->getCategoryDecl();
1483  } else {
1484  iface = impl->getClassInterface();
1485  }
1486 
1487  const ObjCMethodDecl *ifaceMD =
1488  iface->getMethod(MD->getSelector(), MD->isInstanceMethod());
1489  if (ifaceMD) return findExplicitInstancetypeDeclarer(ifaceMD, instancetype);
1490  }
1491 
1493  MD->getOverriddenMethods(overrides);
1494  for (unsigned i = 0, e = overrides.size(); i != e; ++i) {
1495  if (const ObjCMethodDecl *result =
1496  findExplicitInstancetypeDeclarer(overrides[i], instancetype))
1497  return result;
1498  }
1499 
1500  return nullptr;
1501 }
1502 
1504  // Only complain if we're in an ObjC method and the required return
1505  // type doesn't match the method's declared return type.
1506  ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurContext);
1507  if (!MD || !MD->hasRelatedResultType() ||
1508  Context.hasSameUnqualifiedType(destType, MD->getReturnType()))
1509  return;
1510 
1511  // Look for a method overridden by this method which explicitly uses
1512  // 'instancetype'.
1513  if (const ObjCMethodDecl *overridden =
1515  SourceRange range = overridden->getReturnTypeSourceRange();
1516  SourceLocation loc = range.getBegin();
1517  if (loc.isInvalid())
1518  loc = overridden->getLocation();
1519  Diag(loc, diag::note_related_result_type_explicit)
1520  << /*current method*/ 1 << range;
1521  return;
1522  }
1523 
1524  // Otherwise, if we have an interesting method family, note that.
1525  // This should always trigger if the above didn't.
1526  if (ObjCMethodFamily family = MD->getMethodFamily())
1527  Diag(MD->getLocation(), diag::note_related_result_type_family)
1528  << /*current method*/ 1
1529  << family;
1530 }
1531 
1533  E = E->IgnoreParenImpCasts();
1534  const ObjCMessageExpr *MsgSend = dyn_cast<ObjCMessageExpr>(E);
1535  if (!MsgSend)
1536  return;
1537 
1538  const ObjCMethodDecl *Method = MsgSend->getMethodDecl();
1539  if (!Method)
1540  return;
1541 
1542  if (!Method->hasRelatedResultType())
1543  return;
1544 
1545  if (Context.hasSameUnqualifiedType(
1546  Method->getReturnType().getNonReferenceType(), MsgSend->getType()))
1547  return;
1548 
1549  if (!Context.hasSameUnqualifiedType(Method->getReturnType(),
1550  Context.getObjCInstanceType()))
1551  return;
1552 
1553  Diag(Method->getLocation(), diag::note_related_result_type_inferred)
1554  << Method->isInstanceMethod() << Method->getSelector()
1555  << MsgSend->getType();
1556 }
1557 
1559  const Expr *Receiver, QualType ReceiverType, MultiExprArg Args,
1560  Selector Sel, ArrayRef<SourceLocation> SelectorLocs, ObjCMethodDecl *Method,
1561  bool isClassMessage, bool isSuperMessage, SourceLocation lbrac,
1562  SourceLocation rbrac, SourceRange RecRange, QualType &ReturnType,
1563  ExprValueKind &VK) {
1564  SourceLocation SelLoc;
1565  if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
1566  SelLoc = SelectorLocs.front();
1567  else
1568  SelLoc = lbrac;
1569 
1570  if (!Method) {
1571  // Apply default argument promotion as for (C99 6.5.2.2p6).
1572  for (unsigned i = 0, e = Args.size(); i != e; i++) {
1573  if (Args[i]->isTypeDependent())
1574  continue;
1575 
1576  ExprResult result;
1577  if (getLangOpts().DebuggerSupport) {
1578  QualType paramTy; // ignored
1579  result = checkUnknownAnyArg(SelLoc, Args[i], paramTy);
1580  } else {
1581  result = DefaultArgumentPromotion(Args[i]);
1582  }
1583  if (result.isInvalid())
1584  return true;
1585  Args[i] = result.get();
1586  }
1587 
1588  unsigned DiagID;
1589  if (getLangOpts().ObjCAutoRefCount)
1590  DiagID = diag::err_arc_method_not_found;
1591  else
1592  DiagID = isClassMessage ? diag::warn_class_method_not_found
1593  : diag::warn_inst_method_not_found;
1594  if (!getLangOpts().DebuggerSupport) {
1595  const ObjCMethodDecl *OMD = SelectorsForTypoCorrection(Sel, ReceiverType);
1596  if (OMD && !OMD->isInvalidDecl()) {
1597  if (getLangOpts().ObjCAutoRefCount)
1598  DiagID = diag::err_method_not_found_with_typo;
1599  else
1600  DiagID = isClassMessage ? diag::warn_class_method_not_found_with_typo
1601  : diag::warn_instance_method_not_found_with_typo;
1602  Selector MatchedSel = OMD->getSelector();
1603  SourceRange SelectorRange(SelectorLocs.front(), SelectorLocs.back());
1604  if (MatchedSel.isUnarySelector())
1605  Diag(SelLoc, DiagID)
1606  << Sel<< isClassMessage << MatchedSel
1607  << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString());
1608  else
1609  Diag(SelLoc, DiagID) << Sel<< isClassMessage << MatchedSel;
1610  }
1611  else
1612  Diag(SelLoc, DiagID)
1613  << Sel << isClassMessage << SourceRange(SelectorLocs.front(),
1614  SelectorLocs.back());
1615  // Find the class to which we are sending this message.
1616  if (ReceiverType->isObjCObjectPointerType()) {
1617  if (ObjCInterfaceDecl *ThisClass =
1618  ReceiverType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()) {
1619  Diag(ThisClass->getLocation(), diag::note_receiver_class_declared);
1620  if (!RecRange.isInvalid())
1621  if (ThisClass->lookupClassMethod(Sel))
1622  Diag(RecRange.getBegin(),diag::note_receiver_expr_here)
1623  << FixItHint::CreateReplacement(RecRange,
1624  ThisClass->getNameAsString());
1625  }
1626  }
1627  }
1628 
1629  // In debuggers, we want to use __unknown_anytype for these
1630  // results so that clients can cast them.
1631  if (getLangOpts().DebuggerSupport) {
1632  ReturnType = Context.UnknownAnyTy;
1633  } else {
1634  ReturnType = Context.getObjCIdType();
1635  }
1636  VK = VK_RValue;
1637  return false;
1638  }
1639 
1640  ReturnType = getMessageSendResultType(Receiver, ReceiverType, Method,
1641  isClassMessage, isSuperMessage);
1642  VK = Expr::getValueKindForType(Method->getReturnType());
1643 
1644  unsigned NumNamedArgs = Sel.getNumArgs();
1645  // Method might have more arguments than selector indicates. This is due
1646  // to addition of c-style arguments in method.
1647  if (Method->param_size() > Sel.getNumArgs())
1648  NumNamedArgs = Method->param_size();
1649  // FIXME. This need be cleaned up.
1650  if (Args.size() < NumNamedArgs) {
1651  Diag(SelLoc, diag::err_typecheck_call_too_few_args)
1652  << 2 << NumNamedArgs << static_cast<unsigned>(Args.size());
1653  return false;
1654  }
1655 
1656  // Compute the set of type arguments to be substituted into each parameter
1657  // type.
1658  Optional<ArrayRef<QualType>> typeArgs
1659  = ReceiverType->getObjCSubstitutions(Method->getDeclContext());
1660  bool IsError = false;
1661  for (unsigned i = 0; i < NumNamedArgs; i++) {
1662  // We can't do any type-checking on a type-dependent argument.
1663  if (Args[i]->isTypeDependent())
1664  continue;
1665 
1666  Expr *argExpr = Args[i];
1667 
1668  ParmVarDecl *param = Method->parameters()[i];
1669  assert(argExpr && "CheckMessageArgumentTypes(): missing expression");
1670 
1671  if (param->hasAttr<NoEscapeAttr>())
1672  if (auto *BE = dyn_cast<BlockExpr>(
1673  argExpr->IgnoreParenNoopCasts(Context)))
1674  BE->getBlockDecl()->setDoesNotEscape();
1675 
1676  // Strip the unbridged-cast placeholder expression off unless it's
1677  // a consumed argument.
1678  if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
1679  !param->hasAttr<CFConsumedAttr>())
1680  argExpr = stripARCUnbridgedCast(argExpr);
1681 
1682  // If the parameter is __unknown_anytype, infer its type
1683  // from the argument.
1684  if (param->getType() == Context.UnknownAnyTy) {
1685  QualType paramType;
1686  ExprResult argE = checkUnknownAnyArg(SelLoc, argExpr, paramType);
1687  if (argE.isInvalid()) {
1688  IsError = true;
1689  } else {
1690  Args[i] = argE.get();
1691 
1692  // Update the parameter type in-place.
1693  param->setType(paramType);
1694  }
1695  continue;
1696  }
1697 
1698  QualType origParamType = param->getType();
1699  QualType paramType = param->getType();
1700  if (typeArgs)
1701  paramType = paramType.substObjCTypeArgs(
1702  Context,
1703  *typeArgs,
1705 
1706  if (RequireCompleteType(argExpr->getSourceRange().getBegin(),
1707  paramType,
1708  diag::err_call_incomplete_argument, argExpr))
1709  return true;
1710 
1711  InitializedEntity Entity
1712  = InitializedEntity::InitializeParameter(Context, param, paramType);
1713  ExprResult ArgE = PerformCopyInitialization(Entity, SourceLocation(), argExpr);
1714  if (ArgE.isInvalid())
1715  IsError = true;
1716  else {
1717  Args[i] = ArgE.getAs<Expr>();
1718 
1719  // If we are type-erasing a block to a block-compatible
1720  // Objective-C pointer type, we may need to extend the lifetime
1721  // of the block object.
1722  if (typeArgs && Args[i]->isRValue() && paramType->isBlockPointerType() &&
1723  Args[i]->getType()->isBlockPointerType() &&
1724  origParamType->isObjCObjectPointerType()) {
1725  ExprResult arg = Args[i];
1726  maybeExtendBlockObject(arg);
1727  Args[i] = arg.get();
1728  }
1729  }
1730  }
1731 
1732  // Promote additional arguments to variadic methods.
1733  if (Method->isVariadic()) {
1734  for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
1735  if (Args[i]->isTypeDependent())
1736  continue;
1737 
1738  ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
1739  nullptr);
1740  IsError |= Arg.isInvalid();
1741  Args[i] = Arg.get();
1742  }
1743  } else {
1744  // Check for extra arguments to non-variadic methods.
1745  if (Args.size() != NumNamedArgs) {
1746  Diag(Args[NumNamedArgs]->getBeginLoc(),
1747  diag::err_typecheck_call_too_many_args)
1748  << 2 /*method*/ << NumNamedArgs << static_cast<unsigned>(Args.size())
1749  << Method->getSourceRange()
1750  << SourceRange(Args[NumNamedArgs]->getBeginLoc(),
1751  Args.back()->getEndLoc());
1752  }
1753  }
1754 
1755  DiagnoseSentinelCalls(Method, SelLoc, Args);
1756 
1757  // Do additional checkings on method.
1758  IsError |= CheckObjCMethodCall(
1759  Method, SelLoc, makeArrayRef(Args.data(), Args.size()));
1760 
1761  return IsError;
1762 }
1763 
1764 bool Sema::isSelfExpr(Expr *RExpr) {
1765  // 'self' is objc 'self' in an objc method only.
1766  ObjCMethodDecl *Method =
1767  dyn_cast_or_null<ObjCMethodDecl>(CurContext->getNonClosureAncestor());
1768  return isSelfExpr(RExpr, Method);
1769 }
1770 
1771 bool Sema::isSelfExpr(Expr *receiver, const ObjCMethodDecl *method) {
1772  if (!method) return false;
1773 
1774  receiver = receiver->IgnoreParenLValueCasts();
1775  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(receiver))
1776  if (DRE->getDecl() == method->getSelfDecl())
1777  return true;
1778  return false;
1779 }
1780 
1781 /// LookupMethodInType - Look up a method in an ObjCObjectType.
1783  bool isInstance) {
1784  const ObjCObjectType *objType = type->castAs<ObjCObjectType>();
1785  if (ObjCInterfaceDecl *iface = objType->getInterface()) {
1786  // Look it up in the main interface (and categories, etc.)
1787  if (ObjCMethodDecl *method = iface->lookupMethod(sel, isInstance))
1788  return method;
1789 
1790  // Okay, look for "private" methods declared in any
1791  // @implementations we've seen.
1792  if (ObjCMethodDecl *method = iface->lookupPrivateMethod(sel, isInstance))
1793  return method;
1794  }
1795 
1796  // Check qualifiers.
1797  for (const auto *I : objType->quals())
1798  if (ObjCMethodDecl *method = I->lookupMethod(sel, isInstance))
1799  return method;
1800 
1801  return nullptr;
1802 }
1803 
1804 /// LookupMethodInQualifiedType - Lookups up a method in protocol qualifier
1805 /// list of a qualified objective pointer type.
1807  const ObjCObjectPointerType *OPT,
1808  bool Instance)
1809 {
1810  ObjCMethodDecl *MD = nullptr;
1811  for (const auto *PROTO : OPT->quals()) {
1812  if ((MD = PROTO->lookupMethod(Sel, Instance))) {
1813  return MD;
1814  }
1815  }
1816  return nullptr;
1817 }
1818 
1819 /// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an
1820 /// objective C interface. This is a property reference expression.
1823  Expr *BaseExpr, SourceLocation OpLoc,
1824  DeclarationName MemberName,
1825  SourceLocation MemberLoc,
1826  SourceLocation SuperLoc, QualType SuperType,
1827  bool Super) {
1828  const ObjCInterfaceType *IFaceT = OPT->getInterfaceType();
1829  ObjCInterfaceDecl *IFace = IFaceT->getDecl();
1830 
1831  if (!MemberName.isIdentifier()) {
1832  Diag(MemberLoc, diag::err_invalid_property_name)
1833  << MemberName << QualType(OPT, 0);
1834  return ExprError();
1835  }
1836 
1837  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1838 
1839  SourceRange BaseRange = Super? SourceRange(SuperLoc)
1840  : BaseExpr->getSourceRange();
1841  if (RequireCompleteType(MemberLoc, OPT->getPointeeType(),
1842  diag::err_property_not_found_forward_class,
1843  MemberName, BaseRange))
1844  return ExprError();
1845 
1846  if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(
1848  // Check whether we can reference this property.
1849  if (DiagnoseUseOfDecl(PD, MemberLoc))
1850  return ExprError();
1851  if (Super)
1852  return new (Context)
1854  OK_ObjCProperty, MemberLoc, SuperLoc, SuperType);
1855  else
1856  return new (Context)
1858  OK_ObjCProperty, MemberLoc, BaseExpr);
1859  }
1860  // Check protocols on qualified interfaces.
1861  for (const auto *I : OPT->quals())
1862  if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration(
1864  // Check whether we can reference this property.
1865  if (DiagnoseUseOfDecl(PD, MemberLoc))
1866  return ExprError();
1867 
1868  if (Super)
1869  return new (Context) ObjCPropertyRefExpr(
1870  PD, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty, MemberLoc,
1871  SuperLoc, SuperType);
1872  else
1873  return new (Context)
1875  OK_ObjCProperty, MemberLoc, BaseExpr);
1876  }
1877  // If that failed, look for an "implicit" property by seeing if the nullary
1878  // selector is implemented.
1879 
1880  // FIXME: The logic for looking up nullary and unary selectors should be
1881  // shared with the code in ActOnInstanceMessage.
1882 
1883  Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
1884  ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
1885 
1886  // May be found in property's qualified list.
1887  if (!Getter)
1888  Getter = LookupMethodInQualifiedType(Sel, OPT, true);
1889 
1890  // If this reference is in an @implementation, check for 'private' methods.
1891  if (!Getter)
1892  Getter = IFace->lookupPrivateMethod(Sel);
1893 
1894  if (Getter) {
1895  // Check if we can reference this property.
1896  if (DiagnoseUseOfDecl(Getter, MemberLoc))
1897  return ExprError();
1898  }
1899  // If we found a getter then this may be a valid dot-reference, we
1900  // will look for the matching setter, in case it is needed.
1901  Selector SetterSel =
1902  SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
1903  PP.getSelectorTable(), Member);
1904  ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
1905 
1906  // May be found in property's qualified list.
1907  if (!Setter)
1908  Setter = LookupMethodInQualifiedType(SetterSel, OPT, true);
1909 
1910  if (!Setter) {
1911  // If this reference is in an @implementation, also check for 'private'
1912  // methods.
1913  Setter = IFace->lookupPrivateMethod(SetterSel);
1914  }
1915 
1916  if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
1917  return ExprError();
1918 
1919  // Special warning if member name used in a property-dot for a setter accessor
1920  // does not use a property with same name; e.g. obj.X = ... for a property with
1921  // name 'x'.
1922  if (Setter && Setter->isImplicit() && Setter->isPropertyAccessor() &&
1923  !IFace->FindPropertyDeclaration(
1925  if (const ObjCPropertyDecl *PDecl = Setter->findPropertyDecl()) {
1926  // Do not warn if user is using property-dot syntax to make call to
1927  // user named setter.
1928  if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter))
1929  Diag(MemberLoc,
1930  diag::warn_property_access_suggest)
1931  << MemberName << QualType(OPT, 0) << PDecl->getName()
1932  << FixItHint::CreateReplacement(MemberLoc, PDecl->getName());
1933  }
1934  }
1935 
1936  if (Getter || Setter) {
1937  if (Super)
1938  return new (Context)
1939  ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
1940  OK_ObjCProperty, MemberLoc, SuperLoc, SuperType);
1941  else
1942  return new (Context)
1943  ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
1944  OK_ObjCProperty, MemberLoc, BaseExpr);
1945 
1946  }
1947 
1948  // Attempt to correct for typos in property names.
1950  if (TypoCorrection Corrected = CorrectTypo(
1951  DeclarationNameInfo(MemberName, MemberLoc), LookupOrdinaryName,
1952  nullptr, nullptr, CCC, CTK_ErrorRecovery, IFace, false, OPT)) {
1953  DeclarationName TypoResult = Corrected.getCorrection();
1954  if (TypoResult.isIdentifier() &&
1955  TypoResult.getAsIdentifierInfo() == Member) {
1956  // There is no need to try the correction if it is the same.
1957  NamedDecl *ChosenDecl =
1958  Corrected.isKeyword() ? nullptr : Corrected.getFoundDecl();
1959  if (ChosenDecl && isa<ObjCPropertyDecl>(ChosenDecl))
1960  if (cast<ObjCPropertyDecl>(ChosenDecl)->isClassProperty()) {
1961  // This is a class property, we should not use the instance to
1962  // access it.
1963  Diag(MemberLoc, diag::err_class_property_found) << MemberName
1964  << OPT->getInterfaceDecl()->getName()
1966  OPT->getInterfaceDecl()->getName());
1967  return ExprError();
1968  }
1969  } else {
1970  diagnoseTypo(Corrected, PDiag(diag::err_property_not_found_suggest)
1971  << MemberName << QualType(OPT, 0));
1972  return HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc,
1973  TypoResult, MemberLoc,
1974  SuperLoc, SuperType, Super);
1975  }
1976  }
1977  ObjCInterfaceDecl *ClassDeclared;
1978  if (ObjCIvarDecl *Ivar =
1979  IFace->lookupInstanceVariable(Member, ClassDeclared)) {
1980  QualType T = Ivar->getType();
1981  if (const ObjCObjectPointerType * OBJPT =
1983  if (RequireCompleteType(MemberLoc, OBJPT->getPointeeType(),
1984  diag::err_property_not_as_forward_class,
1985  MemberName, BaseExpr))
1986  return ExprError();
1987  }
1988  Diag(MemberLoc,
1989  diag::err_ivar_access_using_property_syntax_suggest)
1990  << MemberName << QualType(OPT, 0) << Ivar->getDeclName()
1991  << FixItHint::CreateReplacement(OpLoc, "->");
1992  return ExprError();
1993  }
1994 
1995  Diag(MemberLoc, diag::err_property_not_found)
1996  << MemberName << QualType(OPT, 0);
1997  if (Setter)
1998  Diag(Setter->getLocation(), diag::note_getter_unavailable)
1999  << MemberName << BaseExpr->getSourceRange();
2000  return ExprError();
2001 }
2002 
2005  IdentifierInfo &propertyName,
2006  SourceLocation receiverNameLoc,
2007  SourceLocation propertyNameLoc) {
2008 
2009  IdentifierInfo *receiverNamePtr = &receiverName;
2010  ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(receiverNamePtr,
2011  receiverNameLoc);
2012 
2013  QualType SuperType;
2014  if (!IFace) {
2015  // If the "receiver" is 'super' in a method, handle it as an expression-like
2016  // property reference.
2017  if (receiverNamePtr->isStr("super")) {
2018  if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) {
2019  if (auto classDecl = CurMethod->getClassInterface()) {
2020  SuperType = QualType(classDecl->getSuperClassType(), 0);
2021  if (CurMethod->isInstanceMethod()) {
2022  if (SuperType.isNull()) {
2023  // The current class does not have a superclass.
2024  Diag(receiverNameLoc, diag::err_root_class_cannot_use_super)
2025  << CurMethod->getClassInterface()->getIdentifier();
2026  return ExprError();
2027  }
2028  QualType T = Context.getObjCObjectPointerType(SuperType);
2029 
2030  return HandleExprPropertyRefExpr(T->castAs<ObjCObjectPointerType>(),
2031  /*BaseExpr*/nullptr,
2032  SourceLocation()/*OpLoc*/,
2033  &propertyName,
2034  propertyNameLoc,
2035  receiverNameLoc, T, true);
2036  }
2037 
2038  // Otherwise, if this is a class method, try dispatching to our
2039  // superclass.
2040  IFace = CurMethod->getClassInterface()->getSuperClass();
2041  }
2042  }
2043  }
2044 
2045  if (!IFace) {
2046  Diag(receiverNameLoc, diag::err_expected_either) << tok::identifier
2047  << tok::l_paren;
2048  return ExprError();
2049  }
2050  }
2051 
2052  Selector GetterSel;
2053  Selector SetterSel;
2054  if (auto PD = IFace->FindPropertyDeclaration(
2056  GetterSel = PD->getGetterName();
2057  SetterSel = PD->getSetterName();
2058  } else {
2059  GetterSel = PP.getSelectorTable().getNullarySelector(&propertyName);
2061  PP.getIdentifierTable(), PP.getSelectorTable(), &propertyName);
2062  }
2063 
2064  // Search for a declared property first.
2065  ObjCMethodDecl *Getter = IFace->lookupClassMethod(GetterSel);
2066 
2067  // If this reference is in an @implementation, check for 'private' methods.
2068  if (!Getter)
2069  Getter = IFace->lookupPrivateClassMethod(GetterSel);
2070 
2071  if (Getter) {
2072  // FIXME: refactor/share with ActOnMemberReference().
2073  // Check if we can reference this property.
2074  if (DiagnoseUseOfDecl(Getter, propertyNameLoc))
2075  return ExprError();
2076  }
2077 
2078  // Look for the matching setter, in case it is needed.
2079  ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
2080  if (!Setter) {
2081  // If this reference is in an @implementation, also check for 'private'
2082  // methods.
2083  Setter = IFace->lookupPrivateClassMethod(SetterSel);
2084  }
2085  // Look through local category implementations associated with the class.
2086  if (!Setter)
2087  Setter = IFace->getCategoryClassMethod(SetterSel);
2088 
2089  if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc))
2090  return ExprError();
2091 
2092  if (Getter || Setter) {
2093  if (!SuperType.isNull())
2094  return new (Context)
2095  ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
2096  OK_ObjCProperty, propertyNameLoc, receiverNameLoc,
2097  SuperType);
2098 
2099  return new (Context) ObjCPropertyRefExpr(
2100  Getter, Setter, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty,
2101  propertyNameLoc, receiverNameLoc, IFace);
2102  }
2103  return ExprError(Diag(propertyNameLoc, diag::err_property_not_found)
2104  << &propertyName << Context.getObjCInterfaceType(IFace));
2105 }
2106 
2107 namespace {
2108 
2109 class ObjCInterfaceOrSuperCCC final : public CorrectionCandidateCallback {
2110  public:
2111  ObjCInterfaceOrSuperCCC(ObjCMethodDecl *Method) {
2112  // Determine whether "super" is acceptable in the current context.
2113  if (Method && Method->getClassInterface())
2114  WantObjCSuper = Method->getClassInterface()->getSuperClass();
2115  }
2116 
2117  bool ValidateCandidate(const TypoCorrection &candidate) override {
2118  return candidate.getCorrectionDeclAs<ObjCInterfaceDecl>() ||
2119  candidate.isKeyword("super");
2120  }
2121 
2122  std::unique_ptr<CorrectionCandidateCallback> clone() override {
2123  return llvm::make_unique<ObjCInterfaceOrSuperCCC>(*this);
2124  }
2125 };
2126 
2127 } // end anonymous namespace
2128 
2130  IdentifierInfo *Name,
2131  SourceLocation NameLoc,
2132  bool IsSuper,
2133  bool HasTrailingDot,
2134  ParsedType &ReceiverType) {
2135  ReceiverType = nullptr;
2136 
2137  // If the identifier is "super" and there is no trailing dot, we're
2138  // messaging super. If the identifier is "super" and there is a
2139  // trailing dot, it's an instance message.
2140  if (IsSuper && S->isInObjcMethodScope())
2141  return HasTrailingDot? ObjCInstanceMessage : ObjCSuperMessage;
2142 
2143  LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
2144  LookupName(Result, S);
2145 
2146  switch (Result.getResultKind()) {
2148  // Normal name lookup didn't find anything. If we're in an
2149  // Objective-C method, look for ivars. If we find one, we're done!
2150  // FIXME: This is a hack. Ivar lookup should be part of normal
2151  // lookup.
2152  if (ObjCMethodDecl *Method = getCurMethodDecl()) {
2153  if (!Method->getClassInterface()) {
2154  // Fall back: let the parser try to parse it as an instance message.
2155  return ObjCInstanceMessage;
2156  }
2157 
2158  ObjCInterfaceDecl *ClassDeclared;
2159  if (Method->getClassInterface()->lookupInstanceVariable(Name,
2160  ClassDeclared))
2161  return ObjCInstanceMessage;
2162  }
2163 
2164  // Break out; we'll perform typo correction below.
2165  break;
2166 
2171  Result.suppressDiagnostics();
2172  return ObjCInstanceMessage;
2173 
2174  case LookupResult::Found: {
2175  // If the identifier is a class or not, and there is a trailing dot,
2176  // it's an instance message.
2177  if (HasTrailingDot)
2178  return ObjCInstanceMessage;
2179  // We found something. If it's a type, then we have a class
2180  // message. Otherwise, it's an instance message.
2181  NamedDecl *ND = Result.getFoundDecl();
2182  QualType T;
2183  if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(ND))
2184  T = Context.getObjCInterfaceType(Class);
2185  else if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) {
2186  T = Context.getTypeDeclType(Type);
2187  DiagnoseUseOfDecl(Type, NameLoc);
2188  }
2189  else
2190  return ObjCInstanceMessage;
2191 
2192  // We have a class message, and T is the type we're
2193  // messaging. Build source-location information for it.
2194  TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
2195  ReceiverType = CreateParsedType(T, TSInfo);
2196  return ObjCClassMessage;
2197  }
2198  }
2199 
2200  ObjCInterfaceOrSuperCCC CCC(getCurMethodDecl());
2201  if (TypoCorrection Corrected = CorrectTypo(
2202  Result.getLookupNameInfo(), Result.getLookupKind(), S, nullptr, CCC,
2203  CTK_ErrorRecovery, nullptr, false, nullptr, false)) {
2204  if (Corrected.isKeyword()) {
2205  // If we've found the keyword "super" (the only keyword that would be
2206  // returned by CorrectTypo), this is a send to super.
2207  diagnoseTypo(Corrected,
2208  PDiag(diag::err_unknown_receiver_suggest) << Name);
2209  return ObjCSuperMessage;
2210  } else if (ObjCInterfaceDecl *Class =
2211  Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
2212  // If we found a declaration, correct when it refers to an Objective-C
2213  // class.
2214  diagnoseTypo(Corrected,
2215  PDiag(diag::err_unknown_receiver_suggest) << Name);
2216  QualType T = Context.getObjCInterfaceType(Class);
2217  TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
2218  ReceiverType = CreateParsedType(T, TSInfo);
2219  return ObjCClassMessage;
2220  }
2221  }
2222 
2223  // Fall back: let the parser try to parse it as an instance message.
2224  return ObjCInstanceMessage;
2225 }
2226 
2228  SourceLocation SuperLoc,
2229  Selector Sel,
2230  SourceLocation LBracLoc,
2231  ArrayRef<SourceLocation> SelectorLocs,
2232  SourceLocation RBracLoc,
2233  MultiExprArg Args) {
2234  // Determine whether we are inside a method or not.
2235  ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc);
2236  if (!Method) {
2237  Diag(SuperLoc, diag::err_invalid_receiver_to_message_super);
2238  return ExprError();
2239  }
2240 
2241  ObjCInterfaceDecl *Class = Method->getClassInterface();
2242  if (!Class) {
2243  Diag(SuperLoc, diag::err_no_super_class_message)
2244  << Method->getDeclName();
2245  return ExprError();
2246  }
2247 
2248  QualType SuperTy(Class->getSuperClassType(), 0);
2249  if (SuperTy.isNull()) {
2250  // The current class does not have a superclass.
2251  Diag(SuperLoc, diag::err_root_class_cannot_use_super)
2252  << Class->getIdentifier();
2253  return ExprError();
2254  }
2255 
2256  // We are in a method whose class has a superclass, so 'super'
2257  // is acting as a keyword.
2258  if (Method->getSelector() == Sel)
2259  getCurFunction()->ObjCShouldCallSuper = false;
2260 
2261  if (Method->isInstanceMethod()) {
2262  // Since we are in an instance method, this is an instance
2263  // message to the superclass instance.
2264  SuperTy = Context.getObjCObjectPointerType(SuperTy);
2265  return BuildInstanceMessage(nullptr, SuperTy, SuperLoc,
2266  Sel, /*Method=*/nullptr,
2267  LBracLoc, SelectorLocs, RBracLoc, Args);
2268  }
2269 
2270  // Since we are in a class method, this is a class message to
2271  // the superclass.
2272  return BuildClassMessage(/*ReceiverTypeInfo=*/nullptr,
2273  SuperTy,
2274  SuperLoc, Sel, /*Method=*/nullptr,
2275  LBracLoc, SelectorLocs, RBracLoc, Args);
2276 }
2277 
2279  bool isSuperReceiver,
2280  SourceLocation Loc,
2281  Selector Sel,
2282  ObjCMethodDecl *Method,
2283  MultiExprArg Args) {
2284  TypeSourceInfo *receiverTypeInfo = nullptr;
2285  if (!ReceiverType.isNull())
2286  receiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType);
2287 
2288  return BuildClassMessage(receiverTypeInfo, ReceiverType,
2289  /*SuperLoc=*/isSuperReceiver ? Loc : SourceLocation(),
2290  Sel, Method, Loc, Loc, Loc, Args,
2291  /*isImplicit=*/true);
2292 }
2293 
2294 static void applyCocoaAPICheck(Sema &S, const ObjCMessageExpr *Msg,
2295  unsigned DiagID,
2296  bool (*refactor)(const ObjCMessageExpr *,
2297  const NSAPI &, edit::Commit &)) {
2298  SourceLocation MsgLoc = Msg->getExprLoc();
2299  if (S.Diags.isIgnored(DiagID, MsgLoc))
2300  return;
2301 
2302  SourceManager &SM = S.SourceMgr;
2303  edit::Commit ECommit(SM, S.LangOpts);
2304  if (refactor(Msg,*S.NSAPIObj, ECommit)) {
2305  DiagnosticBuilder Builder = S.Diag(MsgLoc, DiagID)
2306  << Msg->getSelector() << Msg->getSourceRange();
2307  // FIXME: Don't emit diagnostic at all if fixits are non-commitable.
2308  if (!ECommit.isCommitable())
2309  return;
2311  I = ECommit.edit_begin(), E = ECommit.edit_end(); I != E; ++I) {
2312  const edit::Commit::Edit &Edit = *I;
2313  switch (Edit.Kind) {
2316  Edit.Text,
2317  Edit.BeforePrev));
2318  break;
2320  Builder.AddFixItHint(
2322  Edit.getInsertFromRange(SM),
2323  Edit.BeforePrev));
2324  break;
2327  break;
2328  }
2329  }
2330  }
2331 }
2332 
2333 static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) {
2334  applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use,
2336 }
2337 
2339  const ObjCMethodDecl *Method,
2340  ArrayRef<Expr *> Args, QualType ReceiverType,
2341  bool IsClassObjectCall) {
2342  // Check if this is a performSelector method that uses a selector that returns
2343  // a record or a vector type.
2344  if (Method->getSelector().getMethodFamily() != OMF_performSelector ||
2345  Args.empty())
2346  return;
2347  const auto *SE = dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens());
2348  if (!SE)
2349  return;
2350  ObjCMethodDecl *ImpliedMethod;
2351  if (!IsClassObjectCall) {
2352  const auto *OPT = ReceiverType->getAs<ObjCObjectPointerType>();
2353  if (!OPT || !OPT->getInterfaceDecl())
2354  return;
2355  ImpliedMethod =
2356  OPT->getInterfaceDecl()->lookupInstanceMethod(SE->getSelector());
2357  if (!ImpliedMethod)
2358  ImpliedMethod =
2359  OPT->getInterfaceDecl()->lookupPrivateMethod(SE->getSelector());
2360  } else {
2361  const auto *IT = ReceiverType->getAs<ObjCInterfaceType>();
2362  if (!IT)
2363  return;
2364  ImpliedMethod = IT->getDecl()->lookupClassMethod(SE->getSelector());
2365  if (!ImpliedMethod)
2366  ImpliedMethod =
2367  IT->getDecl()->lookupPrivateClassMethod(SE->getSelector());
2368  }
2369  if (!ImpliedMethod)
2370  return;
2371  QualType Ret = ImpliedMethod->getReturnType();
2372  if (Ret->isRecordType() || Ret->isVectorType() || Ret->isExtVectorType()) {
2373  QualType Ret = ImpliedMethod->getReturnType();
2374  S.Diag(Loc, diag::warn_objc_unsafe_perform_selector)
2375  << Method->getSelector()
2376  << (!Ret->isRecordType()
2377  ? /*Vector*/ 2
2378  : Ret->isUnionType() ? /*Union*/ 1 : /*Struct*/ 0);
2379  S.Diag(ImpliedMethod->getBeginLoc(),
2380  diag::note_objc_unsafe_perform_selector_method_declared_here)
2381  << ImpliedMethod->getSelector() << Ret;
2382  }
2383 }
2384 
2385 /// Diagnose use of %s directive in an NSString which is being passed
2386 /// as formatting string to formatting method.
2387 static void
2389  ObjCMethodDecl *Method,
2390  Selector Sel,
2391  Expr **Args, unsigned NumArgs) {
2392  unsigned Idx = 0;
2393  bool Format = false;
2395  if (SFFamily == ObjCStringFormatFamily::SFF_NSString) {
2396  Idx = 0;
2397  Format = true;
2398  }
2399  else if (Method) {
2400  for (const auto *I : Method->specific_attrs<FormatAttr>()) {
2401  if (S.GetFormatNSStringIdx(I, Idx)) {
2402  Format = true;
2403  break;
2404  }
2405  }
2406  }
2407  if (!Format || NumArgs <= Idx)
2408  return;
2409 
2410  Expr *FormatExpr = Args[Idx];
2411  if (ObjCStringLiteral *OSL =
2412  dyn_cast<ObjCStringLiteral>(FormatExpr->IgnoreParenImpCasts())) {
2413  StringLiteral *FormatString = OSL->getString();
2414  if (S.FormatStringHasSArg(FormatString)) {
2415  S.Diag(FormatExpr->getExprLoc(), diag::warn_objc_cdirective_format_string)
2416  << "%s" << 0 << 0;
2417  if (Method)
2418  S.Diag(Method->getLocation(), diag::note_method_declared_at)
2419  << Method->getDeclName();
2420  }
2421  }
2422 }
2423 
2424 /// Build an Objective-C class message expression.
2425 ///
2426 /// This routine takes care of both normal class messages and
2427 /// class messages to the superclass.
2428 ///
2429 /// \param ReceiverTypeInfo Type source information that describes the
2430 /// receiver of this message. This may be NULL, in which case we are
2431 /// sending to the superclass and \p SuperLoc must be a valid source
2432 /// location.
2433 
2434 /// \param ReceiverType The type of the object receiving the
2435 /// message. When \p ReceiverTypeInfo is non-NULL, this is the same
2436 /// type as that refers to. For a superclass send, this is the type of
2437 /// the superclass.
2438 ///
2439 /// \param SuperLoc The location of the "super" keyword in a
2440 /// superclass message.
2441 ///
2442 /// \param Sel The selector to which the message is being sent.
2443 ///
2444 /// \param Method The method that this class message is invoking, if
2445 /// already known.
2446 ///
2447 /// \param LBracLoc The location of the opening square bracket ']'.
2448 ///
2449 /// \param RBracLoc The location of the closing square bracket ']'.
2450 ///
2451 /// \param ArgsIn The message arguments.
2453  QualType ReceiverType,
2454  SourceLocation SuperLoc,
2455  Selector Sel,
2456  ObjCMethodDecl *Method,
2457  SourceLocation LBracLoc,
2458  ArrayRef<SourceLocation> SelectorLocs,
2459  SourceLocation RBracLoc,
2460  MultiExprArg ArgsIn,
2461  bool isImplicit) {
2462  SourceLocation Loc = SuperLoc.isValid()? SuperLoc
2463  : ReceiverTypeInfo->getTypeLoc().getSourceRange().getBegin();
2464  if (LBracLoc.isInvalid()) {
2465  Diag(Loc, diag::err_missing_open_square_message_send)
2466  << FixItHint::CreateInsertion(Loc, "[");
2467  LBracLoc = Loc;
2468  }
2469  ArrayRef<SourceLocation> SelectorSlotLocs;
2470  if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2471  SelectorSlotLocs = SelectorLocs;
2472  else
2473  SelectorSlotLocs = Loc;
2474  SourceLocation SelLoc = SelectorSlotLocs.front();
2475 
2476  if (ReceiverType->isDependentType()) {
2477  // If the receiver type is dependent, we can't type-check anything
2478  // at this point. Build a dependent expression.
2479  unsigned NumArgs = ArgsIn.size();
2480  Expr **Args = ArgsIn.data();
2481  assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2482  return ObjCMessageExpr::Create(
2483  Context, ReceiverType, VK_RValue, LBracLoc, ReceiverTypeInfo, Sel,
2484  SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs), RBracLoc,
2485  isImplicit);
2486  }
2487 
2488  // Find the class to which we are sending this message.
2489  ObjCInterfaceDecl *Class = nullptr;
2490  const ObjCObjectType *ClassType = ReceiverType->getAs<ObjCObjectType>();
2491  if (!ClassType || !(Class = ClassType->getInterface())) {
2492  Diag(Loc, diag::err_invalid_receiver_class_message)
2493  << ReceiverType;
2494  return ExprError();
2495  }
2496  assert(Class && "We don't know which class we're messaging?");
2497  // objc++ diagnoses during typename annotation.
2498  if (!getLangOpts().CPlusPlus)
2499  (void)DiagnoseUseOfDecl(Class, SelectorSlotLocs);
2500  // Find the method we are messaging.
2501  if (!Method) {
2502  SourceRange TypeRange
2503  = SuperLoc.isValid()? SourceRange(SuperLoc)
2504  : ReceiverTypeInfo->getTypeLoc().getSourceRange();
2505  if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class),
2506  (getLangOpts().ObjCAutoRefCount
2507  ? diag::err_arc_receiver_forward_class
2508  : diag::warn_receiver_forward_class),
2509  TypeRange)) {
2510  // A forward class used in messaging is treated as a 'Class'
2511  Method = LookupFactoryMethodInGlobalPool(Sel,
2512  SourceRange(LBracLoc, RBracLoc));
2513  if (Method && !getLangOpts().ObjCAutoRefCount)
2514  Diag(Method->getLocation(), diag::note_method_sent_forward_class)
2515  << Method->getDeclName();
2516  }
2517  if (!Method)
2518  Method = Class->lookupClassMethod(Sel);
2519 
2520  // If we have an implementation in scope, check "private" methods.
2521  if (!Method)
2522  Method = Class->lookupPrivateClassMethod(Sel);
2523 
2524  if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs,
2525  nullptr, false, false, Class))
2526  return ExprError();
2527  }
2528 
2529  // Check the argument types and determine the result type.
2530  QualType ReturnType;
2531  ExprValueKind VK = VK_RValue;
2532 
2533  unsigned NumArgs = ArgsIn.size();
2534  Expr **Args = ArgsIn.data();
2535  if (CheckMessageArgumentTypes(/*Receiver=*/nullptr, ReceiverType,
2536  MultiExprArg(Args, NumArgs), Sel, SelectorLocs,
2537  Method, true, SuperLoc.isValid(), LBracLoc,
2538  RBracLoc, SourceRange(), ReturnType, VK))
2539  return ExprError();
2540 
2541  if (Method && !Method->getReturnType()->isVoidType() &&
2542  RequireCompleteType(LBracLoc, Method->getReturnType(),
2543  diag::err_illegal_message_expr_incomplete_type))
2544  return ExprError();
2545 
2546  // Warn about explicit call of +initialize on its own class. But not on 'super'.
2547  if (Method && Method->getMethodFamily() == OMF_initialize) {
2548  if (!SuperLoc.isValid()) {
2549  const ObjCInterfaceDecl *ID =
2550  dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext());
2551  if (ID == Class) {
2552  Diag(Loc, diag::warn_direct_initialize_call);
2553  Diag(Method->getLocation(), diag::note_method_declared_at)
2554  << Method->getDeclName();
2555  }
2556  }
2557  else if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2558  // [super initialize] is allowed only within an +initialize implementation
2559  if (CurMeth->getMethodFamily() != OMF_initialize) {
2560  Diag(Loc, diag::warn_direct_super_initialize_call);
2561  Diag(Method->getLocation(), diag::note_method_declared_at)
2562  << Method->getDeclName();
2563  Diag(CurMeth->getLocation(), diag::note_method_declared_at)
2564  << CurMeth->getDeclName();
2565  }
2566  }
2567  }
2568 
2569  DiagnoseCStringFormatDirectiveInObjCAPI(*this, Method, Sel, Args, NumArgs);
2570 
2571  // Construct the appropriate ObjCMessageExpr.
2572  ObjCMessageExpr *Result;
2573  if (SuperLoc.isValid())
2574  Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2575  SuperLoc, /*IsInstanceSuper=*/false,
2576  ReceiverType, Sel, SelectorLocs,
2577  Method, makeArrayRef(Args, NumArgs),
2578  RBracLoc, isImplicit);
2579  else {
2580  Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2581  ReceiverTypeInfo, Sel, SelectorLocs,
2582  Method, makeArrayRef(Args, NumArgs),
2583  RBracLoc, isImplicit);
2584  if (!isImplicit)
2585  checkCocoaAPI(*this, Result);
2586  }
2587  if (Method)
2588  checkFoundationAPI(*this, SelLoc, Method, makeArrayRef(Args, NumArgs),
2589  ReceiverType, /*IsClassObjectCall=*/true);
2590  return MaybeBindToTemporary(Result);
2591 }
2592 
2593 // ActOnClassMessage - used for both unary and keyword messages.
2594 // ArgExprs is optional - if it is present, the number of expressions
2595 // is obtained from Sel.getNumArgs().
2597  ParsedType Receiver,
2598  Selector Sel,
2599  SourceLocation LBracLoc,
2600  ArrayRef<SourceLocation> SelectorLocs,
2601  SourceLocation RBracLoc,
2602  MultiExprArg Args) {
2603  TypeSourceInfo *ReceiverTypeInfo;
2604  QualType ReceiverType = GetTypeFromParser(Receiver, &ReceiverTypeInfo);
2605  if (ReceiverType.isNull())
2606  return ExprError();
2607 
2608  if (!ReceiverTypeInfo)
2609  ReceiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType, LBracLoc);
2610 
2611  return BuildClassMessage(ReceiverTypeInfo, ReceiverType,
2612  /*SuperLoc=*/SourceLocation(), Sel,
2613  /*Method=*/nullptr, LBracLoc, SelectorLocs, RBracLoc,
2614  Args);
2615 }
2616 
2618  QualType ReceiverType,
2619  SourceLocation Loc,
2620  Selector Sel,
2621  ObjCMethodDecl *Method,
2622  MultiExprArg Args) {
2623  return BuildInstanceMessage(Receiver, ReceiverType,
2624  /*SuperLoc=*/!Receiver ? Loc : SourceLocation(),
2625  Sel, Method, Loc, Loc, Loc, Args,
2626  /*isImplicit=*/true);
2627 }
2628 
2630  if (!S.NSAPIObj)
2631  return false;
2632  const auto *Protocol = dyn_cast<ObjCProtocolDecl>(M->getDeclContext());
2633  if (!Protocol)
2634  return false;
2635  const IdentifierInfo *II = S.NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
2636  if (const auto *RootClass = dyn_cast_or_null<ObjCInterfaceDecl>(
2637  S.LookupSingleName(S.TUScope, II, Protocol->getBeginLoc(),
2639  for (const ObjCProtocolDecl *P : RootClass->all_referenced_protocols()) {
2640  if (P->getCanonicalDecl() == Protocol->getCanonicalDecl())
2641  return true;
2642  }
2643  }
2644  return false;
2645 }
2646 
2647 /// Build an Objective-C instance message expression.
2648 ///
2649 /// This routine takes care of both normal instance messages and
2650 /// instance messages to the superclass instance.
2651 ///
2652 /// \param Receiver The expression that computes the object that will
2653 /// receive this message. This may be empty, in which case we are
2654 /// sending to the superclass instance and \p SuperLoc must be a valid
2655 /// source location.
2656 ///
2657 /// \param ReceiverType The (static) type of the object receiving the
2658 /// message. When a \p Receiver expression is provided, this is the
2659 /// same type as that expression. For a superclass instance send, this
2660 /// is a pointer to the type of the superclass.
2661 ///
2662 /// \param SuperLoc The location of the "super" keyword in a
2663 /// superclass instance message.
2664 ///
2665 /// \param Sel The selector to which the message is being sent.
2666 ///
2667 /// \param Method The method that this instance message is invoking, if
2668 /// already known.
2669 ///
2670 /// \param LBracLoc The location of the opening square bracket ']'.
2671 ///
2672 /// \param RBracLoc The location of the closing square bracket ']'.
2673 ///
2674 /// \param ArgsIn The message arguments.
2676  QualType ReceiverType,
2677  SourceLocation SuperLoc,
2678  Selector Sel,
2679  ObjCMethodDecl *Method,
2680  SourceLocation LBracLoc,
2681  ArrayRef<SourceLocation> SelectorLocs,
2682  SourceLocation RBracLoc,
2683  MultiExprArg ArgsIn,
2684  bool isImplicit) {
2685  assert((Receiver || SuperLoc.isValid()) && "If the Receiver is null, the "
2686  "SuperLoc must be valid so we can "
2687  "use it instead.");
2688 
2689  // The location of the receiver.
2690  SourceLocation Loc = SuperLoc.isValid() ? SuperLoc : Receiver->getBeginLoc();
2691  SourceRange RecRange =
2692  SuperLoc.isValid()? SuperLoc : Receiver->getSourceRange();
2693  ArrayRef<SourceLocation> SelectorSlotLocs;
2694  if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2695  SelectorSlotLocs = SelectorLocs;
2696  else
2697  SelectorSlotLocs = Loc;
2698  SourceLocation SelLoc = SelectorSlotLocs.front();
2699 
2700  if (LBracLoc.isInvalid()) {
2701  Diag(Loc, diag::err_missing_open_square_message_send)
2702  << FixItHint::CreateInsertion(Loc, "[");
2703  LBracLoc = Loc;
2704  }
2705 
2706  // If we have a receiver expression, perform appropriate promotions
2707  // and determine receiver type.
2708  if (Receiver) {
2709  if (Receiver->hasPlaceholderType()) {
2710  ExprResult Result;
2711  if (Receiver->getType() == Context.UnknownAnyTy)
2712  Result = forceUnknownAnyToType(Receiver, Context.getObjCIdType());
2713  else
2714  Result = CheckPlaceholderExpr(Receiver);
2715  if (Result.isInvalid()) return ExprError();
2716  Receiver = Result.get();
2717  }
2718 
2719  if (Receiver->isTypeDependent()) {
2720  // If the receiver is type-dependent, we can't type-check anything
2721  // at this point. Build a dependent expression.
2722  unsigned NumArgs = ArgsIn.size();
2723  Expr **Args = ArgsIn.data();
2724  assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2725  return ObjCMessageExpr::Create(
2726  Context, Context.DependentTy, VK_RValue, LBracLoc, Receiver, Sel,
2727  SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs),
2728  RBracLoc, isImplicit);
2729  }
2730 
2731  // If necessary, apply function/array conversion to the receiver.
2732  // C99 6.7.5.3p[7,8].
2733  ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver);
2734  if (Result.isInvalid())
2735  return ExprError();
2736  Receiver = Result.get();
2737  ReceiverType = Receiver->getType();
2738 
2739  // If the receiver is an ObjC pointer, a block pointer, or an
2740  // __attribute__((NSObject)) pointer, we don't need to do any
2741  // special conversion in order to look up a receiver.
2742  if (ReceiverType->isObjCRetainableType()) {
2743  // do nothing
2744  } else if (!getLangOpts().ObjCAutoRefCount &&
2745  !Context.getObjCIdType().isNull() &&
2746  (ReceiverType->isPointerType() ||
2747  ReceiverType->isIntegerType())) {
2748  // Implicitly convert integers and pointers to 'id' but emit a warning.
2749  // But not in ARC.
2750  Diag(Loc, diag::warn_bad_receiver_type)
2751  << ReceiverType
2752  << Receiver->getSourceRange();
2753  if (ReceiverType->isPointerType()) {
2754  Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2755  CK_CPointerToObjCPointerCast).get();
2756  } else {
2757  // TODO: specialized warning on null receivers?
2758  bool IsNull = Receiver->isNullPointerConstant(Context,
2760  CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer;
2761  Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2762  Kind).get();
2763  }
2764  ReceiverType = Receiver->getType();
2765  } else if (getLangOpts().CPlusPlus) {
2766  // The receiver must be a complete type.
2767  if (RequireCompleteType(Loc, Receiver->getType(),
2768  diag::err_incomplete_receiver_type))
2769  return ExprError();
2770 
2771  ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver);
2772  if (result.isUsable()) {
2773  Receiver = result.get();
2774  ReceiverType = Receiver->getType();
2775  }
2776  }
2777  }
2778 
2779  if (ReceiverType->isObjCIdType() && !isImplicit)
2780  Diag(Receiver->getExprLoc(), diag::warn_messaging_unqualified_id);
2781 
2782  // There's a somewhat weird interaction here where we assume that we
2783  // won't actually have a method unless we also don't need to do some
2784  // of the more detailed type-checking on the receiver.
2785 
2786  if (!Method) {
2787  // Handle messages to id and __kindof types (where we use the
2788  // global method pool).
2789  const ObjCObjectType *typeBound = nullptr;
2790  bool receiverIsIdLike = ReceiverType->isObjCIdOrObjectKindOfType(Context,
2791  typeBound);
2792  if (receiverIsIdLike || ReceiverType->isBlockPointerType() ||
2793  (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) {
2795  // If we have a type bound, further filter the methods.
2796  CollectMultipleMethodsInGlobalPool(Sel, Methods, true/*InstanceFirst*/,
2797  true/*CheckTheOther*/, typeBound);
2798  if (!Methods.empty()) {
2799  // We choose the first method as the initial candidate, then try to
2800  // select a better one.
2801  Method = Methods[0];
2802 
2803  if (ObjCMethodDecl *BestMethod =
2804  SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(), Methods))
2805  Method = BestMethod;
2806 
2807  if (!AreMultipleMethodsInGlobalPool(Sel, Method,
2808  SourceRange(LBracLoc, RBracLoc),
2809  receiverIsIdLike, Methods))
2810  DiagnoseUseOfDecl(Method, SelectorSlotLocs);
2811  }
2812  } else if (ReceiverType->isObjCClassOrClassKindOfType() ||
2813  ReceiverType->isObjCQualifiedClassType()) {
2814  // Handle messages to Class.
2815  // We allow sending a message to a qualified Class ("Class<foo>"), which
2816  // is ok as long as one of the protocols implements the selector (if not,
2817  // warn).
2818  if (!ReceiverType->isObjCClassOrClassKindOfType()) {
2819  const ObjCObjectPointerType *QClassTy
2820  = ReceiverType->getAsObjCQualifiedClassType();
2821  // Search protocols for class methods.
2822  Method = LookupMethodInQualifiedType(Sel, QClassTy, false);
2823  if (!Method) {
2824  Method = LookupMethodInQualifiedType(Sel, QClassTy, true);
2825  // warn if instance method found for a Class message.
2826  if (Method && !isMethodDeclaredInRootProtocol(*this, Method)) {
2827  Diag(SelLoc, diag::warn_instance_method_on_class_found)
2828  << Method->getSelector() << Sel;
2829  Diag(Method->getLocation(), diag::note_method_declared_at)
2830  << Method->getDeclName();
2831  }
2832  }
2833  } else {
2834  if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2835  if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) {
2836  // As a guess, try looking for the method in the current interface.
2837  // This very well may not produce the "right" method.
2838 
2839  // First check the public methods in the class interface.
2840  Method = ClassDecl->lookupClassMethod(Sel);
2841 
2842  if (!Method)
2843  Method = ClassDecl->lookupPrivateClassMethod(Sel);
2844 
2845  if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs))
2846  return ExprError();
2847  }
2848  }
2849  if (!Method) {
2850  // If not messaging 'self', look for any factory method named 'Sel'.
2851  if (!Receiver || !isSelfExpr(Receiver)) {
2852  // If no class (factory) method was found, check if an _instance_
2853  // method of the same name exists in the root class only.
2855  CollectMultipleMethodsInGlobalPool(Sel, Methods,
2856  false/*InstanceFirst*/,
2857  true/*CheckTheOther*/);
2858  if (!Methods.empty()) {
2859  // We choose the first method as the initial candidate, then try
2860  // to select a better one.
2861  Method = Methods[0];
2862 
2863  // If we find an instance method, emit warning.
2864  if (Method->isInstanceMethod()) {
2865  if (const ObjCInterfaceDecl *ID =
2866  dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
2867  if (ID->getSuperClass())
2868  Diag(SelLoc, diag::warn_root_inst_method_not_found)
2869  << Sel << SourceRange(LBracLoc, RBracLoc);
2870  }
2871  }
2872 
2873  if (ObjCMethodDecl *BestMethod =
2874  SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(),
2875  Methods))
2876  Method = BestMethod;
2877  }
2878  }
2879  }
2880  }
2881  } else {
2882  ObjCInterfaceDecl *ClassDecl = nullptr;
2883 
2884  // We allow sending a message to a qualified ID ("id<foo>"), which is ok as
2885  // long as one of the protocols implements the selector (if not, warn).
2886  // And as long as message is not deprecated/unavailable (warn if it is).
2887  if (const ObjCObjectPointerType *QIdTy
2888  = ReceiverType->getAsObjCQualifiedIdType()) {
2889  // Search protocols for instance methods.
2890  Method = LookupMethodInQualifiedType(Sel, QIdTy, true);
2891  if (!Method)
2892  Method = LookupMethodInQualifiedType(Sel, QIdTy, false);
2893  if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs))
2894  return ExprError();
2895  } else if (const ObjCObjectPointerType *OCIType
2896  = ReceiverType->getAsObjCInterfacePointerType()) {
2897  // We allow sending a message to a pointer to an interface (an object).
2898  ClassDecl = OCIType->getInterfaceDecl();
2899 
2900  // Try to complete the type. Under ARC, this is a hard error from which
2901  // we don't try to recover.
2902  // FIXME: In the non-ARC case, this will still be a hard error if the
2903  // definition is found in a module that's not visible.
2904  const ObjCInterfaceDecl *forwardClass = nullptr;
2905  if (RequireCompleteType(Loc, OCIType->getPointeeType(),
2906  getLangOpts().ObjCAutoRefCount
2907  ? diag::err_arc_receiver_forward_instance
2908  : diag::warn_receiver_forward_instance,
2909  Receiver? Receiver->getSourceRange()
2910  : SourceRange(SuperLoc))) {
2911  if (getLangOpts().ObjCAutoRefCount)
2912  return ExprError();
2913 
2914  forwardClass = OCIType->getInterfaceDecl();
2915  Diag(Receiver ? Receiver->getBeginLoc() : SuperLoc,
2916  diag::note_receiver_is_id);
2917  Method = nullptr;
2918  } else {
2919  Method = ClassDecl->lookupInstanceMethod(Sel);
2920  }
2921 
2922  if (!Method)
2923  // Search protocol qualifiers.
2924  Method = LookupMethodInQualifiedType(Sel, OCIType, true);
2925 
2926  if (!Method) {
2927  // If we have implementations in scope, check "private" methods.
2928  Method = ClassDecl->lookupPrivateMethod(Sel);
2929 
2930  if (!Method && getLangOpts().ObjCAutoRefCount) {
2931  Diag(SelLoc, diag::err_arc_may_not_respond)
2932  << OCIType->getPointeeType() << Sel << RecRange
2933  << SourceRange(SelectorLocs.front(), SelectorLocs.back());
2934  return ExprError();
2935  }
2936 
2937  if (!Method && (!Receiver || !isSelfExpr(Receiver))) {
2938  // If we still haven't found a method, look in the global pool. This
2939  // behavior isn't very desirable, however we need it for GCC
2940  // compatibility. FIXME: should we deviate??
2941  if (OCIType->qual_empty()) {
2943  CollectMultipleMethodsInGlobalPool(Sel, Methods,
2944  true/*InstanceFirst*/,
2945  false/*CheckTheOther*/);
2946  if (!Methods.empty()) {
2947  // We choose the first method as the initial candidate, then try
2948  // to select a better one.
2949  Method = Methods[0];
2950 
2951  if (ObjCMethodDecl *BestMethod =
2952  SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(),
2953  Methods))
2954  Method = BestMethod;
2955 
2956  AreMultipleMethodsInGlobalPool(Sel, Method,
2957  SourceRange(LBracLoc, RBracLoc),
2958  true/*receiverIdOrClass*/,
2959  Methods);
2960  }
2961  if (Method && !forwardClass)
2962  Diag(SelLoc, diag::warn_maynot_respond)
2963  << OCIType->getInterfaceDecl()->getIdentifier()
2964  << Sel << RecRange;
2965  }
2966  }
2967  }
2968  if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs, forwardClass))
2969  return ExprError();
2970  } else {
2971  // Reject other random receiver types (e.g. structs).
2972  Diag(Loc, diag::err_bad_receiver_type)
2973  << ReceiverType << Receiver->getSourceRange();
2974  return ExprError();
2975  }
2976  }
2977  }
2978 
2979  FunctionScopeInfo *DIFunctionScopeInfo =
2980  (Method && Method->getMethodFamily() == OMF_init)
2981  ? getEnclosingFunction() : nullptr;
2982 
2983  if (DIFunctionScopeInfo &&
2984  DIFunctionScopeInfo->ObjCIsDesignatedInit &&
2985  (SuperLoc.isValid() || isSelfExpr(Receiver))) {
2986  bool isDesignatedInitChain = false;
2987  if (SuperLoc.isValid()) {
2988  if (const ObjCObjectPointerType *
2989  OCIType = ReceiverType->getAsObjCInterfacePointerType()) {
2990  if (const ObjCInterfaceDecl *ID = OCIType->getInterfaceDecl()) {
2991  // Either we know this is a designated initializer or we
2992  // conservatively assume it because we don't know for sure.
2993  if (!ID->declaresOrInheritsDesignatedInitializers() ||
2994  ID->isDesignatedInitializer(Sel)) {
2995  isDesignatedInitChain = true;
2996  DIFunctionScopeInfo->ObjCWarnForNoDesignatedInitChain = false;
2997  }
2998  }
2999  }
3000  }
3001  if (!isDesignatedInitChain) {
3002  const ObjCMethodDecl *InitMethod = nullptr;
3003  bool isDesignated =
3004  getCurMethodDecl()->isDesignatedInitializerForTheInterface(&InitMethod);
3005  assert(isDesignated && InitMethod);
3006  (void)isDesignated;
3007  Diag(SelLoc, SuperLoc.isValid() ?
3008  diag::warn_objc_designated_init_non_designated_init_call :
3009  diag::warn_objc_designated_init_non_super_designated_init_call);
3010  Diag(InitMethod->getLocation(),
3011  diag::note_objc_designated_init_marked_here);
3012  }
3013  }
3014 
3015  if (DIFunctionScopeInfo &&
3016  DIFunctionScopeInfo->ObjCIsSecondaryInit &&
3017  (SuperLoc.isValid() || isSelfExpr(Receiver))) {
3018  if (SuperLoc.isValid()) {
3019  Diag(SelLoc, diag::warn_objc_secondary_init_super_init_call);
3020  } else {
3021  DIFunctionScopeInfo->ObjCWarnForNoInitDelegation = false;
3022  }
3023  }
3024 
3025  // Check the message arguments.
3026  unsigned NumArgs = ArgsIn.size();
3027  Expr **Args = ArgsIn.data();
3028  QualType ReturnType;
3029  ExprValueKind VK = VK_RValue;
3030  bool ClassMessage = (ReceiverType->isObjCClassType() ||
3031  ReceiverType->isObjCQualifiedClassType());
3032  if (CheckMessageArgumentTypes(Receiver, ReceiverType,
3033  MultiExprArg(Args, NumArgs), Sel, SelectorLocs,
3034  Method, ClassMessage, SuperLoc.isValid(),
3035  LBracLoc, RBracLoc, RecRange, ReturnType, VK))
3036  return ExprError();
3037 
3038  if (Method && !Method->getReturnType()->isVoidType() &&
3039  RequireCompleteType(LBracLoc, Method->getReturnType(),
3040  diag::err_illegal_message_expr_incomplete_type))
3041  return ExprError();
3042 
3043  // In ARC, forbid the user from sending messages to
3044  // retain/release/autorelease/dealloc/retainCount explicitly.
3045  if (getLangOpts().ObjCAutoRefCount) {
3046  ObjCMethodFamily family =
3047  (Method ? Method->getMethodFamily() : Sel.getMethodFamily());
3048  switch (family) {
3049  case OMF_init:
3050  if (Method)
3051  checkInitMethod(Method, ReceiverType);
3052  break;
3053 
3054  case OMF_None:
3055  case OMF_alloc:
3056  case OMF_copy:
3057  case OMF_finalize:
3058  case OMF_mutableCopy:
3059  case OMF_new:
3060  case OMF_self:
3061  case OMF_initialize:
3062  break;
3063 
3064  case OMF_dealloc:
3065  case OMF_retain:
3066  case OMF_release:
3067  case OMF_autorelease:
3068  case OMF_retainCount:
3069  Diag(SelLoc, diag::err_arc_illegal_explicit_message)
3070  << Sel << RecRange;
3071  break;
3072 
3073  case OMF_performSelector:
3074  if (Method && NumArgs >= 1) {
3075  if (const auto *SelExp =
3076  dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens())) {
3077  Selector ArgSel = SelExp->getSelector();
3078  ObjCMethodDecl *SelMethod =
3079  LookupInstanceMethodInGlobalPool(ArgSel,
3080  SelExp->getSourceRange());
3081  if (!SelMethod)
3082  SelMethod =
3083  LookupFactoryMethodInGlobalPool(ArgSel,
3084  SelExp->getSourceRange());
3085  if (SelMethod) {
3086  ObjCMethodFamily SelFamily = SelMethod->getMethodFamily();
3087  switch (SelFamily) {
3088  case OMF_alloc:
3089  case OMF_copy:
3090  case OMF_mutableCopy:
3091  case OMF_new:
3092  case OMF_init:
3093  // Issue error, unless ns_returns_not_retained.
3094  if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
3095  // selector names a +1 method
3096  Diag(SelLoc,
3097  diag::err_arc_perform_selector_retains);
3098  Diag(SelMethod->getLocation(), diag::note_method_declared_at)
3099  << SelMethod->getDeclName();
3100  }
3101  break;
3102  default:
3103  // +0 call. OK. unless ns_returns_retained.
3104  if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) {
3105  // selector names a +1 method
3106  Diag(SelLoc,
3107  diag::err_arc_perform_selector_retains);
3108  Diag(SelMethod->getLocation(), diag::note_method_declared_at)
3109  << SelMethod->getDeclName();
3110  }
3111  break;
3112  }
3113  }
3114  } else {
3115  // error (may leak).
3116  Diag(SelLoc, diag::warn_arc_perform_selector_leaks);
3117  Diag(Args[0]->getExprLoc(), diag::note_used_here);
3118  }
3119  }
3120  break;
3121  }
3122  }
3123 
3124  DiagnoseCStringFormatDirectiveInObjCAPI(*this, Method, Sel, Args, NumArgs);
3125 
3126  // Construct the appropriate ObjCMessageExpr instance.
3127  ObjCMessageExpr *Result;
3128  if (SuperLoc.isValid())
3129  Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
3130  SuperLoc, /*IsInstanceSuper=*/true,
3131  ReceiverType, Sel, SelectorLocs, Method,
3132  makeArrayRef(Args, NumArgs), RBracLoc,
3133  isImplicit);
3134  else {
3135  Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
3136  Receiver, Sel, SelectorLocs, Method,
3137  makeArrayRef(Args, NumArgs), RBracLoc,
3138  isImplicit);
3139  if (!isImplicit)
3140  checkCocoaAPI(*this, Result);
3141  }
3142  if (Method) {
3143  bool IsClassObjectCall = ClassMessage;
3144  // 'self' message receivers in class methods should be treated as message
3145  // sends to the class object in order for the semantic checks to be
3146  // performed correctly. Messages to 'super' already count as class messages,
3147  // so they don't need to be handled here.
3148  if (Receiver && isSelfExpr(Receiver)) {
3149  if (const auto *OPT = ReceiverType->getAs<ObjCObjectPointerType>()) {
3150  if (OPT->getObjectType()->isObjCClass()) {
3151  if (const auto *CurMeth = getCurMethodDecl()) {
3152  IsClassObjectCall = true;
3153  ReceiverType =
3154  Context.getObjCInterfaceType(CurMeth->getClassInterface());
3155  }
3156  }
3157  }
3158  }
3159  checkFoundationAPI(*this, SelLoc, Method, makeArrayRef(Args, NumArgs),
3160  ReceiverType, IsClassObjectCall);
3161  }
3162 
3163  if (getLangOpts().ObjCAutoRefCount) {
3164  // In ARC, annotate delegate init calls.
3165  if (Result->getMethodFamily() == OMF_init &&
3166  (SuperLoc.isValid() || isSelfExpr(Receiver))) {
3167  // Only consider init calls *directly* in init implementations,
3168  // not within blocks.
3169  ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(CurContext);
3170  if (method && method->getMethodFamily() == OMF_init) {
3171  // The implicit assignment to self means we also don't want to
3172  // consume the result.
3173  Result->setDelegateInitCall(true);
3174  return Result;
3175  }
3176  }
3177 
3178  // In ARC, check for message sends which are likely to introduce
3179  // retain cycles.
3180  checkRetainCycles(Result);
3181  }
3182 
3183  if (getLangOpts().ObjCWeak) {
3184  if (!isImplicit && Method) {
3185  if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {
3186  bool IsWeak =
3187  Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak;
3188  if (!IsWeak && Sel.isUnarySelector())
3189  IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak;
3190  if (IsWeak && !isUnevaluatedContext() &&
3191  !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, LBracLoc))
3192  getCurFunction()->recordUseOfWeak(Result, Prop);
3193  }
3194  }
3195  }
3196 
3197  CheckObjCCircularContainer(Result);
3198 
3199  return MaybeBindToTemporary(Result);
3200 }
3201 
3203  if (ObjCSelectorExpr *OSE =
3204  dyn_cast<ObjCSelectorExpr>(Arg->IgnoreParenCasts())) {
3205  Selector Sel = OSE->getSelector();
3206  SourceLocation Loc = OSE->getAtLoc();
3207  auto Pos = S.ReferencedSelectors.find(Sel);
3208  if (Pos != S.ReferencedSelectors.end() && Pos->second == Loc)
3209  S.ReferencedSelectors.erase(Pos);
3210  }
3211 }
3212 
3213 // ActOnInstanceMessage - used for both unary and keyword messages.
3214 // ArgExprs is optional - if it is present, the number of expressions
3215 // is obtained from Sel.getNumArgs().
3217  Expr *Receiver,
3218  Selector Sel,
3219  SourceLocation LBracLoc,
3220  ArrayRef<SourceLocation> SelectorLocs,
3221  SourceLocation RBracLoc,
3222  MultiExprArg Args) {
3223  if (!Receiver)
3224  return ExprError();
3225 
3226  // A ParenListExpr can show up while doing error recovery with invalid code.
3227  if (isa<ParenListExpr>(Receiver)) {
3228  ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver);
3229  if (Result.isInvalid()) return ExprError();
3230  Receiver = Result.get();
3231  }
3232 
3233  if (RespondsToSelectorSel.isNull()) {
3234  IdentifierInfo *SelectorId = &Context.Idents.get("respondsToSelector");
3235  RespondsToSelectorSel = Context.Selectors.getUnarySelector(SelectorId);
3236  }
3237  if (Sel == RespondsToSelectorSel)
3238  RemoveSelectorFromWarningCache(*this, Args[0]);
3239 
3240  return BuildInstanceMessage(Receiver, Receiver->getType(),
3241  /*SuperLoc=*/SourceLocation(), Sel,
3242  /*Method=*/nullptr, LBracLoc, SelectorLocs,
3243  RBracLoc, Args);
3244 }
3245 
3247  /// int, void, struct A
3249 
3250  /// id, void (^)()
3252 
3253  /// id*, id***, void (^*)(),
3255 
3256  /// void* might be a normal C type, or it might a CF type.
3258 
3259  /// struct A*
3261 };
3262 
3264  return (ACTC == ACTC_retainable ||
3265  ACTC == ACTC_coreFoundation ||
3266  ACTC == ACTC_voidPtr);
3267 }
3268 
3270  return ACTC == ACTC_none ||
3271  ACTC == ACTC_voidPtr ||
3272  ACTC == ACTC_coreFoundation;
3273 }
3274 
3276  bool isIndirect = false;
3277 
3278  // Ignore an outermost reference type.
3279  if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
3280  type = ref->getPointeeType();
3281  isIndirect = true;
3282  }
3283 
3284  // Drill through pointers and arrays recursively.
3285  while (true) {
3286  if (const PointerType *ptr = type->getAs<PointerType>()) {
3287  type = ptr->getPointeeType();
3288 
3289  // The first level of pointer may be the innermost pointer on a CF type.
3290  if (!isIndirect) {
3291  if (type->isVoidType()) return ACTC_voidPtr;
3292  if (type->isRecordType()) return ACTC_coreFoundation;
3293  }
3294  } else if (const ArrayType *array = type->getAsArrayTypeUnsafe()) {
3295  type = QualType(array->getElementType()->getBaseElementTypeUnsafe(), 0);
3296  } else {
3297  break;
3298  }
3299  isIndirect = true;
3300  }
3301 
3302  if (isIndirect) {
3303  if (type->isObjCARCBridgableType())
3304  return ACTC_indirectRetainable;
3305  return ACTC_none;
3306  }
3307 
3308  if (type->isObjCARCBridgableType())
3309  return ACTC_retainable;
3310 
3311  return ACTC_none;
3312 }
3313 
3314 namespace {
3315  /// A result from the cast checker.
3316  enum ACCResult {
3317  /// Cannot be casted.
3318  ACC_invalid,
3319 
3320  /// Can be safely retained or not retained.
3321  ACC_bottom,
3322 
3323  /// Can be casted at +0.
3324  ACC_plusZero,
3325 
3326  /// Can be casted at +1.
3327  ACC_plusOne
3328  };
3329  ACCResult merge(ACCResult left, ACCResult right) {
3330  if (left == right) return left;
3331  if (left == ACC_bottom) return right;
3332  if (right == ACC_bottom) return left;
3333  return ACC_invalid;
3334  }
3335 
3336  /// A checker which white-lists certain expressions whose conversion
3337  /// to or from retainable type would otherwise be forbidden in ARC.
3338  class ARCCastChecker : public StmtVisitor<ARCCastChecker, ACCResult> {
3340 
3341  ASTContext &Context;
3342  ARCConversionTypeClass SourceClass;
3343  ARCConversionTypeClass TargetClass;
3344  bool Diagnose;
3345 
3346  static bool isCFType(QualType type) {
3347  // Someday this can use ns_bridged. For now, it has to do this.
3348  return type->isCARCBridgableType();
3349  }
3350 
3351  public:
3352  ARCCastChecker(ASTContext &Context, ARCConversionTypeClass source,
3353  ARCConversionTypeClass target, bool diagnose)
3354  : Context(Context), SourceClass(source), TargetClass(target),
3355  Diagnose(diagnose) {}
3356 
3357  using super::Visit;
3358  ACCResult Visit(Expr *e) {
3359  return super::Visit(e->IgnoreParens());
3360  }
3361 
3362  ACCResult VisitStmt(Stmt *s) {
3363  return ACC_invalid;
3364  }
3365 
3366  /// Null pointer constants can be casted however you please.
3367  ACCResult VisitExpr(Expr *e) {
3369  return ACC_bottom;
3370  return ACC_invalid;
3371  }
3372 
3373  /// Objective-C string literals can be safely casted.
3374  ACCResult VisitObjCStringLiteral(ObjCStringLiteral *e) {
3375  // If we're casting to any retainable type, go ahead. Global
3376  // strings are immune to retains, so this is bottom.
3377  if (isAnyRetainable(TargetClass)) return ACC_bottom;
3378 
3379  return ACC_invalid;
3380  }
3381 
3382  /// Look through certain implicit and explicit casts.
3383  ACCResult VisitCastExpr(CastExpr *e) {
3384  switch (e->getCastKind()) {
3385  case CK_NullToPointer:
3386  return ACC_bottom;
3387 
3388  case CK_NoOp:
3389  case CK_LValueToRValue:
3390  case CK_BitCast:
3391  case CK_CPointerToObjCPointerCast:
3392  case CK_BlockPointerToObjCPointerCast:
3393  case CK_AnyPointerToBlockPointerCast:
3394  return Visit(e->getSubExpr());
3395 
3396  default:
3397  return ACC_invalid;
3398  }
3399  }
3400 
3401  /// Look through unary extension.
3402  ACCResult VisitUnaryExtension(UnaryOperator *e) {
3403  return Visit(e->getSubExpr());
3404  }
3405 
3406  /// Ignore the LHS of a comma operator.
3407  ACCResult VisitBinComma(BinaryOperator *e) {
3408  return Visit(e->getRHS());
3409  }
3410 
3411  /// Conditional operators are okay if both sides are okay.
3412  ACCResult VisitConditionalOperator(ConditionalOperator *e) {
3413  ACCResult left = Visit(e->getTrueExpr());
3414  if (left == ACC_invalid) return ACC_invalid;
3415  return merge(left, Visit(e->getFalseExpr()));
3416  }
3417 
3418  /// Look through pseudo-objects.
3419  ACCResult VisitPseudoObjectExpr(PseudoObjectExpr *e) {
3420  // If we're getting here, we should always have a result.
3421  return Visit(e->getResultExpr());
3422  }
3423 
3424  /// Statement expressions are okay if their result expression is okay.
3425  ACCResult VisitStmtExpr(StmtExpr *e) {
3426  return Visit(e->getSubStmt()->body_back());
3427  }
3428 
3429  /// Some declaration references are okay.
3430  ACCResult VisitDeclRefExpr(DeclRefExpr *e) {
3431  VarDecl *var = dyn_cast<VarDecl>(e->getDecl());
3432  // References to global constants are okay.
3433  if (isAnyRetainable(TargetClass) &&
3434  isAnyRetainable(SourceClass) &&
3435  var &&
3436  !var->hasDefinition(Context) &&
3437  var->getType().isConstQualified()) {
3438 
3439  // In system headers, they can also be assumed to be immune to retains.
3440  // These are things like 'kCFStringTransformToLatin'.
3441  if (Context.getSourceManager().isInSystemHeader(var->getLocation()))
3442  return ACC_bottom;
3443 
3444  return ACC_plusZero;
3445  }
3446 
3447  // Nothing else.
3448  return ACC_invalid;
3449  }
3450 
3451  /// Some calls are okay.
3452  ACCResult VisitCallExpr(CallExpr *e) {
3453  if (FunctionDecl *fn = e->getDirectCallee())
3454  if (ACCResult result = checkCallToFunction(fn))
3455  return result;
3456 
3457  return super::VisitCallExpr(e);
3458  }
3459 
3460  ACCResult checkCallToFunction(FunctionDecl *fn) {
3461  // Require a CF*Ref return type.
3462  if (!isCFType(fn->getReturnType()))
3463  return ACC_invalid;
3464 
3465  if (!isAnyRetainable(TargetClass))
3466  return ACC_invalid;
3467 
3468  // Honor an explicit 'not retained' attribute.
3469  if (fn->hasAttr<CFReturnsNotRetainedAttr>())
3470  return ACC_plusZero;
3471 
3472  // Honor an explicit 'retained' attribute, except that for
3473  // now we're not going to permit implicit handling of +1 results,
3474  // because it's a bit frightening.
3475  if (fn->hasAttr<CFReturnsRetainedAttr>())
3476  return Diagnose ? ACC_plusOne
3477  : ACC_invalid; // ACC_plusOne if we start accepting this
3478 
3479  // Recognize this specific builtin function, which is used by CFSTR.
3480  unsigned builtinID = fn->getBuiltinID();
3481  if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString)
3482  return ACC_bottom;
3483 
3484  // Otherwise, don't do anything implicit with an unaudited function.
3485  if (!fn->hasAttr<CFAuditedTransferAttr>())
3486  return ACC_invalid;
3487 
3488  // Otherwise, it's +0 unless it follows the create convention.
3490  return Diagnose ? ACC_plusOne
3491  : ACC_invalid; // ACC_plusOne if we start accepting this
3492 
3493  return ACC_plusZero;
3494  }
3495 
3496  ACCResult VisitObjCMessageExpr(ObjCMessageExpr *e) {
3497  return checkCallToMethod(e->getMethodDecl());
3498  }
3499 
3500  ACCResult VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *e) {
3501  ObjCMethodDecl *method;
3502  if (e->isExplicitProperty())
3503  method = e->getExplicitProperty()->getGetterMethodDecl();
3504  else
3505  method = e->getImplicitPropertyGetter();
3506  return checkCallToMethod(method);
3507  }
3508 
3509  ACCResult checkCallToMethod(ObjCMethodDecl *method) {
3510  if (!method) return ACC_invalid;
3511 
3512  // Check for message sends to functions returning CF types. We
3513  // just obey the Cocoa conventions with these, even though the
3514  // return type is CF.
3515  if (!isAnyRetainable(TargetClass) || !isCFType(method->getReturnType()))
3516  return ACC_invalid;
3517 
3518  // If the method is explicitly marked not-retained, it's +0.
3519  if (method->hasAttr<CFReturnsNotRetainedAttr>())
3520  return ACC_plusZero;
3521 
3522  // If the method is explicitly marked as returning retained, or its
3523  // selector follows a +1 Cocoa convention, treat it as +1.
3524  if (method->hasAttr<CFReturnsRetainedAttr>())
3525  return ACC_plusOne;
3526 
3527  switch (method->getSelector().getMethodFamily()) {
3528  case OMF_alloc:
3529  case OMF_copy:
3530  case OMF_mutableCopy:
3531  case OMF_new:
3532  return ACC_plusOne;
3533 
3534  default:
3535  // Otherwise, treat it as +0.
3536  return ACC_plusZero;
3537  }
3538  }
3539  };
3540 } // end anonymous namespace
3541 
3542 bool Sema::isKnownName(StringRef name) {
3543  if (name.empty())
3544  return false;
3545  LookupResult R(*this, &Context.Idents.get(name), SourceLocation(),
3547  return LookupName(R, TUScope, false);
3548 }
3549 
3551  DiagnosticBuilder &DiagB,
3553  SourceLocation afterLParen,
3554  QualType castType,
3555  Expr *castExpr,
3556  Expr *realCast,
3557  const char *bridgeKeyword,
3558  const char *CFBridgeName) {
3559  // We handle C-style and implicit casts here.
3560  switch (CCK) {
3563  case Sema::CCK_CStyleCast:
3564  case Sema::CCK_OtherCast:
3565  break;
3567  return;
3568  }
3569 
3570  if (CFBridgeName) {
3571  if (CCK == Sema::CCK_OtherCast) {
3572  if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
3573  SourceRange range(NCE->getOperatorLoc(),
3574  NCE->getAngleBrackets().getEnd());
3575  SmallString<32> BridgeCall;
3576 
3578  char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
3579  if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
3580  BridgeCall += ' ';
3581 
3582  BridgeCall += CFBridgeName;
3583  DiagB.AddFixItHint(FixItHint::CreateReplacement(range, BridgeCall));
3584  }
3585  return;
3586  }
3587  Expr *castedE = castExpr;
3588  if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(castedE))
3589  castedE = CCE->getSubExpr();
3590  castedE = castedE->IgnoreImpCasts();
3591  SourceRange range = castedE->getSourceRange();
3592 
3593  SmallString<32> BridgeCall;
3594 
3596  char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
3597  if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
3598  BridgeCall += ' ';
3599 
3600  BridgeCall += CFBridgeName;
3601 
3602  if (isa<ParenExpr>(castedE)) {
3604  BridgeCall));
3605  } else {
3606  BridgeCall += '(';
3608  BridgeCall));
3610  S.getLocForEndOfToken(range.getEnd()),
3611  ")"));
3612  }
3613  return;
3614  }
3615 
3616  if (CCK == Sema::CCK_CStyleCast) {
3617  DiagB.AddFixItHint(FixItHint::CreateInsertion(afterLParen, bridgeKeyword));
3618  } else if (CCK == Sema::CCK_OtherCast) {
3619  if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
3620  std::string castCode = "(";
3621  castCode += bridgeKeyword;
3622  castCode += castType.getAsString();
3623  castCode += ")";
3624  SourceRange Range(NCE->getOperatorLoc(),
3625  NCE->getAngleBrackets().getEnd());
3626  DiagB.AddFixItHint(FixItHint::CreateReplacement(Range, castCode));
3627  }
3628  } else {
3629  std::string castCode = "(";
3630  castCode += bridgeKeyword;
3631  castCode += castType.getAsString();
3632  castCode += ")";
3633  Expr *castedE = castExpr->IgnoreImpCasts();
3634  SourceRange range = castedE->getSourceRange();
3635  if (isa<ParenExpr>(castedE)) {
3637  castCode));
3638  } else {
3639  castCode += "(";
3641  castCode));
3643  S.getLocForEndOfToken(range.getEnd()),
3644  ")"));
3645  }
3646  }
3647 }
3648 
3649 template <typename T>
3650 static inline T *getObjCBridgeAttr(const TypedefType *TD) {
3651  TypedefNameDecl *TDNDecl = TD->getDecl();
3652  QualType QT = TDNDecl->getUnderlyingType();
3653  if (QT->isPointerType()) {
3654  QT = QT->getPointeeType();
3655  if (const RecordType *RT = QT->getAs<RecordType>())
3656  if (RecordDecl *RD = RT->getDecl()->getMostRecentDecl())
3657  return RD->getAttr<T>();
3658  }
3659  return nullptr;
3660 }
3661 
3662 static ObjCBridgeRelatedAttr *ObjCBridgeRelatedAttrFromType(QualType T,
3663  TypedefNameDecl *&TDNDecl) {
3664  while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3665  TDNDecl = TD->getDecl();
3666  if (ObjCBridgeRelatedAttr *ObjCBAttr =
3667  getObjCBridgeAttr<ObjCBridgeRelatedAttr>(TD))
3668  return ObjCBAttr;
3669  T = TDNDecl->getUnderlyingType();
3670  }
3671  return nullptr;
3672 }
3673 
3674 static void
3676  QualType castType, ARCConversionTypeClass castACTC,
3677  Expr *castExpr, Expr *realCast,
3678  ARCConversionTypeClass exprACTC,
3680  SourceLocation loc =
3681  (castRange.isValid() ? castRange.getBegin() : castExpr->getExprLoc());
3682 
3684  UnavailableAttr::IR_ARCForbiddenConversion))
3685  return;
3686 
3687  QualType castExprType = castExpr->getType();
3688  // Defer emitting a diagnostic for bridge-related casts; that will be
3689  // handled by CheckObjCBridgeRelatedConversions.
3690  TypedefNameDecl *TDNDecl = nullptr;
3691  if ((castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable &&
3692  ObjCBridgeRelatedAttrFromType(castType, TDNDecl)) ||
3693  (exprACTC == ACTC_coreFoundation && castACTC == ACTC_retainable &&
3694  ObjCBridgeRelatedAttrFromType(castExprType, TDNDecl)))
3695  return;
3696 
3697  unsigned srcKind = 0;
3698  switch (exprACTC) {
3699  case ACTC_none:
3700  case ACTC_coreFoundation:
3701  case ACTC_voidPtr:
3702  srcKind = (castExprType->isPointerType() ? 1 : 0);
3703  break;
3704  case ACTC_retainable:
3705  srcKind = (castExprType->isBlockPointerType() ? 2 : 3);
3706  break;
3708  srcKind = 4;
3709  break;
3710  }
3711 
3712  // Check whether this could be fixed with a bridge cast.
3713  SourceLocation afterLParen = S.getLocForEndOfToken(castRange.getBegin());
3714  SourceLocation noteLoc = afterLParen.isValid() ? afterLParen : loc;
3715 
3716  unsigned convKindForDiag = Sema::isCast(CCK) ? 0 : 1;
3717 
3718  // Bridge from an ARC type to a CF type.
3719  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {
3720 
3721  S.Diag(loc, diag::err_arc_cast_requires_bridge)
3722  << convKindForDiag
3723  << 2 // of C pointer type
3724  << castExprType
3725  << unsigned(castType->isBlockPointerType()) // to ObjC|block type
3726  << castType
3727  << castRange
3728  << castExpr->getSourceRange();
3729  bool br = S.isKnownName("CFBridgingRelease");
3730  ACCResult CreateRule =
3731  ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3732  assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3733  if (CreateRule != ACC_plusOne)
3734  {
3735  DiagnosticBuilder DiagB =
3736  (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3737  : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3738 
3739  addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3740  castType, castExpr, realCast, "__bridge ",
3741  nullptr);
3742  }
3743  if (CreateRule != ACC_plusZero)
3744  {
3745  DiagnosticBuilder DiagB =
3746  (CCK == Sema::CCK_OtherCast && !br) ?
3747  S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer) << castExprType :
3748  S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3749  diag::note_arc_bridge_transfer)
3750  << castExprType << br;
3751 
3752  addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3753  castType, castExpr, realCast, "__bridge_transfer ",
3754  br ? "CFBridgingRelease" : nullptr);
3755  }
3756 
3757  return;
3758  }
3759 
3760  // Bridge from a CF type to an ARC type.
3761  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {
3762  bool br = S.isKnownName("CFBridgingRetain");
3763  S.Diag(loc, diag::err_arc_cast_requires_bridge)
3764  << convKindForDiag
3765  << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type
3766  << castExprType
3767  << 2 // to C pointer type
3768  << castType
3769  << castRange
3770  << castExpr->getSourceRange();
3771  ACCResult CreateRule =
3772  ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3773  assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3774  if (CreateRule != ACC_plusOne)
3775  {
3776  DiagnosticBuilder DiagB =
3777  (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3778  : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3779  addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3780  castType, castExpr, realCast, "__bridge ",
3781  nullptr);
3782  }
3783  if (CreateRule != ACC_plusZero)
3784  {
3785  DiagnosticBuilder DiagB =
3786  (CCK == Sema::CCK_OtherCast && !br) ?
3787  S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType :
3788  S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3789  diag::note_arc_bridge_retained)
3790  << castType << br;
3791 
3792  addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3793  castType, castExpr, realCast, "__bridge_retained ",
3794  br ? "CFBridgingRetain" : nullptr);
3795  }
3796 
3797  return;
3798  }
3799 
3800  S.Diag(loc, diag::err_arc_mismatched_cast)
3801  << !convKindForDiag
3802  << srcKind << castExprType << castType
3803  << castRange << castExpr->getSourceRange();
3804 }
3805 
3806 template <typename TB>
3807 static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr,
3808  bool &HadTheAttribute, bool warn) {
3809  QualType T = castExpr->getType();
3810  HadTheAttribute = false;
3811  while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3812  TypedefNameDecl *TDNDecl = TD->getDecl();
3813  if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {
3814  if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {
3815  HadTheAttribute = true;
3816  if (Parm->isStr("id"))
3817  return true;
3818 
3819  NamedDecl *Target = nullptr;
3820  // Check for an existing type with this name.
3823  if (S.LookupName(R, S.TUScope)) {
3824  Target = R.getFoundDecl();
3825  if (Target && isa<ObjCInterfaceDecl>(Target)) {
3826  ObjCInterfaceDecl *ExprClass = cast<ObjCInterfaceDecl>(Target);
3827  if (const ObjCObjectPointerType *InterfacePointerType =
3828  castType->getAsObjCInterfacePointerType()) {
3829  ObjCInterfaceDecl *CastClass
3830  = InterfacePointerType->getObjectType()->getInterface();
3831  if ((CastClass == ExprClass) ||
3832  (CastClass && CastClass->isSuperClassOf(ExprClass)))
3833  return true;
3834  if (warn)
3835  S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge)
3836  << T << Target->getName() << castType->getPointeeType();
3837  return false;
3838  } else if (castType->isObjCIdType() ||
3840  castType, ExprClass)))
3841  // ok to cast to 'id'.
3842  // casting to id<p-list> is ok if bridge type adopts all of
3843  // p-list protocols.
3844  return true;
3845  else {
3846  if (warn) {
3847  S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge)
3848  << T << Target->getName() << castType;
3849  S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
3850  S.Diag(Target->getBeginLoc(), diag::note_declared_at);
3851  }
3852  return false;
3853  }
3854  }
3855  } else if (!castType->isObjCIdType()) {
3856  S.Diag(castExpr->getBeginLoc(),
3857  diag::err_objc_cf_bridged_not_interface)
3858  << castExpr->getType() << Parm;
3859  S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
3860  if (Target)
3861  S.Diag(Target->getBeginLoc(), diag::note_declared_at);
3862  }
3863  return true;
3864  }
3865  return false;
3866  }
3867  T = TDNDecl->getUnderlyingType();
3868  }
3869  return true;
3870 }
3871 
3872 template <typename TB>
3873 static bool CheckObjCBridgeCFCast(Sema &S, QualType castType, Expr *castExpr,
3874  bool &HadTheAttribute, bool warn) {
3875  QualType T = castType;
3876  HadTheAttribute = false;
3877  while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3878  TypedefNameDecl *TDNDecl = TD->getDecl();
3879  if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {
3880  if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {
3881  HadTheAttribute = true;
3882  if (Parm->isStr("id"))
3883  return true;
3884 
3885  NamedDecl *Target = nullptr;
3886  // Check for an existing type with this name.
3889  if (S.LookupName(R, S.TUScope)) {
3890  Target = R.getFoundDecl();
3891  if (Target && isa<ObjCInterfaceDecl>(Target)) {
3892  ObjCInterfaceDecl *CastClass = cast<ObjCInterfaceDecl>(Target);
3893  if (const ObjCObjectPointerType *InterfacePointerType =
3894  castExpr->getType()->getAsObjCInterfacePointerType()) {
3895  ObjCInterfaceDecl *ExprClass
3896  = InterfacePointerType->getObjectType()->getInterface();
3897  if ((CastClass == ExprClass) ||
3898  (ExprClass && CastClass->isSuperClassOf(ExprClass)))
3899  return true;
3900  if (warn) {
3901  S.Diag(castExpr->getBeginLoc(),
3902  diag::warn_objc_invalid_bridge_to_cf)
3903  << castExpr->getType()->getPointeeType() << T;
3904  S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
3905  }
3906  return false;
3907  } else if (castExpr->getType()->isObjCIdType() ||
3909  castExpr->getType(), CastClass)))
3910  // ok to cast an 'id' expression to a CFtype.
3911  // ok to cast an 'id<plist>' expression to CFtype provided plist
3912  // adopts all of CFtype's ObjetiveC's class plist.
3913  return true;
3914  else {
3915  if (warn) {
3916  S.Diag(castExpr->getBeginLoc(),
3917  diag::warn_objc_invalid_bridge_to_cf)
3918  << castExpr->getType() << castType;
3919  S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
3920  S.Diag(Target->getBeginLoc(), diag::note_declared_at);
3921  }
3922  return false;
3923  }
3924  }
3925  }
3926  S.Diag(castExpr->getBeginLoc(),
3927  diag::err_objc_ns_bridged_invalid_cfobject)
3928  << castExpr->getType() << castType;
3929  S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
3930  if (Target)
3931  S.Diag(Target->getBeginLoc(), diag::note_declared_at);
3932  return true;
3933  }
3934  return false;
3935  }
3936  T = TDNDecl->getUnderlyingType();
3937  }
3938  return true;
3939 }
3940 
3942  if (!getLangOpts().ObjC)
3943  return;
3944  // warn in presence of __bridge casting to or from a toll free bridge cast.
3947  if (castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) {
3948  bool HasObjCBridgeAttr;
3949  bool ObjCBridgeAttrWillNotWarn =
3950  CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3951  false);
3952  if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr)
3953  return;
3954  bool HasObjCBridgeMutableAttr;
3955  bool ObjCBridgeMutableAttrWillNotWarn =
3956  CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3957  HasObjCBridgeMutableAttr, false);
3958  if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr)
3959  return;
3960 
3961  if (HasObjCBridgeAttr)
3962  CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3963  true);
3964  else if (HasObjCBridgeMutableAttr)
3965  CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3966  HasObjCBridgeMutableAttr, true);
3967  }
3968  else if (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable) {
3969  bool HasObjCBridgeAttr;
3970  bool ObjCBridgeAttrWillNotWarn =
3971  CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3972  false);
3973  if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr)
3974  return;
3975  bool HasObjCBridgeMutableAttr;
3976  bool ObjCBridgeMutableAttrWillNotWarn =
3977  CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3978  HasObjCBridgeMutableAttr, false);
3979  if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr)
3980  return;
3981 
3982  if (HasObjCBridgeAttr)
3983  CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3984  true);
3985  else if (HasObjCBridgeMutableAttr)
3986  CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3987  HasObjCBridgeMutableAttr, true);
3988  }
3989 }
3990 
3992  QualType SrcType = castExpr->getType();
3993  if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(castExpr)) {
3994  if (PRE->isExplicitProperty()) {
3995  if (ObjCPropertyDecl *PDecl = PRE->getExplicitProperty())
3996  SrcType = PDecl->getType();
3997  }
3998  else if (PRE->isImplicitProperty()) {
3999  if (ObjCMethodDecl *Getter = PRE->getImplicitPropertyGetter())
4000  SrcType = Getter->getReturnType();
4001  }
4002  }
4003 
4005  ARCConversionTypeClass castExprACTC = classifyTypeForARCConversion(castType);
4006  if (srcExprACTC != ACTC_retainable || castExprACTC != ACTC_coreFoundation)
4007  return;
4008  CheckObjCBridgeRelatedConversions(castExpr->getBeginLoc(), castType, SrcType,
4009  castExpr);
4010 }
4011 
4013  CastKind &Kind) {
4014  if (!getLangOpts().ObjC)
4015  return false;
4016  ARCConversionTypeClass exprACTC =
4019  if ((castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) ||
4020  (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable)) {
4021  CheckTollFreeBridgeCast(castType, castExpr);
4022  Kind = (castACTC == ACTC_coreFoundation) ? CK_BitCast
4023  : CK_CPointerToObjCPointerCast;
4024  return true;
4025  }
4026  return false;
4027 }
4028 
4030  QualType DestType, QualType SrcType,
4031  ObjCInterfaceDecl *&RelatedClass,
4032  ObjCMethodDecl *&ClassMethod,
4033  ObjCMethodDecl *&InstanceMethod,
4034  TypedefNameDecl *&TDNDecl,
4035  bool CfToNs, bool Diagnose) {
4036  QualType T = CfToNs ? SrcType : DestType;
4037  ObjCBridgeRelatedAttr *ObjCBAttr = ObjCBridgeRelatedAttrFromType(T, TDNDecl);
4038  if (!ObjCBAttr)
4039  return false;
4040 
4041  IdentifierInfo *RCId = ObjCBAttr->getRelatedClass();
4042  IdentifierInfo *CMId = ObjCBAttr->getClassMethod();
4043  IdentifierInfo *IMId = ObjCBAttr->getInstanceMethod();
4044  if (!RCId)
4045  return false;
4046  NamedDecl *Target = nullptr;
4047  // Check for an existing type with this name.
4048  LookupResult R(*this, DeclarationName(RCId), SourceLocation(),
4050  if (!LookupName(R, TUScope)) {
4051  if (Diagnose) {
4052  Diag(Loc, diag::err_objc_bridged_related_invalid_class) << RCId
4053  << SrcType << DestType;
4054  Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4055  }
4056  return false;
4057  }
4058  Target = R.getFoundDecl();
4059  if (Target && isa<ObjCInterfaceDecl>(Target))
4060  RelatedClass = cast<ObjCInterfaceDecl>(Target);
4061  else {
4062  if (Diagnose) {
4063  Diag(Loc, diag::err_objc_bridged_related_invalid_class_name) << RCId
4064  << SrcType << DestType;
4065  Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4066  if (Target)
4067  Diag(Target->getBeginLoc(), diag::note_declared_at);
4068  }
4069  return false;
4070  }
4071 
4072  // Check for an existing class method with the given selector name.
4073  if (CfToNs && CMId) {
4074  Selector Sel = Context.Selectors.getUnarySelector(CMId);
4075  ClassMethod = RelatedClass->lookupMethod(Sel, false);
4076  if (!ClassMethod) {
4077  if (Diagnose) {
4078  Diag(Loc, diag::err_objc_bridged_related_known_method)
4079  << SrcType << DestType << Sel << false;
4080  Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4081  }
4082  return false;
4083  }
4084  }
4085 
4086  // Check for an existing instance method with the given selector name.
4087  if (!CfToNs && IMId) {
4088  Selector Sel = Context.Selectors.getNullarySelector(IMId);
4089  InstanceMethod = RelatedClass->lookupMethod(Sel, true);
4090  if (!InstanceMethod) {
4091  if (Diagnose) {
4092  Diag(Loc, diag::err_objc_bridged_related_known_method)
4093  << SrcType << DestType << Sel << true;
4094  Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4095  }
4096  return false;
4097  }
4098  }
4099  return true;
4100 }
4101 
4102 bool
4104  QualType DestType, QualType SrcType,
4105  Expr *&SrcExpr, bool Diagnose) {
4107  ARCConversionTypeClass lhsExprACTC = classifyTypeForARCConversion(DestType);
4108  bool CfToNs = (rhsExprACTC == ACTC_coreFoundation && lhsExprACTC == ACTC_retainable);
4109  bool NsToCf = (rhsExprACTC == ACTC_retainable && lhsExprACTC == ACTC_coreFoundation);
4110  if (!CfToNs && !NsToCf)
4111  return false;
4112 
4113  ObjCInterfaceDecl *RelatedClass;
4114  ObjCMethodDecl *ClassMethod = nullptr;
4115  ObjCMethodDecl *InstanceMethod = nullptr;
4116  TypedefNameDecl *TDNDecl = nullptr;
4117  if (!checkObjCBridgeRelatedComponents(Loc, DestType, SrcType, RelatedClass,
4118  ClassMethod, InstanceMethod, TDNDecl,
4119  CfToNs, Diagnose))
4120  return false;
4121 
4122  if (CfToNs) {
4123  // Implicit conversion from CF to ObjC object is needed.
4124  if (ClassMethod) {
4125  if (Diagnose) {
4126  std::string ExpressionString = "[";
4127  ExpressionString += RelatedClass->getNameAsString();
4128  ExpressionString += " ";
4129  ExpressionString += ClassMethod->getSelector().getAsString();
4130  SourceLocation SrcExprEndLoc =
4131  getLocForEndOfToken(SrcExpr->getEndLoc());
4132  // Provide a fixit: [RelatedClass ClassMethod SrcExpr]
4133  Diag(Loc, diag::err_objc_bridged_related_known_method)
4134  << SrcType << DestType << ClassMethod->getSelector() << false
4136  ExpressionString)
4137  << FixItHint::CreateInsertion(SrcExprEndLoc, "]");
4138  Diag(RelatedClass->getBeginLoc(), diag::note_declared_at);
4139  Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4140 
4141  QualType receiverType = Context.getObjCInterfaceType(RelatedClass);
4142  // Argument.
4143  Expr *args[] = { SrcExpr };
4144  ExprResult msg = BuildClassMessageImplicit(receiverType, false,
4145  ClassMethod->getLocation(),
4146  ClassMethod->getSelector(), ClassMethod,
4147  MultiExprArg(args, 1));
4148  SrcExpr = msg.get();
4149  }
4150  return true;
4151  }
4152  }
4153  else {
4154  // Implicit conversion from ObjC type to CF object is needed.
4155  if (InstanceMethod) {
4156  if (Diagnose) {
4157  std::string ExpressionString;
4158  SourceLocation SrcExprEndLoc =
4159  getLocForEndOfToken(SrcExpr->getEndLoc());
4160  if (InstanceMethod->isPropertyAccessor())
4161  if (const ObjCPropertyDecl *PDecl =
4162  InstanceMethod->findPropertyDecl()) {
4163  // fixit: ObjectExpr.propertyname when it is aproperty accessor.
4164  ExpressionString = ".";
4165  ExpressionString += PDecl->getNameAsString();
4166  Diag(Loc, diag::err_objc_bridged_related_known_method)
4167  << SrcType << DestType << InstanceMethod->getSelector() << true
4168  << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString);
4169  }
4170  if (ExpressionString.empty()) {
4171  // Provide a fixit: [ObjectExpr InstanceMethod]
4172  ExpressionString = " ";
4173  ExpressionString += InstanceMethod->getSelector().getAsString();
4174  ExpressionString += "]";
4175 
4176  Diag(Loc, diag::err_objc_bridged_related_known_method)
4177  << SrcType << DestType << InstanceMethod->getSelector() << true
4178  << FixItHint::CreateInsertion(SrcExpr->getBeginLoc(), "[")
4179  << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString);
4180  }
4181  Diag(RelatedClass->getBeginLoc(), diag::note_declared_at);
4182  Diag(TDNDecl->getBeginLoc(), diag::note_declared_at);
4183 
4184  ExprResult msg =
4185  BuildInstanceMessageImplicit(SrcExpr, SrcType,
4186  InstanceMethod->getLocation(),
4187  InstanceMethod->getSelector(),
4188  InstanceMethod, None);
4189  SrcExpr = msg.get();
4190  }
4191  return true;
4192  }
4193  }
4194  return false;
4195 }
4196 
4200  bool Diagnose, bool DiagnoseCFAudited,
4201  BinaryOperatorKind Opc) {
4202  QualType castExprType = castExpr->getType();
4203 
4204  // For the purposes of the classification, we assume reference types
4205  // will bind to temporaries.
4206  QualType effCastType = castType;
4207  if (const ReferenceType *ref = castType->getAs<ReferenceType>())
4208  effCastType = ref->getPointeeType();
4209 
4210  ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExprType);
4211  ARCConversionTypeClass castACTC = classifyTypeForARCConversion(effCastType);
4212  if (exprACTC == castACTC) {
4213  // Check for viability and report error if casting an rvalue to a
4214  // life-time qualifier.
4215  if (castACTC == ACTC_retainable &&
4216  (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) &&
4217  castType != castExprType) {
4218  const Type *DT = castType.getTypePtr();
4219  QualType QDT = castType;
4220  // We desugar some types but not others. We ignore those
4221  // that cannot happen in a cast; i.e. auto, and those which
4222  // should not be de-sugared; i.e typedef.
4223  if (const ParenType *PT = dyn_cast<ParenType>(DT))
4224  QDT = PT->desugar();
4225  else if (const TypeOfType *TP = dyn_cast<TypeOfType>(DT))
4226  QDT = TP->desugar();
4227  else if (const AttributedType *AT = dyn_cast<AttributedType>(DT))
4228  QDT = AT->desugar();
4229  if (QDT != castType &&
4231  if (Diagnose) {
4232  SourceLocation loc = (castRange.isValid() ? castRange.getBegin()
4233  : castExpr->getExprLoc());
4234  Diag(loc, diag::err_arc_nolifetime_behavior);
4235  }
4236  return ACR_error;
4237  }
4238  }
4239  return ACR_okay;
4240  }
4241 
4242  // The life-time qualifier cast check above is all we need for ObjCWeak.
4243  // ObjCAutoRefCount has more restrictions on what is legal.
4244  if (!getLangOpts().ObjCAutoRefCount)
4245  return ACR_okay;
4246 
4247  if (isAnyCLike(exprACTC) && isAnyCLike(castACTC)) return ACR_okay;
4248 
4249  // Allow all of these types to be cast to integer types (but not
4250  // vice-versa).
4251  if (castACTC == ACTC_none && castType->isIntegralType(Context))
4252  return ACR_okay;
4253 
4254  // Allow casts between pointers to lifetime types (e.g., __strong id*)
4255  // and pointers to void (e.g., cv void *). Casting from void* to lifetime*
4256  // must be explicit.
4257  if (exprACTC == ACTC_indirectRetainable && castACTC == ACTC_voidPtr)
4258  return ACR_okay;
4259  if (castACTC == ACTC_indirectRetainable && exprACTC == ACTC_voidPtr &&
4260  isCast(CCK))
4261  return ACR_okay;
4262 
4263  switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) {
4264  // For invalid casts, fall through.
4265  case ACC_invalid:
4266  break;
4267 
4268  // Do nothing for both bottom and +0.
4269  case ACC_bottom:
4270  case ACC_plusZero:
4271  return ACR_okay;
4272 
4273  // If the result is +1, consume it here.
4274  case ACC_plusOne:
4275  castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(),
4276  CK_ARCConsumeObject, castExpr,
4277  nullptr, VK_RValue);
4278  Cleanup.setExprNeedsCleanups(true);
4279  return ACR_okay;
4280  }
4281 
4282  // If this is a non-implicit cast from id or block type to a
4283  // CoreFoundation type, delay complaining in case the cast is used
4284  // in an acceptable context.
4285  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) && isCast(CCK))
4286  return ACR_unbridged;
4287 
4288  // Issue a diagnostic about a missing @-sign when implicit casting a cstring
4289  // to 'NSString *', instead of falling through to report a "bridge cast"
4290  // diagnostic.
4291  if (castACTC == ACTC_retainable && exprACTC == ACTC_none &&
4292  ConversionToObjCStringLiteralCheck(castType, castExpr, Diagnose))
4293  return ACR_error;
4294 
4295  // Do not issue "bridge cast" diagnostic when implicit casting
4296  // a retainable object to a CF type parameter belonging to an audited
4297  // CF API function. Let caller issue a normal type mismatched diagnostic
4298  // instead.
4299  if ((!DiagnoseCFAudited || exprACTC != ACTC_retainable ||
4300  castACTC != ACTC_coreFoundation) &&
4301  !(exprACTC == ACTC_voidPtr && castACTC == ACTC_retainable &&
4302  (Opc == BO_NE || Opc == BO_EQ))) {
4303  if (Diagnose)
4304  diagnoseObjCARCConversion(*this, castRange, castType, castACTC, castExpr,
4305  castExpr, exprACTC, CCK);
4306  return ACR_error;
4307  }
4308  return ACR_okay;
4309 }
4310 
4311 /// Given that we saw an expression with the ARCUnbridgedCastTy
4312 /// placeholder type, complain bitterly.
4314  // We expect the spurious ImplicitCastExpr to already have been stripped.
4315  assert(!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
4316  CastExpr *realCast = cast<CastExpr>(e->IgnoreParens());
4317 
4318  SourceRange castRange;
4319  QualType castType;
4321 
4322  if (CStyleCastExpr *cast = dyn_cast<CStyleCastExpr>(realCast)) {
4323  castRange = SourceRange(cast->getLParenLoc(), cast->getRParenLoc());
4324  castType = cast->getTypeAsWritten();
4325  CCK = CCK_CStyleCast;
4326  } else if (ExplicitCastExpr *cast = dyn_cast<ExplicitCastExpr>(realCast)) {
4327  castRange = cast->getTypeInfoAsWritten()->getTypeLoc().getSourceRange();
4328  castType = cast->getTypeAsWritten();
4329  CCK = CCK_OtherCast;
4330  } else {
4331  llvm_unreachable("Unexpected ImplicitCastExpr");
4332  }
4333 
4334  ARCConversionTypeClass castACTC =
4336 
4337  Expr *castExpr = realCast->getSubExpr();
4338  assert(classifyTypeForARCConversion(castExpr->getType()) == ACTC_retainable);
4339 
4340  diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
4341  castExpr, realCast, ACTC_retainable, CCK);
4342 }
4343 
4344 /// stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast
4345 /// type, remove the placeholder cast.
4347  assert(e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
4348 
4349  if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) {
4350  Expr *sub = stripARCUnbridgedCast(pe->getSubExpr());
4351  return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub);
4352  } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) {
4353  assert(uo->getOpcode() == UO_Extension);
4354  Expr *sub = stripARCUnbridgedCast(uo->getSubExpr());
4355  return new (Context)
4356  UnaryOperator(sub, UO_Extension, sub->getType(), sub->getValueKind(),
4357  sub->getObjectKind(), uo->getOperatorLoc(), false);
4358  } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
4359  assert(!gse->isResultDependent());
4360 
4361  unsigned n = gse->getNumAssocs();
4362  SmallVector<Expr *, 4> subExprs;
4364  subExprs.reserve(n);
4365  subTypes.reserve(n);
4366  for (const GenericSelectionExpr::Association &assoc : gse->associations()) {
4367  subTypes.push_back(assoc.getTypeSourceInfo());
4368  Expr *sub = assoc.getAssociationExpr();
4369  if (assoc.isSelected())
4370  sub = stripARCUnbridgedCast(sub);
4371  subExprs.push_back(sub);
4372  }
4373 
4375  Context, gse->getGenericLoc(), gse->getControllingExpr(), subTypes,
4376  subExprs, gse->getDefaultLoc(), gse->getRParenLoc(),
4377  gse->containsUnexpandedParameterPack(), gse->getResultIndex());
4378  } else {
4379  assert(isa<ImplicitCastExpr>(e) && "bad form of unbridged cast!");
4380  return cast<ImplicitCastExpr>(e)->getSubExpr();
4381  }
4382 }
4383 
4385  QualType exprType) {
4386  QualType canCastType =
4387  Context.getCanonicalType(castType).getUnqualifiedType();
4388  QualType canExprType =
4389  Context.getCanonicalType(exprType).getUnqualifiedType();
4390  if (isa<ObjCObjectPointerType>(canCastType) &&
4391  castType.getObjCLifetime() == Qualifiers::OCL_Weak &&
4392  canExprType->isObjCObjectPointerType()) {
4393  if (const ObjCObjectPointerType *ObjT =
4394  canExprType->getAs<ObjCObjectPointerType>())
4395  if (const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl())
4396  return !ObjI->isArcWeakrefUnavailable();
4397  }
4398  return true;
4399 }
4400 
4401 /// Look for an ObjCReclaimReturnedObject cast and destroy it.
4403  Expr *curExpr = e, *prevExpr = nullptr;
4404 
4405  // Walk down the expression until we hit an implicit cast of kind
4406  // ARCReclaimReturnedObject or an Expr that is neither a Paren nor a Cast.
4407  while (true) {
4408  if (auto *pe = dyn_cast<ParenExpr>(curExpr)) {
4409  prevExpr = curExpr;
4410  curExpr = pe->getSubExpr();
4411  continue;
4412  }
4413 
4414  if (auto *ce = dyn_cast<CastExpr>(curExpr)) {
4415  if (auto *ice = dyn_cast<ImplicitCastExpr>(ce))
4416  if (ice->getCastKind() == CK_ARCReclaimReturnedObject) {
4417  if (!prevExpr)
4418  return ice->getSubExpr();
4419  if (auto *pe = dyn_cast<ParenExpr>(prevExpr))
4420  pe->setSubExpr(ice->getSubExpr());
4421  else
4422  cast<CastExpr>(prevExpr)->setSubExpr(ice->getSubExpr());
4423  return e;
4424  }
4425 
4426  prevExpr = curExpr;
4427  curExpr = ce->getSubExpr();
4428  continue;
4429  }
4430 
4431  // Break out of the loop if curExpr is neither a Paren nor a Cast.
4432  break;
4433  }
4434 
4435  return e;
4436 }
4437 
4440  SourceLocation BridgeKeywordLoc,
4441  TypeSourceInfo *TSInfo,
4442  Expr *SubExpr) {
4443  ExprResult SubResult = UsualUnaryConversions(SubExpr);
4444  if (SubResult.isInvalid()) return ExprError();
4445  SubExpr = SubResult.get();
4446 
4447  QualType T = TSInfo->getType();
4448  QualType FromType = SubExpr->getType();
4449 
4450  CastKind CK;
4451 
4452  bool MustConsume = false;
4453  if (T->isDependentType() || SubExpr->isTypeDependent()) {
4454  // Okay: we'll build a dependent expression type.
4455  CK = CK_Dependent;
4456  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {
4457  // Casting CF -> id
4458  CK = (T->isBlockPointerType() ? CK_AnyPointerToBlockPointerCast
4459  : CK_CPointerToObjCPointerCast);
4460  switch (Kind) {
4461  case OBC_Bridge:
4462  break;
4463 
4464  case OBC_BridgeRetained: {
4465  bool br = isKnownName("CFBridgingRelease");
4466  Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
4467  << 2
4468  << FromType
4469  << (T->isBlockPointerType()? 1 : 0)
4470  << T
4471  << SubExpr->getSourceRange()
4472  << Kind;
4473  Diag(BridgeKeywordLoc, diag::note_arc_bridge)
4474  << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge");
4475  Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer)
4476  << FromType << br
4477  << FixItHint::CreateReplacement(BridgeKeywordLoc,
4478  br ? "CFBridgingRelease "
4479  : "__bridge_transfer ");
4480 
4481  Kind = OBC_Bridge;
4482  break;
4483  }
4484 
4485  case OBC_BridgeTransfer:
4486  // We must consume the Objective-C object produced by the cast.
4487  MustConsume = true;
4488  break;
4489  }
4490  } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {
4491  // Okay: id -> CF
4492  CK = CK_BitCast;
4493  switch (Kind) {
4494  case OBC_Bridge:
4495  // Reclaiming a value that's going to be __bridge-casted to CF
4496  // is very dangerous, so we don't do it.
4497  SubExpr = maybeUndoReclaimObject(SubExpr);
4498  break;
4499 
4500  case OBC_BridgeRetained:
4501  // Produce the object before casting it.
4502  SubExpr = ImplicitCastExpr::Create(Context, FromType,
4503  CK_ARCProduceObject,
4504  SubExpr, nullptr, VK_RValue);
4505  break;
4506 
4507  case OBC_BridgeTransfer: {
4508  bool br = isKnownName("CFBridgingRetain");
4509  Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
4510  << (FromType->isBlockPointerType()? 1 : 0)
4511  << FromType
4512  << 2
4513  << T
4514  << SubExpr->getSourceRange()
4515  << Kind;
4516 
4517  Diag(BridgeKeywordLoc, diag::note_arc_bridge)
4518  << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge ");
4519  Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained)
4520  << T << br
4521  << FixItHint::CreateReplacement(BridgeKeywordLoc,
4522  br ? "CFBridgingRetain " : "__bridge_retained");
4523 
4524  Kind = OBC_Bridge;
4525  break;
4526  }
4527  }
4528  } else {
4529  Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible)
4530  << FromType << T << Kind
4531  << SubExpr->getSourceRange()
4532  << TSInfo->getTypeLoc().getSourceRange();
4533  return ExprError();
4534  }
4535 
4536  Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK,
4537  BridgeKeywordLoc,
4538  TSInfo, SubExpr);
4539 
4540  if (MustConsume) {
4541  Cleanup.setExprNeedsCleanups(true);
4542  Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result,
4543  nullptr, VK_RValue);
4544  }
4545 
4546  return Result;
4547 }
4548 
4550  SourceLocation LParenLoc,
4552  SourceLocation BridgeKeywordLoc,
4553  ParsedType Type,
4554  SourceLocation RParenLoc,
4555  Expr *SubExpr) {
4556  TypeSourceInfo *TSInfo = nullptr;
4557  QualType T = GetTypeFromParser(Type, &TSInfo);
4558  if (Kind == OBC_Bridge)
4559  CheckTollFreeBridgeCast(T, SubExpr);
4560  if (!TSInfo)
4561  TSInfo = Context.getTrivialTypeSourceInfo(T, LParenLoc);
4562  return BuildObjCBridgedCast(LParenLoc, Kind, BridgeKeywordLoc, TSInfo,
4563  SubExpr);
4564 }
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:1552
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:1737
Stmt * body_back()
Definition: Stmt.h:1303
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:1848
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:2549
QualType getPointeeType() const
Definition: Type.h:2562
CanQualType VoidPtrTy
Definition: ASTContext.h:1043
A (possibly-)qualified type.
Definition: Type.h:639
bool isBlockPointerType() const
Definition: Type.h:6316
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:1360
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:9566
void* might be a normal C type, or it might a CF type.
void AddFixItHint(const FixItHint &Hint) const
Definition: Diagnostic.h:1170
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:939
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:3155
CompoundStmt * getSubStmt()
Definition: Expr.h:3851
CanQualType Char32Ty
Definition: ASTContext.h:1023
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:8337
Stmt - This represents one statement.
Definition: Stmt.h:65
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:285
static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK)
bool isObjCClassOrClassKindOfType() const
Whether the type is Objective-C &#39;Class&#39; or a __kindof type of an Class type, e.g., __kindof Class <NSCopying>.
Definition: Type.cpp: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:474
static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr, bool &HadTheAttribute, bool warn)
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:808
bool isObjCARCBridgableType() const
Determine whether the given type T is a "bridgable" Objective-C type, which is either an Objective-C ...
Definition: Type.cpp:4029
bool isRecordType() const
Definition: Type.h:6381
bool isAscii() const
Definition: Expr.h:1718
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
const ObjCObjectType * getAsObjCInterfaceType() const
Definition: Type.cpp:1604
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1363
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:413
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:6397
StringRef P
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:878
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1882
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:6257
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:1414
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:2824
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:104
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:845
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1612
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Definition: Expr.h:397
QualType withConst() const
Definition: Type.h:811
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:4034
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:2859
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:96
An Objective-C array/dictionary subscripting which reads an object or writes at the subscripted array...
Definition: Specifiers.h:140
Represents a variable declaration or definition.
Definition: Decl.h:812
QualType getReturnType() const
Definition: Decl.h:2301
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:6768
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
bool isInvalidDecl() const
Definition: DeclBase.h:545
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:1214
static StringRef bytes(const std::vector< T, Allocator > &v)
Definition: ASTWriter.cpp:119
Represents a parameter to a function.
Definition: Decl.h:1549
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:3788
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:3592
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:910
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:3659
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:5550
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:9562
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:6434
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:1584
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:16951
LookupResultKind getResultKind() const
Definition: Lookup.h:321
static ObjCBridgeRelatedAttr * ObjCBridgeRelatedAttrFromType(QualType T, TypedefNameDecl *&TDNDecl)
Expr * getSubExpr()
Definition: Expr.h:3093
bool isObjCQualifiedClassType() const
Definition: Type.h:6428
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:565
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:109
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:1244
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:6817
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:1625
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:2900
const ObjCObjectPointerType * getAsObjCQualifiedClassType() const
Definition: Type.cpp:1594
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Definition: Sema.h:1210
Represents a declaration of a type.
Definition: Decl.h:2873
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3318
CanQualType PseudoObjectTy
Definition: ASTContext.h:1046
tokloc_iterator tokloc_end() const
Definition: Expr.h:1770
A conversion for an operand of a builtin overloaded operator.
Definition: Sema.h:9568
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:9558
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2728
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:6084
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:3041
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2063
AssociationTy< false > Association
Definition: Expr.h:5203
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:913
const LangOptions & getLangOpts() const
Definition: Sema.h:1286
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:169
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:3011
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5785
SourceLocation OrigLoc
Definition: Commit.h:40
QualType getObjCProtoType() const
Retrieve the type of the Objective-C Protocol class.
Definition: ASTContext.h:1894
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:2707
bool isObjCSelfExpr() const
Check if this expression is the ObjC &#39;self&#39; implicit parameter.
Definition: Expr.cpp:3572
bool isKnownName(StringRef name)
ObjCMethodDecl * getCategoryClassMethod(Selector Sel) const
Definition: DeclObjC.cpp:1689
static bool isAnyRetainable(ARCConversionTypeClass ACTC)
bool hasAttr() const
Definition: DeclBase.h:534
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3616
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
RecordDecl * getMostRecentDecl()
Definition: Decl.h:3639
StringRef getString() const
Definition: Expr.h:1682
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:1044
A functional-style cast.
Definition: Sema.h:9564
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:5450
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:1847
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:135
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:982
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:106
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:4493
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6831
static bool isAnyCLike(ARCConversionTypeClass ACTC)
bool isObjCRetainableType() const
Definition: Type.cpp:4000
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:6440
DeclContext * getDeclContext()
Definition: DeclBase.h:430
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:16834
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
Definition: Expr.h:2570
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:919
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:723
bool isInvalid() const
QualType getType() const
Definition: Expr.h:130
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:3912
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
Definition: Decl.cpp:2154
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:1934
bool isInstanceMethod() const
Definition: DeclObjC.h:421
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2861
bool rewriteObjCRedundantCallWithLiteral(const ObjCMessageExpr *Msg, const NSAPI &NS, Commit &commit)
unsigned getNumArgs() const
ValueDecl * getDecl()
Definition: Expr.h:1147
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:1395
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:3255
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:704
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:413
const SourceManager & SM
Definition: Format.cpp:1568
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:6143
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:1564
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:9994
SelectorTable & Selectors
Definition: ASTContext.h:566
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:5511
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:3433
Encodes a location in the source.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5763
Sugar for parentheses used when specifying types.
Definition: Type.h:2519
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:4408
Expr * getSubExpr() const
Definition: Expr.h:1964
Represents typeof(type), a GCC extension.
Definition: Type.h:4231
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5750
CastKind getCastKind() const
Definition: Expr.h:3087
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:389
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C &#39;SEL&#39; type.
Definition: ASTContext.h:1858
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
Definition: ScopeInfo.h:143
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1781
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2426
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:9571
Specifies that a value-dependent expression should be considered to never be a null pointer constant...
Definition: Expr.h:727
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:1774
ExprResult ActOnClassPropertyRefExpr(IdentifierInfo &receiverName, IdentifierInfo &propertyName, SourceLocation receiverNameLoc, SourceLocation propertyNameLoc)
bool isObjCObjectPointerType() const
Definition: Type.h:6405
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:138
static QualType getBaseMessageSendResultType(Sema &S, QualType ReceiverType, ObjCMethodDecl *Method, bool isClassMessage, bool isSuperMessage)
Determine the result type of a message send based on the receiver type, method, and the kind of messa...
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1356
bool isVectorType() const
Definition: Type.h:6393
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3835
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:2306
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:214
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
Definition: ASTContext.h:1729
Represents a C11 generic selection.
Definition: Expr.h:5044
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:2915
Expr * getResultExpr()
Return the result-bearing expression, or null if there is none.
Definition: Expr.h:5566
CanQualType CharTy
Definition: ASTContext.h:1017
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:9183
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:1047
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2548
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
tokloc_iterator tokloc_begin() const
Definition: Expr.h:1766