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