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
14 #include "clang/Sema/SemaInternal.h"
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"
20 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
21 #include "clang/Edit/Commit.h"
22 #include "clang/Edit/Rewriters.h"
23 #include "clang/Lex/Preprocessor.h"
24 #include "clang/Sema/Initialization.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
ParseObjCStringLiteral(SourceLocation * AtLocs,Expr ** strings,unsigned NumStrings)34 ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
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;
49 SmallVector<SourceLocation, 8> StrLocs;
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.
70 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
71 assert(CAT && "String literal not of constant array type!");
72 QualType StrTy = Context.getConstantArrayType(
73 CAT->getElementType(), llvm::APInt(32, StrBuf.size() + 1),
74 CAT->getSizeModifier(), CAT->getIndexTypeCVRQualifiers());
75 S = StringLiteral::Create(Context, StrBuf, StringLiteral::Ascii,
76 /*Pascal=*/false, StrTy, &StrLocs[0],
77 StrLocs.size());
78 }
79
80 return BuildObjCStringLiteral(AtLocs[0], S);
81 }
82
BuildObjCStringLiteral(SourceLocation AtLoc,StringLiteral * S)83 ExprResult Sema::BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S){
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).
92 QualType Ty = Context.getObjCConstantStringInterface();
93 if (!Ty.isNull()) {
94 Ty = Context.getObjCObjectPointerType(Ty);
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)) {
107 Context.setObjCConstantStringInterface(StrIF);
108 Ty = Context.getObjCConstantStringInterface();
109 Ty = Context.getObjCObjectPointerType(Ty);
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)) {
122 Context.setObjCConstantStringInterface(StrIF);
123 Ty = Context.getObjCConstantStringInterface();
124 Ty = Context.getObjCObjectPointerType(Ty);
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.
130 Ty = Context.getObjCNSStringType();
131 if (Ty.isNull()) {
132 ObjCInterfaceDecl *NSStringIDecl =
133 ObjCInterfaceDecl::Create (Context,
134 Context.getTranslationUnitDecl(),
135 SourceLocation(), NSIdent,
136 nullptr, SourceLocation());
137 Ty = Context.getObjCInterfaceType(NSStringIDecl);
138 Context.setObjCNSStringType(Ty);
139 }
140 Ty = Context.getObjCObjectPointerType(Ty);
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.
validateBoxingMethod(Sema & S,SourceLocation Loc,const ObjCInterfaceDecl * Class,Selector Sel,const ObjCMethodDecl * Method)149 static bool validateBoxingMethod(Sema &S, SourceLocation Loc,
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.
getNSNumberFactoryMethod(Sema & S,SourceLocation Loc,QualType NumberType,bool isLiteral=false,SourceRange R=SourceRange ())173 static ObjCMethodDecl *getNSNumberFactoryMethod(Sema &S, SourceLocation Loc,
174 QualType NumberType,
175 bool isLiteral = false,
176 SourceRange R = SourceRange()) {
177 Optional<NSAPI::NSNumberLiteralMethodKind> Kind =
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,
203 Loc, Sema::LookupOrdinaryName);
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.
208 S.NSNumberDecl = ObjCInterfaceDecl::Create(CX,
209 CX.getTranslationUnitDecl(),
210 SourceLocation(), NSNumberId,
211 nullptr, SourceLocation());
212 } else {
213 // Otherwise, require a declaration of NSNumber.
214 S.Diag(Loc, diag::err_undeclared_nsnumber);
215 return nullptr;
216 }
217 } else if (!S.NSNumberDecl->hasDefinition()) {
218 S.Diag(Loc, diag::err_undeclared_nsnumber);
219 return nullptr;
220 }
221
222 // generate the pointer to NSNumber type.
223 QualType NSNumberObject = CX.getObjCInterfaceType(S.NSNumberDecl);
224 S.NSNumberPointer = CX.getObjCObjectPointerType(NSNumberObject);
225 }
226
227 // Look for the appropriate method within NSNumber.
228 ObjCMethodDecl *Method = S.NSNumberDecl->lookupClassMethod(Sel);
229 if (!Method && S.getLangOpts().DebuggerObjCLiteral) {
230 // create a stub definition this NSNumber factory method.
231 TypeSourceInfo *ReturnTInfo = nullptr;
232 Method =
233 ObjCMethodDecl::Create(CX, SourceLocation(), SourceLocation(), Sel,
234 S.NSNumberPointer, ReturnTInfo, S.NSNumberDecl,
235 /*isInstance=*/false, /*isVariadic=*/false,
236 /*isPropertyAccessor=*/false,
237 /*isImplicitlyDeclared=*/true,
238 /*isDefined=*/false, ObjCMethodDecl::Required,
239 /*HasRelatedResultType=*/false);
240 ParmVarDecl *value = ParmVarDecl::Create(S.Context, Method,
241 SourceLocation(), SourceLocation(),
242 &CX.Idents.get("value"),
243 NumberType, /*TInfo=*/nullptr,
244 SC_None, nullptr);
245 Method->setMethodParams(S.Context, value, None);
246 }
247
248 if (!validateBoxingMethod(S, Loc, S.NSNumberDecl, Sel, Method))
249 return nullptr;
250
251 // Note: if the parameter type is out-of-line, we'll catch it later in the
252 // implicit conversion.
253
254 S.NSNumberLiteralMethods[*Kind] = Method;
255 return Method;
256 }
257
258 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
259 /// numeric literal expression. Type of the expression will be "NSNumber *".
BuildObjCNumericLiteral(SourceLocation AtLoc,Expr * Number)260 ExprResult Sema::BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number) {
261 // Determine the type of the literal.
262 QualType NumberType = Number->getType();
263 if (CharacterLiteral *Char = dyn_cast<CharacterLiteral>(Number)) {
264 // In C, character literals have type 'int'. That's not the type we want
265 // to use to determine the Objective-c literal kind.
266 switch (Char->getKind()) {
267 case CharacterLiteral::Ascii:
268 NumberType = Context.CharTy;
269 break;
270
271 case CharacterLiteral::Wide:
272 NumberType = Context.getWideCharType();
273 break;
274
275 case CharacterLiteral::UTF16:
276 NumberType = Context.Char16Ty;
277 break;
278
279 case CharacterLiteral::UTF32:
280 NumberType = Context.Char32Ty;
281 break;
282 }
283 }
284
285 // Look for the appropriate method within NSNumber.
286 // Construct the literal.
287 SourceRange NR(Number->getSourceRange());
288 ObjCMethodDecl *Method = getNSNumberFactoryMethod(*this, AtLoc, NumberType,
289 true, NR);
290 if (!Method)
291 return ExprError();
292
293 // Convert the number to the type that the parameter expects.
294 ParmVarDecl *ParamDecl = Method->parameters()[0];
295 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
296 ParamDecl);
297 ExprResult ConvertedNumber = PerformCopyInitialization(Entity,
298 SourceLocation(),
299 Number);
300 if (ConvertedNumber.isInvalid())
301 return ExprError();
302 Number = ConvertedNumber.get();
303
304 // Use the effective source range of the literal, including the leading '@'.
305 return MaybeBindToTemporary(
306 new (Context) ObjCBoxedExpr(Number, NSNumberPointer, Method,
307 SourceRange(AtLoc, NR.getEnd())));
308 }
309
ActOnObjCBoolLiteral(SourceLocation AtLoc,SourceLocation ValueLoc,bool Value)310 ExprResult Sema::ActOnObjCBoolLiteral(SourceLocation AtLoc,
311 SourceLocation ValueLoc,
312 bool Value) {
313 ExprResult Inner;
314 if (getLangOpts().CPlusPlus) {
315 Inner = ActOnCXXBoolLiteral(ValueLoc, Value? tok::kw_true : tok::kw_false);
316 } else {
317 // C doesn't actually have a way to represent literal values of type
318 // _Bool. So, we'll use 0/1 and implicit cast to _Bool.
319 Inner = ActOnIntegerConstant(ValueLoc, Value? 1 : 0);
320 Inner = ImpCastExprToType(Inner.get(), Context.BoolTy,
321 CK_IntegralToBoolean);
322 }
323
324 return BuildObjCNumericLiteral(AtLoc, Inner.get());
325 }
326
327 /// \brief Check that the given expression is a valid element of an Objective-C
328 /// collection literal.
CheckObjCCollectionLiteralElement(Sema & S,Expr * Element,QualType T,bool ArrayLiteral=false)329 static ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element,
330 QualType T,
331 bool ArrayLiteral = false) {
332 // If the expression is type-dependent, there's nothing for us to do.
333 if (Element->isTypeDependent())
334 return Element;
335
336 ExprResult Result = S.CheckPlaceholderExpr(Element);
337 if (Result.isInvalid())
338 return ExprError();
339 Element = Result.get();
340
341 // In C++, check for an implicit conversion to an Objective-C object pointer
342 // type.
343 if (S.getLangOpts().CPlusPlus && Element->getType()->isRecordType()) {
344 InitializedEntity Entity
345 = InitializedEntity::InitializeParameter(S.Context, T,
346 /*Consumed=*/false);
347 InitializationKind Kind
348 = InitializationKind::CreateCopy(Element->getLocStart(),
349 SourceLocation());
350 InitializationSequence Seq(S, Entity, Kind, Element);
351 if (!Seq.Failed())
352 return Seq.Perform(S, Entity, Kind, Element);
353 }
354
355 Expr *OrigElement = Element;
356
357 // Perform lvalue-to-rvalue conversion.
358 Result = S.DefaultLvalueConversion(Element);
359 if (Result.isInvalid())
360 return ExprError();
361 Element = Result.get();
362
363 // Make sure that we have an Objective-C pointer type or block.
364 if (!Element->getType()->isObjCObjectPointerType() &&
365 !Element->getType()->isBlockPointerType()) {
366 bool Recovered = false;
367
368 // If this is potentially an Objective-C numeric literal, add the '@'.
369 if (isa<IntegerLiteral>(OrigElement) ||
370 isa<CharacterLiteral>(OrigElement) ||
371 isa<FloatingLiteral>(OrigElement) ||
372 isa<ObjCBoolLiteralExpr>(OrigElement) ||
373 isa<CXXBoolLiteralExpr>(OrigElement)) {
374 if (S.NSAPIObj->getNSNumberFactoryMethodKind(OrigElement->getType())) {
375 int Which = isa<CharacterLiteral>(OrigElement) ? 1
376 : (isa<CXXBoolLiteralExpr>(OrigElement) ||
377 isa<ObjCBoolLiteralExpr>(OrigElement)) ? 2
378 : 3;
379
380 S.Diag(OrigElement->getLocStart(), diag::err_box_literal_collection)
381 << Which << OrigElement->getSourceRange()
382 << FixItHint::CreateInsertion(OrigElement->getLocStart(), "@");
383
384 Result = S.BuildObjCNumericLiteral(OrigElement->getLocStart(),
385 OrigElement);
386 if (Result.isInvalid())
387 return ExprError();
388
389 Element = Result.get();
390 Recovered = true;
391 }
392 }
393 // If this is potentially an Objective-C string literal, add the '@'.
394 else if (StringLiteral *String = dyn_cast<StringLiteral>(OrigElement)) {
395 if (String->isAscii()) {
396 S.Diag(OrigElement->getLocStart(), diag::err_box_literal_collection)
397 << 0 << OrigElement->getSourceRange()
398 << FixItHint::CreateInsertion(OrigElement->getLocStart(), "@");
399
400 Result = S.BuildObjCStringLiteral(OrigElement->getLocStart(), String);
401 if (Result.isInvalid())
402 return ExprError();
403
404 Element = Result.get();
405 Recovered = true;
406 }
407 }
408
409 if (!Recovered) {
410 S.Diag(Element->getLocStart(), diag::err_invalid_collection_element)
411 << Element->getType();
412 return ExprError();
413 }
414 }
415 if (ArrayLiteral)
416 if (ObjCStringLiteral *getString =
417 dyn_cast<ObjCStringLiteral>(OrigElement)) {
418 if (StringLiteral *SL = getString->getString()) {
419 unsigned numConcat = SL->getNumConcatenated();
420 if (numConcat > 1) {
421 // Only warn if the concatenated string doesn't come from a macro.
422 bool hasMacro = false;
423 for (unsigned i = 0; i < numConcat ; ++i)
424 if (SL->getStrTokenLoc(i).isMacroID()) {
425 hasMacro = true;
426 break;
427 }
428 if (!hasMacro)
429 S.Diag(Element->getLocStart(),
430 diag::warn_concatenated_nsarray_literal)
431 << Element->getType();
432 }
433 }
434 }
435
436 // Make sure that the element has the type that the container factory
437 // function expects.
438 return S.PerformCopyInitialization(
439 InitializedEntity::InitializeParameter(S.Context, T,
440 /*Consumed=*/false),
441 Element->getLocStart(), Element);
442 }
443
BuildObjCBoxedExpr(SourceRange SR,Expr * ValueExpr)444 ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
445 if (ValueExpr->isTypeDependent()) {
446 ObjCBoxedExpr *BoxedExpr =
447 new (Context) ObjCBoxedExpr(ValueExpr, Context.DependentTy, nullptr, SR);
448 return BoxedExpr;
449 }
450 ObjCMethodDecl *BoxingMethod = nullptr;
451 QualType BoxedType;
452 // Convert the expression to an RValue, so we can check for pointer types...
453 ExprResult RValue = DefaultFunctionArrayLvalueConversion(ValueExpr);
454 if (RValue.isInvalid()) {
455 return ExprError();
456 }
457 ValueExpr = RValue.get();
458 QualType ValueType(ValueExpr->getType());
459 if (const PointerType *PT = ValueType->getAs<PointerType>()) {
460 QualType PointeeType = PT->getPointeeType();
461 if (Context.hasSameUnqualifiedType(PointeeType, Context.CharTy)) {
462
463 if (!NSStringDecl) {
464 IdentifierInfo *NSStringId =
465 NSAPIObj->getNSClassId(NSAPI::ClassId_NSString);
466 NamedDecl *Decl = LookupSingleName(TUScope, NSStringId,
467 SR.getBegin(), LookupOrdinaryName);
468 NSStringDecl = dyn_cast_or_null<ObjCInterfaceDecl>(Decl);
469 if (!NSStringDecl) {
470 if (getLangOpts().DebuggerObjCLiteral) {
471 // Support boxed expressions in the debugger w/o NSString declaration.
472 DeclContext *TU = Context.getTranslationUnitDecl();
473 NSStringDecl = ObjCInterfaceDecl::Create(Context, TU,
474 SourceLocation(),
475 NSStringId,
476 nullptr, SourceLocation());
477 } else {
478 Diag(SR.getBegin(), diag::err_undeclared_nsstring);
479 return ExprError();
480 }
481 } else if (!NSStringDecl->hasDefinition()) {
482 Diag(SR.getBegin(), diag::err_undeclared_nsstring);
483 return ExprError();
484 }
485 assert(NSStringDecl && "NSStringDecl should not be NULL");
486 QualType NSStringObject = Context.getObjCInterfaceType(NSStringDecl);
487 NSStringPointer = Context.getObjCObjectPointerType(NSStringObject);
488 }
489
490 if (!StringWithUTF8StringMethod) {
491 IdentifierInfo *II = &Context.Idents.get("stringWithUTF8String");
492 Selector stringWithUTF8String = Context.Selectors.getUnarySelector(II);
493
494 // Look for the appropriate method within NSString.
495 BoxingMethod = NSStringDecl->lookupClassMethod(stringWithUTF8String);
496 if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) {
497 // Debugger needs to work even if NSString hasn't been defined.
498 TypeSourceInfo *ReturnTInfo = nullptr;
499 ObjCMethodDecl *M = ObjCMethodDecl::Create(
500 Context, SourceLocation(), SourceLocation(), stringWithUTF8String,
501 NSStringPointer, ReturnTInfo, NSStringDecl,
502 /*isInstance=*/false, /*isVariadic=*/false,
503 /*isPropertyAccessor=*/false,
504 /*isImplicitlyDeclared=*/true,
505 /*isDefined=*/false, ObjCMethodDecl::Required,
506 /*HasRelatedResultType=*/false);
507 QualType ConstCharType = Context.CharTy.withConst();
508 ParmVarDecl *value =
509 ParmVarDecl::Create(Context, M,
510 SourceLocation(), SourceLocation(),
511 &Context.Idents.get("value"),
512 Context.getPointerType(ConstCharType),
513 /*TInfo=*/nullptr,
514 SC_None, nullptr);
515 M->setMethodParams(Context, value, None);
516 BoxingMethod = M;
517 }
518
519 if (!validateBoxingMethod(*this, SR.getBegin(), NSStringDecl,
520 stringWithUTF8String, BoxingMethod))
521 return ExprError();
522
523 StringWithUTF8StringMethod = BoxingMethod;
524 }
525
526 BoxingMethod = StringWithUTF8StringMethod;
527 BoxedType = NSStringPointer;
528 }
529 } else if (ValueType->isBuiltinType()) {
530 // The other types we support are numeric, char and BOOL/bool. We could also
531 // provide limited support for structure types, such as NSRange, NSRect, and
532 // NSSize. See NSValue (NSValueGeometryExtensions) in <Foundation/NSGeometry.h>
533 // for more details.
534
535 // Check for a top-level character literal.
536 if (const CharacterLiteral *Char =
537 dyn_cast<CharacterLiteral>(ValueExpr->IgnoreParens())) {
538 // In C, character literals have type 'int'. That's not the type we want
539 // to use to determine the Objective-c literal kind.
540 switch (Char->getKind()) {
541 case CharacterLiteral::Ascii:
542 ValueType = Context.CharTy;
543 break;
544
545 case CharacterLiteral::Wide:
546 ValueType = Context.getWideCharType();
547 break;
548
549 case CharacterLiteral::UTF16:
550 ValueType = Context.Char16Ty;
551 break;
552
553 case CharacterLiteral::UTF32:
554 ValueType = Context.Char32Ty;
555 break;
556 }
557 }
558 CheckForIntOverflow(ValueExpr);
559 // FIXME: Do I need to do anything special with BoolTy expressions?
560
561 // Look for the appropriate method within NSNumber.
562 BoxingMethod = getNSNumberFactoryMethod(*this, SR.getBegin(), ValueType);
563 BoxedType = NSNumberPointer;
564
565 } else if (const EnumType *ET = ValueType->getAs<EnumType>()) {
566 if (!ET->getDecl()->isComplete()) {
567 Diag(SR.getBegin(), diag::err_objc_incomplete_boxed_expression_type)
568 << ValueType << ValueExpr->getSourceRange();
569 return ExprError();
570 }
571
572 BoxingMethod = getNSNumberFactoryMethod(*this, SR.getBegin(),
573 ET->getDecl()->getIntegerType());
574 BoxedType = NSNumberPointer;
575 }
576
577 if (!BoxingMethod) {
578 Diag(SR.getBegin(), diag::err_objc_illegal_boxed_expression_type)
579 << ValueType << ValueExpr->getSourceRange();
580 return ExprError();
581 }
582
583 // Convert the expression to the type that the parameter requires.
584 ParmVarDecl *ParamDecl = BoxingMethod->parameters()[0];
585 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
586 ParamDecl);
587 ExprResult ConvertedValueExpr = PerformCopyInitialization(Entity,
588 SourceLocation(),
589 ValueExpr);
590 if (ConvertedValueExpr.isInvalid())
591 return ExprError();
592 ValueExpr = ConvertedValueExpr.get();
593
594 ObjCBoxedExpr *BoxedExpr =
595 new (Context) ObjCBoxedExpr(ValueExpr, BoxedType,
596 BoxingMethod, SR);
597 return MaybeBindToTemporary(BoxedExpr);
598 }
599
600 /// Build an ObjC subscript pseudo-object expression, given that
601 /// that's supported by the runtime.
BuildObjCSubscriptExpression(SourceLocation RB,Expr * BaseExpr,Expr * IndexExpr,ObjCMethodDecl * getterMethod,ObjCMethodDecl * setterMethod)602 ExprResult Sema::BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
603 Expr *IndexExpr,
604 ObjCMethodDecl *getterMethod,
605 ObjCMethodDecl *setterMethod) {
606 assert(!LangOpts.isSubscriptPointerArithmetic());
607
608 // We can't get dependent types here; our callers should have
609 // filtered them out.
610 assert((!BaseExpr->isTypeDependent() && !IndexExpr->isTypeDependent()) &&
611 "base or index cannot have dependent type here");
612
613 // Filter out placeholders in the index. In theory, overloads could
614 // be preserved here, although that might not actually work correctly.
615 ExprResult Result = CheckPlaceholderExpr(IndexExpr);
616 if (Result.isInvalid())
617 return ExprError();
618 IndexExpr = Result.get();
619
620 // Perform lvalue-to-rvalue conversion on the base.
621 Result = DefaultLvalueConversion(BaseExpr);
622 if (Result.isInvalid())
623 return ExprError();
624 BaseExpr = Result.get();
625
626 // Build the pseudo-object expression.
627 return ObjCSubscriptRefExpr::Create(Context, BaseExpr, IndexExpr,
628 Context.PseudoObjectTy, getterMethod,
629 setterMethod, RB);
630 }
631
BuildObjCArrayLiteral(SourceRange SR,MultiExprArg Elements)632 ExprResult Sema::BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements) {
633 // Look up the NSArray class, if we haven't done so already.
634 if (!NSArrayDecl) {
635 NamedDecl *IF = LookupSingleName(TUScope,
636 NSAPIObj->getNSClassId(NSAPI::ClassId_NSArray),
637 SR.getBegin(),
638 LookupOrdinaryName);
639 NSArrayDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
640 if (!NSArrayDecl && getLangOpts().DebuggerObjCLiteral)
641 NSArrayDecl = ObjCInterfaceDecl::Create (Context,
642 Context.getTranslationUnitDecl(),
643 SourceLocation(),
644 NSAPIObj->getNSClassId(NSAPI::ClassId_NSArray),
645 nullptr, SourceLocation());
646
647 if (!NSArrayDecl) {
648 Diag(SR.getBegin(), diag::err_undeclared_nsarray);
649 return ExprError();
650 }
651 }
652
653 // Find the arrayWithObjects:count: method, if we haven't done so already.
654 QualType IdT = Context.getObjCIdType();
655 if (!ArrayWithObjectsMethod) {
656 Selector
657 Sel = NSAPIObj->getNSArraySelector(NSAPI::NSArr_arrayWithObjectsCount);
658 ObjCMethodDecl *Method = NSArrayDecl->lookupClassMethod(Sel);
659 if (!Method && getLangOpts().DebuggerObjCLiteral) {
660 TypeSourceInfo *ReturnTInfo = nullptr;
661 Method = ObjCMethodDecl::Create(
662 Context, SourceLocation(), SourceLocation(), Sel, IdT, ReturnTInfo,
663 Context.getTranslationUnitDecl(), false /*Instance*/,
664 false /*isVariadic*/,
665 /*isPropertyAccessor=*/false,
666 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
667 ObjCMethodDecl::Required, false);
668 SmallVector<ParmVarDecl *, 2> Params;
669 ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
670 SourceLocation(),
671 SourceLocation(),
672 &Context.Idents.get("objects"),
673 Context.getPointerType(IdT),
674 /*TInfo=*/nullptr,
675 SC_None, nullptr);
676 Params.push_back(objects);
677 ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
678 SourceLocation(),
679 SourceLocation(),
680 &Context.Idents.get("cnt"),
681 Context.UnsignedLongTy,
682 /*TInfo=*/nullptr, SC_None,
683 nullptr);
684 Params.push_back(cnt);
685 Method->setMethodParams(Context, Params, None);
686 }
687
688 if (!validateBoxingMethod(*this, SR.getBegin(), NSArrayDecl, Sel, Method))
689 return ExprError();
690
691 // Dig out the type that all elements should be converted to.
692 QualType T = Method->parameters()[0]->getType();
693 const PointerType *PtrT = T->getAs<PointerType>();
694 if (!PtrT ||
695 !Context.hasSameUnqualifiedType(PtrT->getPointeeType(), IdT)) {
696 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
697 << Sel;
698 Diag(Method->parameters()[0]->getLocation(),
699 diag::note_objc_literal_method_param)
700 << 0 << T
701 << Context.getPointerType(IdT.withConst());
702 return ExprError();
703 }
704
705 // Check that the 'count' parameter is integral.
706 if (!Method->parameters()[1]->getType()->isIntegerType()) {
707 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
708 << Sel;
709 Diag(Method->parameters()[1]->getLocation(),
710 diag::note_objc_literal_method_param)
711 << 1
712 << Method->parameters()[1]->getType()
713 << "integral";
714 return ExprError();
715 }
716
717 // We've found a good +arrayWithObjects:count: method. Save it!
718 ArrayWithObjectsMethod = Method;
719 }
720
721 QualType ObjectsType = ArrayWithObjectsMethod->parameters()[0]->getType();
722 QualType RequiredType = ObjectsType->castAs<PointerType>()->getPointeeType();
723
724 // Check that each of the elements provided is valid in a collection literal,
725 // performing conversions as necessary.
726 Expr **ElementsBuffer = Elements.data();
727 for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
728 ExprResult Converted = CheckObjCCollectionLiteralElement(*this,
729 ElementsBuffer[I],
730 RequiredType, true);
731 if (Converted.isInvalid())
732 return ExprError();
733
734 ElementsBuffer[I] = Converted.get();
735 }
736
737 QualType Ty
738 = Context.getObjCObjectPointerType(
739 Context.getObjCInterfaceType(NSArrayDecl));
740
741 return MaybeBindToTemporary(
742 ObjCArrayLiteral::Create(Context, Elements, Ty,
743 ArrayWithObjectsMethod, SR));
744 }
745
BuildObjCDictionaryLiteral(SourceRange SR,ObjCDictionaryElement * Elements,unsigned NumElements)746 ExprResult Sema::BuildObjCDictionaryLiteral(SourceRange SR,
747 ObjCDictionaryElement *Elements,
748 unsigned NumElements) {
749 // Look up the NSDictionary class, if we haven't done so already.
750 if (!NSDictionaryDecl) {
751 NamedDecl *IF = LookupSingleName(TUScope,
752 NSAPIObj->getNSClassId(NSAPI::ClassId_NSDictionary),
753 SR.getBegin(), LookupOrdinaryName);
754 NSDictionaryDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
755 if (!NSDictionaryDecl && getLangOpts().DebuggerObjCLiteral)
756 NSDictionaryDecl = ObjCInterfaceDecl::Create (Context,
757 Context.getTranslationUnitDecl(),
758 SourceLocation(),
759 NSAPIObj->getNSClassId(NSAPI::ClassId_NSDictionary),
760 nullptr, SourceLocation());
761
762 if (!NSDictionaryDecl) {
763 Diag(SR.getBegin(), diag::err_undeclared_nsdictionary);
764 return ExprError();
765 }
766 }
767
768 // Find the dictionaryWithObjects:forKeys:count: method, if we haven't done
769 // so already.
770 QualType IdT = Context.getObjCIdType();
771 if (!DictionaryWithObjectsMethod) {
772 Selector Sel = NSAPIObj->getNSDictionarySelector(
773 NSAPI::NSDict_dictionaryWithObjectsForKeysCount);
774 ObjCMethodDecl *Method = NSDictionaryDecl->lookupClassMethod(Sel);
775 if (!Method && getLangOpts().DebuggerObjCLiteral) {
776 Method = ObjCMethodDecl::Create(Context,
777 SourceLocation(), SourceLocation(), Sel,
778 IdT,
779 nullptr /*TypeSourceInfo */,
780 Context.getTranslationUnitDecl(),
781 false /*Instance*/, false/*isVariadic*/,
782 /*isPropertyAccessor=*/false,
783 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
784 ObjCMethodDecl::Required,
785 false);
786 SmallVector<ParmVarDecl *, 3> Params;
787 ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
788 SourceLocation(),
789 SourceLocation(),
790 &Context.Idents.get("objects"),
791 Context.getPointerType(IdT),
792 /*TInfo=*/nullptr, SC_None,
793 nullptr);
794 Params.push_back(objects);
795 ParmVarDecl *keys = ParmVarDecl::Create(Context, Method,
796 SourceLocation(),
797 SourceLocation(),
798 &Context.Idents.get("keys"),
799 Context.getPointerType(IdT),
800 /*TInfo=*/nullptr, SC_None,
801 nullptr);
802 Params.push_back(keys);
803 ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
804 SourceLocation(),
805 SourceLocation(),
806 &Context.Idents.get("cnt"),
807 Context.UnsignedLongTy,
808 /*TInfo=*/nullptr, SC_None,
809 nullptr);
810 Params.push_back(cnt);
811 Method->setMethodParams(Context, Params, None);
812 }
813
814 if (!validateBoxingMethod(*this, SR.getBegin(), NSDictionaryDecl, Sel,
815 Method))
816 return ExprError();
817
818 // Dig out the type that all values should be converted to.
819 QualType ValueT = Method->parameters()[0]->getType();
820 const PointerType *PtrValue = ValueT->getAs<PointerType>();
821 if (!PtrValue ||
822 !Context.hasSameUnqualifiedType(PtrValue->getPointeeType(), IdT)) {
823 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
824 << Sel;
825 Diag(Method->parameters()[0]->getLocation(),
826 diag::note_objc_literal_method_param)
827 << 0 << ValueT
828 << Context.getPointerType(IdT.withConst());
829 return ExprError();
830 }
831
832 // Dig out the type that all keys should be converted to.
833 QualType KeyT = Method->parameters()[1]->getType();
834 const PointerType *PtrKey = KeyT->getAs<PointerType>();
835 if (!PtrKey ||
836 !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
837 IdT)) {
838 bool err = true;
839 if (PtrKey) {
840 if (QIDNSCopying.isNull()) {
841 // key argument of selector is id<NSCopying>?
842 if (ObjCProtocolDecl *NSCopyingPDecl =
843 LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) {
844 ObjCProtocolDecl *PQ[] = {NSCopyingPDecl};
845 QIDNSCopying =
846 Context.getObjCObjectType(Context.ObjCBuiltinIdTy,
847 (ObjCProtocolDecl**) PQ,1);
848 QIDNSCopying = Context.getObjCObjectPointerType(QIDNSCopying);
849 }
850 }
851 if (!QIDNSCopying.isNull())
852 err = !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
853 QIDNSCopying);
854 }
855
856 if (err) {
857 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
858 << Sel;
859 Diag(Method->parameters()[1]->getLocation(),
860 diag::note_objc_literal_method_param)
861 << 1 << KeyT
862 << Context.getPointerType(IdT.withConst());
863 return ExprError();
864 }
865 }
866
867 // Check that the 'count' parameter is integral.
868 QualType CountType = Method->parameters()[2]->getType();
869 if (!CountType->isIntegerType()) {
870 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
871 << Sel;
872 Diag(Method->parameters()[2]->getLocation(),
873 diag::note_objc_literal_method_param)
874 << 2 << CountType
875 << "integral";
876 return ExprError();
877 }
878
879 // We've found a good +dictionaryWithObjects:keys:count: method; save it!
880 DictionaryWithObjectsMethod = Method;
881 }
882
883 QualType ValuesT = DictionaryWithObjectsMethod->parameters()[0]->getType();
884 QualType ValueT = ValuesT->castAs<PointerType>()->getPointeeType();
885 QualType KeysT = DictionaryWithObjectsMethod->parameters()[1]->getType();
886 QualType KeyT = KeysT->castAs<PointerType>()->getPointeeType();
887
888 // Check that each of the keys and values provided is valid in a collection
889 // literal, performing conversions as necessary.
890 bool HasPackExpansions = false;
891 for (unsigned I = 0, N = NumElements; I != N; ++I) {
892 // Check the key.
893 ExprResult Key = CheckObjCCollectionLiteralElement(*this, Elements[I].Key,
894 KeyT);
895 if (Key.isInvalid())
896 return ExprError();
897
898 // Check the value.
899 ExprResult Value
900 = CheckObjCCollectionLiteralElement(*this, Elements[I].Value, ValueT);
901 if (Value.isInvalid())
902 return ExprError();
903
904 Elements[I].Key = Key.get();
905 Elements[I].Value = Value.get();
906
907 if (Elements[I].EllipsisLoc.isInvalid())
908 continue;
909
910 if (!Elements[I].Key->containsUnexpandedParameterPack() &&
911 !Elements[I].Value->containsUnexpandedParameterPack()) {
912 Diag(Elements[I].EllipsisLoc,
913 diag::err_pack_expansion_without_parameter_packs)
914 << SourceRange(Elements[I].Key->getLocStart(),
915 Elements[I].Value->getLocEnd());
916 return ExprError();
917 }
918
919 HasPackExpansions = true;
920 }
921
922
923 QualType Ty
924 = Context.getObjCObjectPointerType(
925 Context.getObjCInterfaceType(NSDictionaryDecl));
926 return MaybeBindToTemporary(ObjCDictionaryLiteral::Create(
927 Context, makeArrayRef(Elements, NumElements), HasPackExpansions, Ty,
928 DictionaryWithObjectsMethod, SR));
929 }
930
BuildObjCEncodeExpression(SourceLocation AtLoc,TypeSourceInfo * EncodedTypeInfo,SourceLocation RParenLoc)931 ExprResult Sema::BuildObjCEncodeExpression(SourceLocation AtLoc,
932 TypeSourceInfo *EncodedTypeInfo,
933 SourceLocation RParenLoc) {
934 QualType EncodedType = EncodedTypeInfo->getType();
935 QualType StrTy;
936 if (EncodedType->isDependentType())
937 StrTy = Context.DependentTy;
938 else {
939 if (!EncodedType->getAsArrayTypeUnsafe() && //// Incomplete array is handled.
940 !EncodedType->isVoidType()) // void is handled too.
941 if (RequireCompleteType(AtLoc, EncodedType,
942 diag::err_incomplete_type_objc_at_encode,
943 EncodedTypeInfo->getTypeLoc()))
944 return ExprError();
945
946 std::string Str;
947 Context.getObjCEncodingForType(EncodedType, Str);
948
949 // The type of @encode is the same as the type of the corresponding string,
950 // which is an array type.
951 StrTy = Context.CharTy;
952 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
953 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings)
954 StrTy.addConst();
955 StrTy = Context.getConstantArrayType(StrTy, llvm::APInt(32, Str.size()+1),
956 ArrayType::Normal, 0);
957 }
958
959 return new (Context) ObjCEncodeExpr(StrTy, EncodedTypeInfo, AtLoc, RParenLoc);
960 }
961
ParseObjCEncodeExpression(SourceLocation AtLoc,SourceLocation EncodeLoc,SourceLocation LParenLoc,ParsedType ty,SourceLocation RParenLoc)962 ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc,
963 SourceLocation EncodeLoc,
964 SourceLocation LParenLoc,
965 ParsedType ty,
966 SourceLocation RParenLoc) {
967 // FIXME: Preserve type source info ?
968 TypeSourceInfo *TInfo;
969 QualType EncodedType = GetTypeFromParser(ty, &TInfo);
970 if (!TInfo)
971 TInfo = Context.getTrivialTypeSourceInfo(EncodedType,
972 PP.getLocForEndOfToken(LParenLoc));
973
974 return BuildObjCEncodeExpression(AtLoc, TInfo, RParenLoc);
975 }
976
HelperToDiagnoseMismatchedMethodsInGlobalPool(Sema & S,SourceLocation AtLoc,SourceLocation LParenLoc,SourceLocation RParenLoc,ObjCMethodDecl * Method,ObjCMethodList & MethList)977 static bool HelperToDiagnoseMismatchedMethodsInGlobalPool(Sema &S,
978 SourceLocation AtLoc,
979 SourceLocation LParenLoc,
980 SourceLocation RParenLoc,
981 ObjCMethodDecl *Method,
982 ObjCMethodList &MethList) {
983 ObjCMethodList *M = &MethList;
984 bool Warned = false;
985 for (M = M->getNext(); M; M=M->getNext()) {
986 ObjCMethodDecl *MatchingMethodDecl = M->Method;
987 if (MatchingMethodDecl == Method ||
988 isa<ObjCImplDecl>(MatchingMethodDecl->getDeclContext()) ||
989 MatchingMethodDecl->getSelector() != Method->getSelector())
990 continue;
991 if (!S.MatchTwoMethodDeclarations(Method,
992 MatchingMethodDecl, Sema::MMS_loose)) {
993 if (!Warned) {
994 Warned = true;
995 S.Diag(AtLoc, diag::warning_multiple_selectors)
996 << Method->getSelector() << FixItHint::CreateInsertion(LParenLoc, "(")
997 << FixItHint::CreateInsertion(RParenLoc, ")");
998 S.Diag(Method->getLocation(), diag::note_method_declared_at)
999 << Method->getDeclName();
1000 }
1001 S.Diag(MatchingMethodDecl->getLocation(), diag::note_method_declared_at)
1002 << MatchingMethodDecl->getDeclName();
1003 }
1004 }
1005 return Warned;
1006 }
1007
DiagnoseMismatchedSelectors(Sema & S,SourceLocation AtLoc,ObjCMethodDecl * Method,SourceLocation LParenLoc,SourceLocation RParenLoc,bool WarnMultipleSelectors)1008 static void DiagnoseMismatchedSelectors(Sema &S, SourceLocation AtLoc,
1009 ObjCMethodDecl *Method,
1010 SourceLocation LParenLoc,
1011 SourceLocation RParenLoc,
1012 bool WarnMultipleSelectors) {
1013 if (!WarnMultipleSelectors ||
1014 S.Diags.isIgnored(diag::warning_multiple_selectors, SourceLocation()))
1015 return;
1016 bool Warned = false;
1017 for (Sema::GlobalMethodPool::iterator b = S.MethodPool.begin(),
1018 e = S.MethodPool.end(); b != e; b++) {
1019 // first, instance methods
1020 ObjCMethodList &InstMethList = b->second.first;
1021 if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc,
1022 Method, InstMethList))
1023 Warned = true;
1024
1025 // second, class methods
1026 ObjCMethodList &ClsMethList = b->second.second;
1027 if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc,
1028 Method, ClsMethList) || Warned)
1029 return;
1030 }
1031 }
1032
ParseObjCSelectorExpression(Selector Sel,SourceLocation AtLoc,SourceLocation SelLoc,SourceLocation LParenLoc,SourceLocation RParenLoc,bool WarnMultipleSelectors)1033 ExprResult Sema::ParseObjCSelectorExpression(Selector Sel,
1034 SourceLocation AtLoc,
1035 SourceLocation SelLoc,
1036 SourceLocation LParenLoc,
1037 SourceLocation RParenLoc,
1038 bool WarnMultipleSelectors) {
1039 ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel,
1040 SourceRange(LParenLoc, RParenLoc), false, false);
1041 if (!Method)
1042 Method = LookupFactoryMethodInGlobalPool(Sel,
1043 SourceRange(LParenLoc, RParenLoc));
1044 if (!Method) {
1045 if (const ObjCMethodDecl *OM = SelectorsForTypoCorrection(Sel)) {
1046 Selector MatchedSel = OM->getSelector();
1047 SourceRange SelectorRange(LParenLoc.getLocWithOffset(1),
1048 RParenLoc.getLocWithOffset(-1));
1049 Diag(SelLoc, diag::warn_undeclared_selector_with_typo)
1050 << Sel << MatchedSel
1051 << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString());
1052
1053 } else
1054 Diag(SelLoc, diag::warn_undeclared_selector) << Sel;
1055 } else
1056 DiagnoseMismatchedSelectors(*this, AtLoc, Method, LParenLoc, RParenLoc,
1057 WarnMultipleSelectors);
1058
1059 if (Method &&
1060 Method->getImplementationControl() != ObjCMethodDecl::Optional &&
1061 !getSourceManager().isInSystemHeader(Method->getLocation())) {
1062 llvm::DenseMap<Selector, SourceLocation>::iterator Pos
1063 = ReferencedSelectors.find(Sel);
1064 if (Pos == ReferencedSelectors.end())
1065 ReferencedSelectors.insert(std::make_pair(Sel, AtLoc));
1066 }
1067
1068 // In ARC, forbid the user from using @selector for
1069 // retain/release/autorelease/dealloc/retainCount.
1070 if (getLangOpts().ObjCAutoRefCount) {
1071 switch (Sel.getMethodFamily()) {
1072 case OMF_retain:
1073 case OMF_release:
1074 case OMF_autorelease:
1075 case OMF_retainCount:
1076 case OMF_dealloc:
1077 Diag(AtLoc, diag::err_arc_illegal_selector) <<
1078 Sel << SourceRange(LParenLoc, RParenLoc);
1079 break;
1080
1081 case OMF_None:
1082 case OMF_alloc:
1083 case OMF_copy:
1084 case OMF_finalize:
1085 case OMF_init:
1086 case OMF_mutableCopy:
1087 case OMF_new:
1088 case OMF_self:
1089 case OMF_performSelector:
1090 break;
1091 }
1092 }
1093 QualType Ty = Context.getObjCSelType();
1094 return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc);
1095 }
1096
ParseObjCProtocolExpression(IdentifierInfo * ProtocolId,SourceLocation AtLoc,SourceLocation ProtoLoc,SourceLocation LParenLoc,SourceLocation ProtoIdLoc,SourceLocation RParenLoc)1097 ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
1098 SourceLocation AtLoc,
1099 SourceLocation ProtoLoc,
1100 SourceLocation LParenLoc,
1101 SourceLocation ProtoIdLoc,
1102 SourceLocation RParenLoc) {
1103 ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoIdLoc);
1104 if (!PDecl) {
1105 Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;
1106 return true;
1107 }
1108
1109 QualType Ty = Context.getObjCProtoType();
1110 if (Ty.isNull())
1111 return true;
1112 Ty = Context.getObjCObjectPointerType(Ty);
1113 return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, ProtoIdLoc, RParenLoc);
1114 }
1115
1116 /// Try to capture an implicit reference to 'self'.
tryCaptureObjCSelf(SourceLocation Loc)1117 ObjCMethodDecl *Sema::tryCaptureObjCSelf(SourceLocation Loc) {
1118 DeclContext *DC = getFunctionLevelDeclContext();
1119
1120 // If we're not in an ObjC method, error out. Note that, unlike the
1121 // C++ case, we don't require an instance method --- class methods
1122 // still have a 'self', and we really do still need to capture it!
1123 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(DC);
1124 if (!method)
1125 return nullptr;
1126
1127 tryCaptureVariable(method->getSelfDecl(), Loc);
1128
1129 return method;
1130 }
1131
stripObjCInstanceType(ASTContext & Context,QualType T)1132 static QualType stripObjCInstanceType(ASTContext &Context, QualType T) {
1133 if (T == Context.getObjCInstanceType())
1134 return Context.getObjCIdType();
1135
1136 return T;
1137 }
1138
getMessageSendResultType(QualType ReceiverType,ObjCMethodDecl * Method,bool isClassMessage,bool isSuperMessage)1139 QualType Sema::getMessageSendResultType(QualType ReceiverType,
1140 ObjCMethodDecl *Method,
1141 bool isClassMessage, bool isSuperMessage) {
1142 assert(Method && "Must have a method");
1143 if (!Method->hasRelatedResultType())
1144 return Method->getSendResultType();
1145
1146 // If a method has a related return type:
1147 // - if the method found is an instance method, but the message send
1148 // was a class message send, T is the declared return type of the method
1149 // found
1150 if (Method->isInstanceMethod() && isClassMessage)
1151 return stripObjCInstanceType(Context, Method->getSendResultType());
1152
1153 // - if the receiver is super, T is a pointer to the class of the
1154 // enclosing method definition
1155 if (isSuperMessage) {
1156 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
1157 if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface())
1158 return Context.getObjCObjectPointerType(
1159 Context.getObjCInterfaceType(Class));
1160 }
1161
1162 // - if the receiver is the name of a class U, T is a pointer to U
1163 if (ReceiverType->getAs<ObjCInterfaceType>() ||
1164 ReceiverType->isObjCQualifiedInterfaceType())
1165 return Context.getObjCObjectPointerType(ReceiverType);
1166 // - if the receiver is of type Class or qualified Class type,
1167 // T is the declared return type of the method.
1168 if (ReceiverType->isObjCClassType() ||
1169 ReceiverType->isObjCQualifiedClassType())
1170 return stripObjCInstanceType(Context, Method->getSendResultType());
1171
1172 // - if the receiver is id, qualified id, Class, or qualified Class, T
1173 // is the receiver type, otherwise
1174 // - T is the type of the receiver expression.
1175 return ReceiverType;
1176 }
1177
1178 /// Look for an ObjC method whose result type exactly matches the given type.
1179 static const ObjCMethodDecl *
findExplicitInstancetypeDeclarer(const ObjCMethodDecl * MD,QualType instancetype)1180 findExplicitInstancetypeDeclarer(const ObjCMethodDecl *MD,
1181 QualType instancetype) {
1182 if (MD->getReturnType() == instancetype)
1183 return MD;
1184
1185 // For these purposes, a method in an @implementation overrides a
1186 // declaration in the @interface.
1187 if (const ObjCImplDecl *impl =
1188 dyn_cast<ObjCImplDecl>(MD->getDeclContext())) {
1189 const ObjCContainerDecl *iface;
1190 if (const ObjCCategoryImplDecl *catImpl =
1191 dyn_cast<ObjCCategoryImplDecl>(impl)) {
1192 iface = catImpl->getCategoryDecl();
1193 } else {
1194 iface = impl->getClassInterface();
1195 }
1196
1197 const ObjCMethodDecl *ifaceMD =
1198 iface->getMethod(MD->getSelector(), MD->isInstanceMethod());
1199 if (ifaceMD) return findExplicitInstancetypeDeclarer(ifaceMD, instancetype);
1200 }
1201
1202 SmallVector<const ObjCMethodDecl *, 4> overrides;
1203 MD->getOverriddenMethods(overrides);
1204 for (unsigned i = 0, e = overrides.size(); i != e; ++i) {
1205 if (const ObjCMethodDecl *result =
1206 findExplicitInstancetypeDeclarer(overrides[i], instancetype))
1207 return result;
1208 }
1209
1210 return nullptr;
1211 }
1212
EmitRelatedResultTypeNoteForReturn(QualType destType)1213 void Sema::EmitRelatedResultTypeNoteForReturn(QualType destType) {
1214 // Only complain if we're in an ObjC method and the required return
1215 // type doesn't match the method's declared return type.
1216 ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurContext);
1217 if (!MD || !MD->hasRelatedResultType() ||
1218 Context.hasSameUnqualifiedType(destType, MD->getReturnType()))
1219 return;
1220
1221 // Look for a method overridden by this method which explicitly uses
1222 // 'instancetype'.
1223 if (const ObjCMethodDecl *overridden =
1224 findExplicitInstancetypeDeclarer(MD, Context.getObjCInstanceType())) {
1225 SourceLocation loc;
1226 SourceRange range;
1227 if (TypeSourceInfo *TSI = overridden->getReturnTypeSourceInfo()) {
1228 range = TSI->getTypeLoc().getSourceRange();
1229 loc = range.getBegin();
1230 }
1231 if (loc.isInvalid())
1232 loc = overridden->getLocation();
1233 Diag(loc, diag::note_related_result_type_explicit)
1234 << /*current method*/ 1 << range;
1235 return;
1236 }
1237
1238 // Otherwise, if we have an interesting method family, note that.
1239 // This should always trigger if the above didn't.
1240 if (ObjCMethodFamily family = MD->getMethodFamily())
1241 Diag(MD->getLocation(), diag::note_related_result_type_family)
1242 << /*current method*/ 1
1243 << family;
1244 }
1245
EmitRelatedResultTypeNote(const Expr * E)1246 void Sema::EmitRelatedResultTypeNote(const Expr *E) {
1247 E = E->IgnoreParenImpCasts();
1248 const ObjCMessageExpr *MsgSend = dyn_cast<ObjCMessageExpr>(E);
1249 if (!MsgSend)
1250 return;
1251
1252 const ObjCMethodDecl *Method = MsgSend->getMethodDecl();
1253 if (!Method)
1254 return;
1255
1256 if (!Method->hasRelatedResultType())
1257 return;
1258
1259 if (Context.hasSameUnqualifiedType(
1260 Method->getReturnType().getNonReferenceType(), MsgSend->getType()))
1261 return;
1262
1263 if (!Context.hasSameUnqualifiedType(Method->getReturnType(),
1264 Context.getObjCInstanceType()))
1265 return;
1266
1267 Diag(Method->getLocation(), diag::note_related_result_type_inferred)
1268 << Method->isInstanceMethod() << Method->getSelector()
1269 << MsgSend->getType();
1270 }
1271
CheckMessageArgumentTypes(QualType ReceiverType,MultiExprArg Args,Selector Sel,ArrayRef<SourceLocation> SelectorLocs,ObjCMethodDecl * Method,bool isClassMessage,bool isSuperMessage,SourceLocation lbrac,SourceLocation rbrac,QualType & ReturnType,ExprValueKind & VK)1272 bool Sema::CheckMessageArgumentTypes(QualType ReceiverType,
1273 MultiExprArg Args,
1274 Selector Sel,
1275 ArrayRef<SourceLocation> SelectorLocs,
1276 ObjCMethodDecl *Method,
1277 bool isClassMessage, bool isSuperMessage,
1278 SourceLocation lbrac, SourceLocation rbrac,
1279 QualType &ReturnType, ExprValueKind &VK) {
1280 SourceLocation SelLoc;
1281 if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
1282 SelLoc = SelectorLocs.front();
1283 else
1284 SelLoc = lbrac;
1285
1286 if (!Method) {
1287 // Apply default argument promotion as for (C99 6.5.2.2p6).
1288 for (unsigned i = 0, e = Args.size(); i != e; i++) {
1289 if (Args[i]->isTypeDependent())
1290 continue;
1291
1292 ExprResult result;
1293 if (getLangOpts().DebuggerSupport) {
1294 QualType paramTy; // ignored
1295 result = checkUnknownAnyArg(SelLoc, Args[i], paramTy);
1296 } else {
1297 result = DefaultArgumentPromotion(Args[i]);
1298 }
1299 if (result.isInvalid())
1300 return true;
1301 Args[i] = result.get();
1302 }
1303
1304 unsigned DiagID;
1305 if (getLangOpts().ObjCAutoRefCount)
1306 DiagID = diag::err_arc_method_not_found;
1307 else
1308 DiagID = isClassMessage ? diag::warn_class_method_not_found
1309 : diag::warn_inst_method_not_found;
1310 if (!getLangOpts().DebuggerSupport) {
1311 const ObjCMethodDecl *OMD = SelectorsForTypoCorrection(Sel, ReceiverType);
1312 if (OMD && !OMD->isInvalidDecl()) {
1313 if (getLangOpts().ObjCAutoRefCount)
1314 DiagID = diag::error_method_not_found_with_typo;
1315 else
1316 DiagID = isClassMessage ? diag::warn_class_method_not_found_with_typo
1317 : diag::warn_instance_method_not_found_with_typo;
1318 Selector MatchedSel = OMD->getSelector();
1319 SourceRange SelectorRange(SelectorLocs.front(), SelectorLocs.back());
1320 Diag(SelLoc, DiagID)
1321 << Sel<< isClassMessage << MatchedSel
1322 << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString());
1323 }
1324 else
1325 Diag(SelLoc, DiagID)
1326 << Sel << isClassMessage << SourceRange(SelectorLocs.front(),
1327 SelectorLocs.back());
1328 // Find the class to which we are sending this message.
1329 if (ReceiverType->isObjCObjectPointerType()) {
1330 if (ObjCInterfaceDecl *Class =
1331 ReceiverType->getAs<ObjCObjectPointerType>()->getInterfaceDecl())
1332 Diag(Class->getLocation(), diag::note_receiver_class_declared);
1333 }
1334 }
1335
1336 // In debuggers, we want to use __unknown_anytype for these
1337 // results so that clients can cast them.
1338 if (getLangOpts().DebuggerSupport) {
1339 ReturnType = Context.UnknownAnyTy;
1340 } else {
1341 ReturnType = Context.getObjCIdType();
1342 }
1343 VK = VK_RValue;
1344 return false;
1345 }
1346
1347 ReturnType = getMessageSendResultType(ReceiverType, Method, isClassMessage,
1348 isSuperMessage);
1349 VK = Expr::getValueKindForType(Method->getReturnType());
1350
1351 unsigned NumNamedArgs = Sel.getNumArgs();
1352 // Method might have more arguments than selector indicates. This is due
1353 // to addition of c-style arguments in method.
1354 if (Method->param_size() > Sel.getNumArgs())
1355 NumNamedArgs = Method->param_size();
1356 // FIXME. This need be cleaned up.
1357 if (Args.size() < NumNamedArgs) {
1358 Diag(SelLoc, diag::err_typecheck_call_too_few_args)
1359 << 2 << NumNamedArgs << static_cast<unsigned>(Args.size());
1360 return false;
1361 }
1362
1363 bool IsError = false;
1364 for (unsigned i = 0; i < NumNamedArgs; i++) {
1365 // We can't do any type-checking on a type-dependent argument.
1366 if (Args[i]->isTypeDependent())
1367 continue;
1368
1369 Expr *argExpr = Args[i];
1370
1371 ParmVarDecl *param = Method->parameters()[i];
1372 assert(argExpr && "CheckMessageArgumentTypes(): missing expression");
1373
1374 // Strip the unbridged-cast placeholder expression off unless it's
1375 // a consumed argument.
1376 if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
1377 !param->hasAttr<CFConsumedAttr>())
1378 argExpr = stripARCUnbridgedCast(argExpr);
1379
1380 // If the parameter is __unknown_anytype, infer its type
1381 // from the argument.
1382 if (param->getType() == Context.UnknownAnyTy) {
1383 QualType paramType;
1384 ExprResult argE = checkUnknownAnyArg(SelLoc, argExpr, paramType);
1385 if (argE.isInvalid()) {
1386 IsError = true;
1387 } else {
1388 Args[i] = argE.get();
1389
1390 // Update the parameter type in-place.
1391 param->setType(paramType);
1392 }
1393 continue;
1394 }
1395
1396 if (RequireCompleteType(argExpr->getSourceRange().getBegin(),
1397 param->getType(),
1398 diag::err_call_incomplete_argument, argExpr))
1399 return true;
1400
1401 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
1402 param);
1403 ExprResult ArgE = PerformCopyInitialization(Entity, SelLoc, argExpr);
1404 if (ArgE.isInvalid())
1405 IsError = true;
1406 else
1407 Args[i] = ArgE.getAs<Expr>();
1408 }
1409
1410 // Promote additional arguments to variadic methods.
1411 if (Method->isVariadic()) {
1412 for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
1413 if (Args[i]->isTypeDependent())
1414 continue;
1415
1416 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
1417 nullptr);
1418 IsError |= Arg.isInvalid();
1419 Args[i] = Arg.get();
1420 }
1421 } else {
1422 // Check for extra arguments to non-variadic methods.
1423 if (Args.size() != NumNamedArgs) {
1424 Diag(Args[NumNamedArgs]->getLocStart(),
1425 diag::err_typecheck_call_too_many_args)
1426 << 2 /*method*/ << NumNamedArgs << static_cast<unsigned>(Args.size())
1427 << Method->getSourceRange()
1428 << SourceRange(Args[NumNamedArgs]->getLocStart(),
1429 Args.back()->getLocEnd());
1430 }
1431 }
1432
1433 DiagnoseSentinelCalls(Method, SelLoc, Args);
1434
1435 // Do additional checkings on method.
1436 IsError |= CheckObjCMethodCall(
1437 Method, SelLoc, makeArrayRef<const Expr *>(Args.data(), Args.size()));
1438
1439 return IsError;
1440 }
1441
isSelfExpr(Expr * RExpr)1442 bool Sema::isSelfExpr(Expr *RExpr) {
1443 // 'self' is objc 'self' in an objc method only.
1444 ObjCMethodDecl *Method =
1445 dyn_cast_or_null<ObjCMethodDecl>(CurContext->getNonClosureAncestor());
1446 return isSelfExpr(RExpr, Method);
1447 }
1448
isSelfExpr(Expr * receiver,const ObjCMethodDecl * method)1449 bool Sema::isSelfExpr(Expr *receiver, const ObjCMethodDecl *method) {
1450 if (!method) return false;
1451
1452 receiver = receiver->IgnoreParenLValueCasts();
1453 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(receiver))
1454 if (DRE->getDecl() == method->getSelfDecl())
1455 return true;
1456 return false;
1457 }
1458
1459 /// LookupMethodInType - Look up a method in an ObjCObjectType.
LookupMethodInObjectType(Selector sel,QualType type,bool isInstance)1460 ObjCMethodDecl *Sema::LookupMethodInObjectType(Selector sel, QualType type,
1461 bool isInstance) {
1462 const ObjCObjectType *objType = type->castAs<ObjCObjectType>();
1463 if (ObjCInterfaceDecl *iface = objType->getInterface()) {
1464 // Look it up in the main interface (and categories, etc.)
1465 if (ObjCMethodDecl *method = iface->lookupMethod(sel, isInstance))
1466 return method;
1467
1468 // Okay, look for "private" methods declared in any
1469 // @implementations we've seen.
1470 if (ObjCMethodDecl *method = iface->lookupPrivateMethod(sel, isInstance))
1471 return method;
1472 }
1473
1474 // Check qualifiers.
1475 for (const auto *I : objType->quals())
1476 if (ObjCMethodDecl *method = I->lookupMethod(sel, isInstance))
1477 return method;
1478
1479 return nullptr;
1480 }
1481
1482 /// LookupMethodInQualifiedType - Lookups up a method in protocol qualifier
1483 /// list of a qualified objective pointer type.
LookupMethodInQualifiedType(Selector Sel,const ObjCObjectPointerType * OPT,bool Instance)1484 ObjCMethodDecl *Sema::LookupMethodInQualifiedType(Selector Sel,
1485 const ObjCObjectPointerType *OPT,
1486 bool Instance)
1487 {
1488 ObjCMethodDecl *MD = nullptr;
1489 for (const auto *PROTO : OPT->quals()) {
1490 if ((MD = PROTO->lookupMethod(Sel, Instance))) {
1491 return MD;
1492 }
1493 }
1494 return nullptr;
1495 }
1496
DiagnoseARCUseOfWeakReceiver(Sema & S,Expr * Receiver)1497 static void DiagnoseARCUseOfWeakReceiver(Sema &S, Expr *Receiver) {
1498 if (!Receiver)
1499 return;
1500
1501 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Receiver))
1502 Receiver = OVE->getSourceExpr();
1503
1504 Expr *RExpr = Receiver->IgnoreParenImpCasts();
1505 SourceLocation Loc = RExpr->getLocStart();
1506 QualType T = RExpr->getType();
1507 const ObjCPropertyDecl *PDecl = nullptr;
1508 const ObjCMethodDecl *GDecl = nullptr;
1509 if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(RExpr)) {
1510 RExpr = POE->getSyntacticForm();
1511 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(RExpr)) {
1512 if (PRE->isImplicitProperty()) {
1513 GDecl = PRE->getImplicitPropertyGetter();
1514 if (GDecl) {
1515 T = GDecl->getReturnType();
1516 }
1517 }
1518 else {
1519 PDecl = PRE->getExplicitProperty();
1520 if (PDecl) {
1521 T = PDecl->getType();
1522 }
1523 }
1524 }
1525 }
1526 else if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(RExpr)) {
1527 // See if receiver is a method which envokes a synthesized getter
1528 // backing a 'weak' property.
1529 ObjCMethodDecl *Method = ME->getMethodDecl();
1530 if (Method && Method->getSelector().getNumArgs() == 0) {
1531 PDecl = Method->findPropertyDecl();
1532 if (PDecl)
1533 T = PDecl->getType();
1534 }
1535 }
1536
1537 if (T.getObjCLifetime() != Qualifiers::OCL_Weak) {
1538 if (!PDecl)
1539 return;
1540 if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak))
1541 return;
1542 }
1543
1544 S.Diag(Loc, diag::warn_receiver_is_weak)
1545 << ((!PDecl && !GDecl) ? 0 : (PDecl ? 1 : 2));
1546
1547 if (PDecl)
1548 S.Diag(PDecl->getLocation(), diag::note_property_declare);
1549 else if (GDecl)
1550 S.Diag(GDecl->getLocation(), diag::note_method_declared_at) << GDecl;
1551
1552 S.Diag(Loc, diag::note_arc_assign_to_strong);
1553 }
1554
1555 /// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an
1556 /// objective C interface. This is a property reference expression.
1557 ExprResult Sema::
HandleExprPropertyRefExpr(const ObjCObjectPointerType * OPT,Expr * BaseExpr,SourceLocation OpLoc,DeclarationName MemberName,SourceLocation MemberLoc,SourceLocation SuperLoc,QualType SuperType,bool Super)1558 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
1559 Expr *BaseExpr, SourceLocation OpLoc,
1560 DeclarationName MemberName,
1561 SourceLocation MemberLoc,
1562 SourceLocation SuperLoc, QualType SuperType,
1563 bool Super) {
1564 const ObjCInterfaceType *IFaceT = OPT->getInterfaceType();
1565 ObjCInterfaceDecl *IFace = IFaceT->getDecl();
1566
1567 if (!MemberName.isIdentifier()) {
1568 Diag(MemberLoc, diag::err_invalid_property_name)
1569 << MemberName << QualType(OPT, 0);
1570 return ExprError();
1571 }
1572
1573 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1574
1575 SourceRange BaseRange = Super? SourceRange(SuperLoc)
1576 : BaseExpr->getSourceRange();
1577 if (RequireCompleteType(MemberLoc, OPT->getPointeeType(),
1578 diag::err_property_not_found_forward_class,
1579 MemberName, BaseRange))
1580 return ExprError();
1581
1582 // Search for a declared property first.
1583 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Member)) {
1584 // Check whether we can reference this property.
1585 if (DiagnoseUseOfDecl(PD, MemberLoc))
1586 return ExprError();
1587 if (Super)
1588 return new (Context)
1589 ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue,
1590 OK_ObjCProperty, MemberLoc, SuperLoc, SuperType);
1591 else
1592 return new (Context)
1593 ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue,
1594 OK_ObjCProperty, MemberLoc, BaseExpr);
1595 }
1596 // Check protocols on qualified interfaces.
1597 for (const auto *I : OPT->quals())
1598 if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration(Member)) {
1599 // Check whether we can reference this property.
1600 if (DiagnoseUseOfDecl(PD, MemberLoc))
1601 return ExprError();
1602
1603 if (Super)
1604 return new (Context) ObjCPropertyRefExpr(
1605 PD, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty, MemberLoc,
1606 SuperLoc, SuperType);
1607 else
1608 return new (Context)
1609 ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue,
1610 OK_ObjCProperty, MemberLoc, BaseExpr);
1611 }
1612 // If that failed, look for an "implicit" property by seeing if the nullary
1613 // selector is implemented.
1614
1615 // FIXME: The logic for looking up nullary and unary selectors should be
1616 // shared with the code in ActOnInstanceMessage.
1617
1618 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
1619 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
1620
1621 // May be founf in property's qualified list.
1622 if (!Getter)
1623 Getter = LookupMethodInQualifiedType(Sel, OPT, true);
1624
1625 // If this reference is in an @implementation, check for 'private' methods.
1626 if (!Getter)
1627 Getter = IFace->lookupPrivateMethod(Sel);
1628
1629 if (Getter) {
1630 // Check if we can reference this property.
1631 if (DiagnoseUseOfDecl(Getter, MemberLoc))
1632 return ExprError();
1633 }
1634 // If we found a getter then this may be a valid dot-reference, we
1635 // will look for the matching setter, in case it is needed.
1636 Selector SetterSel =
1637 SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
1638 PP.getSelectorTable(), Member);
1639 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
1640
1641 // May be founf in property's qualified list.
1642 if (!Setter)
1643 Setter = LookupMethodInQualifiedType(SetterSel, OPT, true);
1644
1645 if (!Setter) {
1646 // If this reference is in an @implementation, also check for 'private'
1647 // methods.
1648 Setter = IFace->lookupPrivateMethod(SetterSel);
1649 }
1650
1651 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
1652 return ExprError();
1653
1654 if (Getter || Setter) {
1655 if (Super)
1656 return new (Context)
1657 ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
1658 OK_ObjCProperty, MemberLoc, SuperLoc, SuperType);
1659 else
1660 return new (Context)
1661 ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
1662 OK_ObjCProperty, MemberLoc, BaseExpr);
1663
1664 }
1665
1666 // Attempt to correct for typos in property names.
1667 DeclFilterCCC<ObjCPropertyDecl> Validator;
1668 if (TypoCorrection Corrected = CorrectTypo(
1669 DeclarationNameInfo(MemberName, MemberLoc), LookupOrdinaryName,
1670 nullptr, nullptr, Validator, CTK_ErrorRecovery, IFace, false, OPT)) {
1671 diagnoseTypo(Corrected, PDiag(diag::err_property_not_found_suggest)
1672 << MemberName << QualType(OPT, 0));
1673 DeclarationName TypoResult = Corrected.getCorrection();
1674 return HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc,
1675 TypoResult, MemberLoc,
1676 SuperLoc, SuperType, Super);
1677 }
1678 ObjCInterfaceDecl *ClassDeclared;
1679 if (ObjCIvarDecl *Ivar =
1680 IFace->lookupInstanceVariable(Member, ClassDeclared)) {
1681 QualType T = Ivar->getType();
1682 if (const ObjCObjectPointerType * OBJPT =
1683 T->getAsObjCInterfacePointerType()) {
1684 if (RequireCompleteType(MemberLoc, OBJPT->getPointeeType(),
1685 diag::err_property_not_as_forward_class,
1686 MemberName, BaseExpr))
1687 return ExprError();
1688 }
1689 Diag(MemberLoc,
1690 diag::err_ivar_access_using_property_syntax_suggest)
1691 << MemberName << QualType(OPT, 0) << Ivar->getDeclName()
1692 << FixItHint::CreateReplacement(OpLoc, "->");
1693 return ExprError();
1694 }
1695
1696 Diag(MemberLoc, diag::err_property_not_found)
1697 << MemberName << QualType(OPT, 0);
1698 if (Setter)
1699 Diag(Setter->getLocation(), diag::note_getter_unavailable)
1700 << MemberName << BaseExpr->getSourceRange();
1701 return ExprError();
1702 }
1703
1704
1705
1706 ExprResult Sema::
ActOnClassPropertyRefExpr(IdentifierInfo & receiverName,IdentifierInfo & propertyName,SourceLocation receiverNameLoc,SourceLocation propertyNameLoc)1707 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
1708 IdentifierInfo &propertyName,
1709 SourceLocation receiverNameLoc,
1710 SourceLocation propertyNameLoc) {
1711
1712 IdentifierInfo *receiverNamePtr = &receiverName;
1713 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(receiverNamePtr,
1714 receiverNameLoc);
1715
1716 bool IsSuper = false;
1717 if (!IFace) {
1718 // If the "receiver" is 'super' in a method, handle it as an expression-like
1719 // property reference.
1720 if (receiverNamePtr->isStr("super")) {
1721 IsSuper = true;
1722
1723 if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) {
1724 if (CurMethod->isInstanceMethod()) {
1725 ObjCInterfaceDecl *Super =
1726 CurMethod->getClassInterface()->getSuperClass();
1727 if (!Super) {
1728 // The current class does not have a superclass.
1729 Diag(receiverNameLoc, diag::error_root_class_cannot_use_super)
1730 << CurMethod->getClassInterface()->getIdentifier();
1731 return ExprError();
1732 }
1733 QualType T = Context.getObjCInterfaceType(Super);
1734 T = Context.getObjCObjectPointerType(T);
1735
1736 return HandleExprPropertyRefExpr(T->getAsObjCInterfacePointerType(),
1737 /*BaseExpr*/nullptr,
1738 SourceLocation()/*OpLoc*/,
1739 &propertyName,
1740 propertyNameLoc,
1741 receiverNameLoc, T, true);
1742 }
1743
1744 // Otherwise, if this is a class method, try dispatching to our
1745 // superclass.
1746 IFace = CurMethod->getClassInterface()->getSuperClass();
1747 }
1748 }
1749
1750 if (!IFace) {
1751 Diag(receiverNameLoc, diag::err_expected_either) << tok::identifier
1752 << tok::l_paren;
1753 return ExprError();
1754 }
1755 }
1756
1757 // Search for a declared property first.
1758 Selector Sel = PP.getSelectorTable().getNullarySelector(&propertyName);
1759 ObjCMethodDecl *Getter = IFace->lookupClassMethod(Sel);
1760
1761 // If this reference is in an @implementation, check for 'private' methods.
1762 if (!Getter)
1763 Getter = IFace->lookupPrivateClassMethod(Sel);
1764
1765 if (Getter) {
1766 // FIXME: refactor/share with ActOnMemberReference().
1767 // Check if we can reference this property.
1768 if (DiagnoseUseOfDecl(Getter, propertyNameLoc))
1769 return ExprError();
1770 }
1771
1772 // Look for the matching setter, in case it is needed.
1773 Selector SetterSel =
1774 SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
1775 PP.getSelectorTable(),
1776 &propertyName);
1777
1778 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1779 if (!Setter) {
1780 // If this reference is in an @implementation, also check for 'private'
1781 // methods.
1782 Setter = IFace->lookupPrivateClassMethod(SetterSel);
1783 }
1784 // Look through local category implementations associated with the class.
1785 if (!Setter)
1786 Setter = IFace->getCategoryClassMethod(SetterSel);
1787
1788 if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc))
1789 return ExprError();
1790
1791 if (Getter || Setter) {
1792 if (IsSuper)
1793 return new (Context)
1794 ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
1795 OK_ObjCProperty, propertyNameLoc, receiverNameLoc,
1796 Context.getObjCInterfaceType(IFace));
1797
1798 return new (Context) ObjCPropertyRefExpr(
1799 Getter, Setter, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty,
1800 propertyNameLoc, receiverNameLoc, IFace);
1801 }
1802 return ExprError(Diag(propertyNameLoc, diag::err_property_not_found)
1803 << &propertyName << Context.getObjCInterfaceType(IFace));
1804 }
1805
1806 namespace {
1807
1808 class ObjCInterfaceOrSuperCCC : public CorrectionCandidateCallback {
1809 public:
ObjCInterfaceOrSuperCCC(ObjCMethodDecl * Method)1810 ObjCInterfaceOrSuperCCC(ObjCMethodDecl *Method) {
1811 // Determine whether "super" is acceptable in the current context.
1812 if (Method && Method->getClassInterface())
1813 WantObjCSuper = Method->getClassInterface()->getSuperClass();
1814 }
1815
ValidateCandidate(const TypoCorrection & candidate)1816 bool ValidateCandidate(const TypoCorrection &candidate) override {
1817 return candidate.getCorrectionDeclAs<ObjCInterfaceDecl>() ||
1818 candidate.isKeyword("super");
1819 }
1820 };
1821
1822 }
1823
getObjCMessageKind(Scope * S,IdentifierInfo * Name,SourceLocation NameLoc,bool IsSuper,bool HasTrailingDot,ParsedType & ReceiverType)1824 Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S,
1825 IdentifierInfo *Name,
1826 SourceLocation NameLoc,
1827 bool IsSuper,
1828 bool HasTrailingDot,
1829 ParsedType &ReceiverType) {
1830 ReceiverType = ParsedType();
1831
1832 // If the identifier is "super" and there is no trailing dot, we're
1833 // messaging super. If the identifier is "super" and there is a
1834 // trailing dot, it's an instance message.
1835 if (IsSuper && S->isInObjcMethodScope())
1836 return HasTrailingDot? ObjCInstanceMessage : ObjCSuperMessage;
1837
1838 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
1839 LookupName(Result, S);
1840
1841 switch (Result.getResultKind()) {
1842 case LookupResult::NotFound:
1843 // Normal name lookup didn't find anything. If we're in an
1844 // Objective-C method, look for ivars. If we find one, we're done!
1845 // FIXME: This is a hack. Ivar lookup should be part of normal
1846 // lookup.
1847 if (ObjCMethodDecl *Method = getCurMethodDecl()) {
1848 if (!Method->getClassInterface()) {
1849 // Fall back: let the parser try to parse it as an instance message.
1850 return ObjCInstanceMessage;
1851 }
1852
1853 ObjCInterfaceDecl *ClassDeclared;
1854 if (Method->getClassInterface()->lookupInstanceVariable(Name,
1855 ClassDeclared))
1856 return ObjCInstanceMessage;
1857 }
1858
1859 // Break out; we'll perform typo correction below.
1860 break;
1861
1862 case LookupResult::NotFoundInCurrentInstantiation:
1863 case LookupResult::FoundOverloaded:
1864 case LookupResult::FoundUnresolvedValue:
1865 case LookupResult::Ambiguous:
1866 Result.suppressDiagnostics();
1867 return ObjCInstanceMessage;
1868
1869 case LookupResult::Found: {
1870 // If the identifier is a class or not, and there is a trailing dot,
1871 // it's an instance message.
1872 if (HasTrailingDot)
1873 return ObjCInstanceMessage;
1874 // We found something. If it's a type, then we have a class
1875 // message. Otherwise, it's an instance message.
1876 NamedDecl *ND = Result.getFoundDecl();
1877 QualType T;
1878 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(ND))
1879 T = Context.getObjCInterfaceType(Class);
1880 else if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) {
1881 T = Context.getTypeDeclType(Type);
1882 DiagnoseUseOfDecl(Type, NameLoc);
1883 }
1884 else
1885 return ObjCInstanceMessage;
1886
1887 // We have a class message, and T is the type we're
1888 // messaging. Build source-location information for it.
1889 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
1890 ReceiverType = CreateParsedType(T, TSInfo);
1891 return ObjCClassMessage;
1892 }
1893 }
1894
1895 ObjCInterfaceOrSuperCCC Validator(getCurMethodDecl());
1896 if (TypoCorrection Corrected =
1897 CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S,
1898 nullptr, Validator, CTK_ErrorRecovery, nullptr, false,
1899 nullptr, false)) {
1900 if (Corrected.isKeyword()) {
1901 // If we've found the keyword "super" (the only keyword that would be
1902 // returned by CorrectTypo), this is a send to super.
1903 diagnoseTypo(Corrected,
1904 PDiag(diag::err_unknown_receiver_suggest) << Name);
1905 return ObjCSuperMessage;
1906 } else if (ObjCInterfaceDecl *Class =
1907 Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
1908 // If we found a declaration, correct when it refers to an Objective-C
1909 // class.
1910 diagnoseTypo(Corrected,
1911 PDiag(diag::err_unknown_receiver_suggest) << Name);
1912 QualType T = Context.getObjCInterfaceType(Class);
1913 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
1914 ReceiverType = CreateParsedType(T, TSInfo);
1915 return ObjCClassMessage;
1916 }
1917 }
1918
1919 // Fall back: let the parser try to parse it as an instance message.
1920 return ObjCInstanceMessage;
1921 }
1922
ActOnSuperMessage(Scope * S,SourceLocation SuperLoc,Selector Sel,SourceLocation LBracLoc,ArrayRef<SourceLocation> SelectorLocs,SourceLocation RBracLoc,MultiExprArg Args)1923 ExprResult Sema::ActOnSuperMessage(Scope *S,
1924 SourceLocation SuperLoc,
1925 Selector Sel,
1926 SourceLocation LBracLoc,
1927 ArrayRef<SourceLocation> SelectorLocs,
1928 SourceLocation RBracLoc,
1929 MultiExprArg Args) {
1930 // Determine whether we are inside a method or not.
1931 ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc);
1932 if (!Method) {
1933 Diag(SuperLoc, diag::err_invalid_receiver_to_message_super);
1934 return ExprError();
1935 }
1936
1937 ObjCInterfaceDecl *Class = Method->getClassInterface();
1938 if (!Class) {
1939 Diag(SuperLoc, diag::error_no_super_class_message)
1940 << Method->getDeclName();
1941 return ExprError();
1942 }
1943
1944 ObjCInterfaceDecl *Super = Class->getSuperClass();
1945 if (!Super) {
1946 // The current class does not have a superclass.
1947 Diag(SuperLoc, diag::error_root_class_cannot_use_super)
1948 << Class->getIdentifier();
1949 return ExprError();
1950 }
1951
1952 // We are in a method whose class has a superclass, so 'super'
1953 // is acting as a keyword.
1954 if (Method->getSelector() == Sel)
1955 getCurFunction()->ObjCShouldCallSuper = false;
1956
1957 if (Method->isInstanceMethod()) {
1958 // Since we are in an instance method, this is an instance
1959 // message to the superclass instance.
1960 QualType SuperTy = Context.getObjCInterfaceType(Super);
1961 SuperTy = Context.getObjCObjectPointerType(SuperTy);
1962 return BuildInstanceMessage(nullptr, SuperTy, SuperLoc,
1963 Sel, /*Method=*/nullptr,
1964 LBracLoc, SelectorLocs, RBracLoc, Args);
1965 }
1966
1967 // Since we are in a class method, this is a class message to
1968 // the superclass.
1969 return BuildClassMessage(/*ReceiverTypeInfo=*/nullptr,
1970 Context.getObjCInterfaceType(Super),
1971 SuperLoc, Sel, /*Method=*/nullptr,
1972 LBracLoc, SelectorLocs, RBracLoc, Args);
1973 }
1974
1975
BuildClassMessageImplicit(QualType ReceiverType,bool isSuperReceiver,SourceLocation Loc,Selector Sel,ObjCMethodDecl * Method,MultiExprArg Args)1976 ExprResult Sema::BuildClassMessageImplicit(QualType ReceiverType,
1977 bool isSuperReceiver,
1978 SourceLocation Loc,
1979 Selector Sel,
1980 ObjCMethodDecl *Method,
1981 MultiExprArg Args) {
1982 TypeSourceInfo *receiverTypeInfo = nullptr;
1983 if (!ReceiverType.isNull())
1984 receiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType);
1985
1986 return BuildClassMessage(receiverTypeInfo, ReceiverType,
1987 /*SuperLoc=*/isSuperReceiver ? Loc : SourceLocation(),
1988 Sel, Method, Loc, Loc, Loc, Args,
1989 /*isImplicit=*/true);
1990
1991 }
1992
applyCocoaAPICheck(Sema & S,const ObjCMessageExpr * Msg,unsigned DiagID,bool (* refactor)(const ObjCMessageExpr *,const NSAPI &,edit::Commit &))1993 static void applyCocoaAPICheck(Sema &S, const ObjCMessageExpr *Msg,
1994 unsigned DiagID,
1995 bool (*refactor)(const ObjCMessageExpr *,
1996 const NSAPI &, edit::Commit &)) {
1997 SourceLocation MsgLoc = Msg->getExprLoc();
1998 if (S.Diags.isIgnored(DiagID, MsgLoc))
1999 return;
2000
2001 SourceManager &SM = S.SourceMgr;
2002 edit::Commit ECommit(SM, S.LangOpts);
2003 if (refactor(Msg,*S.NSAPIObj, ECommit)) {
2004 DiagnosticBuilder Builder = S.Diag(MsgLoc, DiagID)
2005 << Msg->getSelector() << Msg->getSourceRange();
2006 // FIXME: Don't emit diagnostic at all if fixits are non-commitable.
2007 if (!ECommit.isCommitable())
2008 return;
2009 for (edit::Commit::edit_iterator
2010 I = ECommit.edit_begin(), E = ECommit.edit_end(); I != E; ++I) {
2011 const edit::Commit::Edit &Edit = *I;
2012 switch (Edit.Kind) {
2013 case edit::Commit::Act_Insert:
2014 Builder.AddFixItHint(FixItHint::CreateInsertion(Edit.OrigLoc,
2015 Edit.Text,
2016 Edit.BeforePrev));
2017 break;
2018 case edit::Commit::Act_InsertFromRange:
2019 Builder.AddFixItHint(
2020 FixItHint::CreateInsertionFromRange(Edit.OrigLoc,
2021 Edit.getInsertFromRange(SM),
2022 Edit.BeforePrev));
2023 break;
2024 case edit::Commit::Act_Remove:
2025 Builder.AddFixItHint(FixItHint::CreateRemoval(Edit.getFileRange(SM)));
2026 break;
2027 }
2028 }
2029 }
2030 }
2031
checkCocoaAPI(Sema & S,const ObjCMessageExpr * Msg)2032 static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) {
2033 applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use,
2034 edit::rewriteObjCRedundantCallWithLiteral);
2035 }
2036
2037 /// \brief Build an Objective-C class message expression.
2038 ///
2039 /// This routine takes care of both normal class messages and
2040 /// class messages to the superclass.
2041 ///
2042 /// \param ReceiverTypeInfo Type source information that describes the
2043 /// receiver of this message. This may be NULL, in which case we are
2044 /// sending to the superclass and \p SuperLoc must be a valid source
2045 /// location.
2046
2047 /// \param ReceiverType The type of the object receiving the
2048 /// message. When \p ReceiverTypeInfo is non-NULL, this is the same
2049 /// type as that refers to. For a superclass send, this is the type of
2050 /// the superclass.
2051 ///
2052 /// \param SuperLoc The location of the "super" keyword in a
2053 /// superclass message.
2054 ///
2055 /// \param Sel The selector to which the message is being sent.
2056 ///
2057 /// \param Method The method that this class message is invoking, if
2058 /// already known.
2059 ///
2060 /// \param LBracLoc The location of the opening square bracket ']'.
2061 ///
2062 /// \param RBracLoc The location of the closing square bracket ']'.
2063 ///
2064 /// \param ArgsIn The message arguments.
BuildClassMessage(TypeSourceInfo * ReceiverTypeInfo,QualType ReceiverType,SourceLocation SuperLoc,Selector Sel,ObjCMethodDecl * Method,SourceLocation LBracLoc,ArrayRef<SourceLocation> SelectorLocs,SourceLocation RBracLoc,MultiExprArg ArgsIn,bool isImplicit)2065 ExprResult Sema::BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
2066 QualType ReceiverType,
2067 SourceLocation SuperLoc,
2068 Selector Sel,
2069 ObjCMethodDecl *Method,
2070 SourceLocation LBracLoc,
2071 ArrayRef<SourceLocation> SelectorLocs,
2072 SourceLocation RBracLoc,
2073 MultiExprArg ArgsIn,
2074 bool isImplicit) {
2075 SourceLocation Loc = SuperLoc.isValid()? SuperLoc
2076 : ReceiverTypeInfo->getTypeLoc().getSourceRange().getBegin();
2077 if (LBracLoc.isInvalid()) {
2078 Diag(Loc, diag::err_missing_open_square_message_send)
2079 << FixItHint::CreateInsertion(Loc, "[");
2080 LBracLoc = Loc;
2081 }
2082 SourceLocation SelLoc;
2083 if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2084 SelLoc = SelectorLocs.front();
2085 else
2086 SelLoc = Loc;
2087
2088 if (ReceiverType->isDependentType()) {
2089 // If the receiver type is dependent, we can't type-check anything
2090 // at this point. Build a dependent expression.
2091 unsigned NumArgs = ArgsIn.size();
2092 Expr **Args = ArgsIn.data();
2093 assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2094 return ObjCMessageExpr::Create(
2095 Context, ReceiverType, VK_RValue, LBracLoc, ReceiverTypeInfo, Sel,
2096 SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs), RBracLoc,
2097 isImplicit);
2098 }
2099
2100 // Find the class to which we are sending this message.
2101 ObjCInterfaceDecl *Class = nullptr;
2102 const ObjCObjectType *ClassType = ReceiverType->getAs<ObjCObjectType>();
2103 if (!ClassType || !(Class = ClassType->getInterface())) {
2104 Diag(Loc, diag::err_invalid_receiver_class_message)
2105 << ReceiverType;
2106 return ExprError();
2107 }
2108 assert(Class && "We don't know which class we're messaging?");
2109 // objc++ diagnoses during typename annotation.
2110 if (!getLangOpts().CPlusPlus)
2111 (void)DiagnoseUseOfDecl(Class, SelLoc);
2112 // Find the method we are messaging.
2113 if (!Method) {
2114 SourceRange TypeRange
2115 = SuperLoc.isValid()? SourceRange(SuperLoc)
2116 : ReceiverTypeInfo->getTypeLoc().getSourceRange();
2117 if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class),
2118 (getLangOpts().ObjCAutoRefCount
2119 ? diag::err_arc_receiver_forward_class
2120 : diag::warn_receiver_forward_class),
2121 TypeRange)) {
2122 // A forward class used in messaging is treated as a 'Class'
2123 Method = LookupFactoryMethodInGlobalPool(Sel,
2124 SourceRange(LBracLoc, RBracLoc));
2125 if (Method && !getLangOpts().ObjCAutoRefCount)
2126 Diag(Method->getLocation(), diag::note_method_sent_forward_class)
2127 << Method->getDeclName();
2128 }
2129 if (!Method)
2130 Method = Class->lookupClassMethod(Sel);
2131
2132 // If we have an implementation in scope, check "private" methods.
2133 if (!Method)
2134 Method = Class->lookupPrivateClassMethod(Sel);
2135
2136 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2137 return ExprError();
2138 }
2139
2140 // Check the argument types and determine the result type.
2141 QualType ReturnType;
2142 ExprValueKind VK = VK_RValue;
2143
2144 unsigned NumArgs = ArgsIn.size();
2145 Expr **Args = ArgsIn.data();
2146 if (CheckMessageArgumentTypes(ReceiverType, MultiExprArg(Args, NumArgs),
2147 Sel, SelectorLocs,
2148 Method, true,
2149 SuperLoc.isValid(), LBracLoc, RBracLoc,
2150 ReturnType, VK))
2151 return ExprError();
2152
2153 if (Method && !Method->getReturnType()->isVoidType() &&
2154 RequireCompleteType(LBracLoc, Method->getReturnType(),
2155 diag::err_illegal_message_expr_incomplete_type))
2156 return ExprError();
2157
2158 // Construct the appropriate ObjCMessageExpr.
2159 ObjCMessageExpr *Result;
2160 if (SuperLoc.isValid())
2161 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2162 SuperLoc, /*IsInstanceSuper=*/false,
2163 ReceiverType, Sel, SelectorLocs,
2164 Method, makeArrayRef(Args, NumArgs),
2165 RBracLoc, isImplicit);
2166 else {
2167 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2168 ReceiverTypeInfo, Sel, SelectorLocs,
2169 Method, makeArrayRef(Args, NumArgs),
2170 RBracLoc, isImplicit);
2171 if (!isImplicit)
2172 checkCocoaAPI(*this, Result);
2173 }
2174 return MaybeBindToTemporary(Result);
2175 }
2176
2177 // ActOnClassMessage - used for both unary and keyword messages.
2178 // ArgExprs is optional - if it is present, the number of expressions
2179 // is obtained from Sel.getNumArgs().
ActOnClassMessage(Scope * S,ParsedType Receiver,Selector Sel,SourceLocation LBracLoc,ArrayRef<SourceLocation> SelectorLocs,SourceLocation RBracLoc,MultiExprArg Args)2180 ExprResult Sema::ActOnClassMessage(Scope *S,
2181 ParsedType Receiver,
2182 Selector Sel,
2183 SourceLocation LBracLoc,
2184 ArrayRef<SourceLocation> SelectorLocs,
2185 SourceLocation RBracLoc,
2186 MultiExprArg Args) {
2187 TypeSourceInfo *ReceiverTypeInfo;
2188 QualType ReceiverType = GetTypeFromParser(Receiver, &ReceiverTypeInfo);
2189 if (ReceiverType.isNull())
2190 return ExprError();
2191
2192
2193 if (!ReceiverTypeInfo)
2194 ReceiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType, LBracLoc);
2195
2196 return BuildClassMessage(ReceiverTypeInfo, ReceiverType,
2197 /*SuperLoc=*/SourceLocation(), Sel,
2198 /*Method=*/nullptr, LBracLoc, SelectorLocs, RBracLoc,
2199 Args);
2200 }
2201
BuildInstanceMessageImplicit(Expr * Receiver,QualType ReceiverType,SourceLocation Loc,Selector Sel,ObjCMethodDecl * Method,MultiExprArg Args)2202 ExprResult Sema::BuildInstanceMessageImplicit(Expr *Receiver,
2203 QualType ReceiverType,
2204 SourceLocation Loc,
2205 Selector Sel,
2206 ObjCMethodDecl *Method,
2207 MultiExprArg Args) {
2208 return BuildInstanceMessage(Receiver, ReceiverType,
2209 /*SuperLoc=*/!Receiver ? Loc : SourceLocation(),
2210 Sel, Method, Loc, Loc, Loc, Args,
2211 /*isImplicit=*/true);
2212 }
2213
2214 /// \brief Build an Objective-C instance message expression.
2215 ///
2216 /// This routine takes care of both normal instance messages and
2217 /// instance messages to the superclass instance.
2218 ///
2219 /// \param Receiver The expression that computes the object that will
2220 /// receive this message. This may be empty, in which case we are
2221 /// sending to the superclass instance and \p SuperLoc must be a valid
2222 /// source location.
2223 ///
2224 /// \param ReceiverType The (static) type of the object receiving the
2225 /// message. When a \p Receiver expression is provided, this is the
2226 /// same type as that expression. For a superclass instance send, this
2227 /// is a pointer to the type of the superclass.
2228 ///
2229 /// \param SuperLoc The location of the "super" keyword in a
2230 /// superclass instance message.
2231 ///
2232 /// \param Sel The selector to which the message is being sent.
2233 ///
2234 /// \param Method The method that this instance message is invoking, if
2235 /// already known.
2236 ///
2237 /// \param LBracLoc The location of the opening square bracket ']'.
2238 ///
2239 /// \param RBracLoc The location of the closing square bracket ']'.
2240 ///
2241 /// \param ArgsIn The message arguments.
BuildInstanceMessage(Expr * Receiver,QualType ReceiverType,SourceLocation SuperLoc,Selector Sel,ObjCMethodDecl * Method,SourceLocation LBracLoc,ArrayRef<SourceLocation> SelectorLocs,SourceLocation RBracLoc,MultiExprArg ArgsIn,bool isImplicit)2242 ExprResult Sema::BuildInstanceMessage(Expr *Receiver,
2243 QualType ReceiverType,
2244 SourceLocation SuperLoc,
2245 Selector Sel,
2246 ObjCMethodDecl *Method,
2247 SourceLocation LBracLoc,
2248 ArrayRef<SourceLocation> SelectorLocs,
2249 SourceLocation RBracLoc,
2250 MultiExprArg ArgsIn,
2251 bool isImplicit) {
2252 // The location of the receiver.
2253 SourceLocation Loc = SuperLoc.isValid()? SuperLoc : Receiver->getLocStart();
2254 SourceRange RecRange =
2255 SuperLoc.isValid()? SuperLoc : Receiver->getSourceRange();
2256 SourceLocation SelLoc;
2257 if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2258 SelLoc = SelectorLocs.front();
2259 else
2260 SelLoc = Loc;
2261
2262 if (LBracLoc.isInvalid()) {
2263 Diag(Loc, diag::err_missing_open_square_message_send)
2264 << FixItHint::CreateInsertion(Loc, "[");
2265 LBracLoc = Loc;
2266 }
2267
2268 // If we have a receiver expression, perform appropriate promotions
2269 // and determine receiver type.
2270 if (Receiver) {
2271 if (Receiver->hasPlaceholderType()) {
2272 ExprResult Result;
2273 if (Receiver->getType() == Context.UnknownAnyTy)
2274 Result = forceUnknownAnyToType(Receiver, Context.getObjCIdType());
2275 else
2276 Result = CheckPlaceholderExpr(Receiver);
2277 if (Result.isInvalid()) return ExprError();
2278 Receiver = Result.get();
2279 }
2280
2281 if (Receiver->isTypeDependent()) {
2282 // If the receiver is type-dependent, we can't type-check anything
2283 // at this point. Build a dependent expression.
2284 unsigned NumArgs = ArgsIn.size();
2285 Expr **Args = ArgsIn.data();
2286 assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2287 return ObjCMessageExpr::Create(
2288 Context, Context.DependentTy, VK_RValue, LBracLoc, Receiver, Sel,
2289 SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs),
2290 RBracLoc, isImplicit);
2291 }
2292
2293 // If necessary, apply function/array conversion to the receiver.
2294 // C99 6.7.5.3p[7,8].
2295 ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver);
2296 if (Result.isInvalid())
2297 return ExprError();
2298 Receiver = Result.get();
2299 ReceiverType = Receiver->getType();
2300
2301 // If the receiver is an ObjC pointer, a block pointer, or an
2302 // __attribute__((NSObject)) pointer, we don't need to do any
2303 // special conversion in order to look up a receiver.
2304 if (ReceiverType->isObjCRetainableType()) {
2305 // do nothing
2306 } else if (!getLangOpts().ObjCAutoRefCount &&
2307 !Context.getObjCIdType().isNull() &&
2308 (ReceiverType->isPointerType() ||
2309 ReceiverType->isIntegerType())) {
2310 // Implicitly convert integers and pointers to 'id' but emit a warning.
2311 // But not in ARC.
2312 Diag(Loc, diag::warn_bad_receiver_type)
2313 << ReceiverType
2314 << Receiver->getSourceRange();
2315 if (ReceiverType->isPointerType()) {
2316 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2317 CK_CPointerToObjCPointerCast).get();
2318 } else {
2319 // TODO: specialized warning on null receivers?
2320 bool IsNull = Receiver->isNullPointerConstant(Context,
2321 Expr::NPC_ValueDependentIsNull);
2322 CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer;
2323 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2324 Kind).get();
2325 }
2326 ReceiverType = Receiver->getType();
2327 } else if (getLangOpts().CPlusPlus) {
2328 // The receiver must be a complete type.
2329 if (RequireCompleteType(Loc, Receiver->getType(),
2330 diag::err_incomplete_receiver_type))
2331 return ExprError();
2332
2333 ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver);
2334 if (result.isUsable()) {
2335 Receiver = result.get();
2336 ReceiverType = Receiver->getType();
2337 }
2338 }
2339 }
2340
2341 // There's a somewhat weird interaction here where we assume that we
2342 // won't actually have a method unless we also don't need to do some
2343 // of the more detailed type-checking on the receiver.
2344
2345 if (!Method) {
2346 // Handle messages to id.
2347 bool receiverIsId = ReceiverType->isObjCIdType();
2348 if (receiverIsId || ReceiverType->isBlockPointerType() ||
2349 (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) {
2350 Method = LookupInstanceMethodInGlobalPool(Sel,
2351 SourceRange(LBracLoc, RBracLoc),
2352 receiverIsId);
2353 if (!Method)
2354 Method = LookupFactoryMethodInGlobalPool(Sel,
2355 SourceRange(LBracLoc,RBracLoc),
2356 receiverIsId);
2357 } else if (ReceiverType->isObjCClassType() ||
2358 ReceiverType->isObjCQualifiedClassType()) {
2359 // Handle messages to Class.
2360 // We allow sending a message to a qualified Class ("Class<foo>"), which
2361 // is ok as long as one of the protocols implements the selector (if not, warn).
2362 if (const ObjCObjectPointerType *QClassTy
2363 = ReceiverType->getAsObjCQualifiedClassType()) {
2364 // Search protocols for class methods.
2365 Method = LookupMethodInQualifiedType(Sel, QClassTy, false);
2366 if (!Method) {
2367 Method = LookupMethodInQualifiedType(Sel, QClassTy, true);
2368 // warn if instance method found for a Class message.
2369 if (Method) {
2370 Diag(SelLoc, diag::warn_instance_method_on_class_found)
2371 << Method->getSelector() << Sel;
2372 Diag(Method->getLocation(), diag::note_method_declared_at)
2373 << Method->getDeclName();
2374 }
2375 }
2376 } else {
2377 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2378 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) {
2379 // First check the public methods in the class interface.
2380 Method = ClassDecl->lookupClassMethod(Sel);
2381
2382 if (!Method)
2383 Method = ClassDecl->lookupPrivateClassMethod(Sel);
2384 }
2385 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2386 return ExprError();
2387 }
2388 if (!Method) {
2389 // If not messaging 'self', look for any factory method named 'Sel'.
2390 if (!Receiver || !isSelfExpr(Receiver)) {
2391 Method = LookupFactoryMethodInGlobalPool(Sel,
2392 SourceRange(LBracLoc, RBracLoc),
2393 true);
2394 if (!Method) {
2395 // If no class (factory) method was found, check if an _instance_
2396 // method of the same name exists in the root class only.
2397 Method = LookupInstanceMethodInGlobalPool(Sel,
2398 SourceRange(LBracLoc, RBracLoc),
2399 true);
2400 if (Method)
2401 if (const ObjCInterfaceDecl *ID =
2402 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
2403 if (ID->getSuperClass())
2404 Diag(SelLoc, diag::warn_root_inst_method_not_found)
2405 << Sel << SourceRange(LBracLoc, RBracLoc);
2406 }
2407 }
2408 }
2409 }
2410 }
2411 } else {
2412 ObjCInterfaceDecl *ClassDecl = nullptr;
2413
2414 // We allow sending a message to a qualified ID ("id<foo>"), which is ok as
2415 // long as one of the protocols implements the selector (if not, warn).
2416 // And as long as message is not deprecated/unavailable (warn if it is).
2417 if (const ObjCObjectPointerType *QIdTy
2418 = ReceiverType->getAsObjCQualifiedIdType()) {
2419 // Search protocols for instance methods.
2420 Method = LookupMethodInQualifiedType(Sel, QIdTy, true);
2421 if (!Method)
2422 Method = LookupMethodInQualifiedType(Sel, QIdTy, false);
2423 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2424 return ExprError();
2425 } else if (const ObjCObjectPointerType *OCIType
2426 = ReceiverType->getAsObjCInterfacePointerType()) {
2427 // We allow sending a message to a pointer to an interface (an object).
2428 ClassDecl = OCIType->getInterfaceDecl();
2429
2430 // Try to complete the type. Under ARC, this is a hard error from which
2431 // we don't try to recover.
2432 const ObjCInterfaceDecl *forwardClass = nullptr;
2433 if (RequireCompleteType(Loc, OCIType->getPointeeType(),
2434 getLangOpts().ObjCAutoRefCount
2435 ? diag::err_arc_receiver_forward_instance
2436 : diag::warn_receiver_forward_instance,
2437 Receiver? Receiver->getSourceRange()
2438 : SourceRange(SuperLoc))) {
2439 if (getLangOpts().ObjCAutoRefCount)
2440 return ExprError();
2441
2442 forwardClass = OCIType->getInterfaceDecl();
2443 Diag(Receiver ? Receiver->getLocStart()
2444 : SuperLoc, diag::note_receiver_is_id);
2445 Method = nullptr;
2446 } else {
2447 Method = ClassDecl->lookupInstanceMethod(Sel);
2448 }
2449
2450 if (!Method)
2451 // Search protocol qualifiers.
2452 Method = LookupMethodInQualifiedType(Sel, OCIType, true);
2453
2454 if (!Method) {
2455 // If we have implementations in scope, check "private" methods.
2456 Method = ClassDecl->lookupPrivateMethod(Sel);
2457
2458 if (!Method && getLangOpts().ObjCAutoRefCount) {
2459 Diag(SelLoc, diag::err_arc_may_not_respond)
2460 << OCIType->getPointeeType() << Sel << RecRange
2461 << SourceRange(SelectorLocs.front(), SelectorLocs.back());
2462 return ExprError();
2463 }
2464
2465 if (!Method && (!Receiver || !isSelfExpr(Receiver))) {
2466 // If we still haven't found a method, look in the global pool. This
2467 // behavior isn't very desirable, however we need it for GCC
2468 // compatibility. FIXME: should we deviate??
2469 if (OCIType->qual_empty()) {
2470 Method = LookupInstanceMethodInGlobalPool(Sel,
2471 SourceRange(LBracLoc, RBracLoc));
2472 if (Method && !forwardClass)
2473 Diag(SelLoc, diag::warn_maynot_respond)
2474 << OCIType->getInterfaceDecl()->getIdentifier()
2475 << Sel << RecRange;
2476 }
2477 }
2478 }
2479 if (Method && DiagnoseUseOfDecl(Method, SelLoc, forwardClass))
2480 return ExprError();
2481 } else {
2482 // Reject other random receiver types (e.g. structs).
2483 Diag(Loc, diag::err_bad_receiver_type)
2484 << ReceiverType << Receiver->getSourceRange();
2485 return ExprError();
2486 }
2487 }
2488 }
2489
2490 FunctionScopeInfo *DIFunctionScopeInfo =
2491 (Method && Method->getMethodFamily() == OMF_init)
2492 ? getEnclosingFunction() : nullptr;
2493
2494 if (DIFunctionScopeInfo &&
2495 DIFunctionScopeInfo->ObjCIsDesignatedInit &&
2496 (SuperLoc.isValid() || isSelfExpr(Receiver))) {
2497 bool isDesignatedInitChain = false;
2498 if (SuperLoc.isValid()) {
2499 if (const ObjCObjectPointerType *
2500 OCIType = ReceiverType->getAsObjCInterfacePointerType()) {
2501 if (const ObjCInterfaceDecl *ID = OCIType->getInterfaceDecl()) {
2502 // Either we know this is a designated initializer or we
2503 // conservatively assume it because we don't know for sure.
2504 if (!ID->declaresOrInheritsDesignatedInitializers() ||
2505 ID->isDesignatedInitializer(Sel)) {
2506 isDesignatedInitChain = true;
2507 DIFunctionScopeInfo->ObjCWarnForNoDesignatedInitChain = false;
2508 }
2509 }
2510 }
2511 }
2512 if (!isDesignatedInitChain) {
2513 const ObjCMethodDecl *InitMethod = nullptr;
2514 bool isDesignated =
2515 getCurMethodDecl()->isDesignatedInitializerForTheInterface(&InitMethod);
2516 assert(isDesignated && InitMethod);
2517 (void)isDesignated;
2518 Diag(SelLoc, SuperLoc.isValid() ?
2519 diag::warn_objc_designated_init_non_designated_init_call :
2520 diag::warn_objc_designated_init_non_super_designated_init_call);
2521 Diag(InitMethod->getLocation(),
2522 diag::note_objc_designated_init_marked_here);
2523 }
2524 }
2525
2526 if (DIFunctionScopeInfo &&
2527 DIFunctionScopeInfo->ObjCIsSecondaryInit &&
2528 (SuperLoc.isValid() || isSelfExpr(Receiver))) {
2529 if (SuperLoc.isValid()) {
2530 Diag(SelLoc, diag::warn_objc_secondary_init_super_init_call);
2531 } else {
2532 DIFunctionScopeInfo->ObjCWarnForNoInitDelegation = false;
2533 }
2534 }
2535
2536 // Check the message arguments.
2537 unsigned NumArgs = ArgsIn.size();
2538 Expr **Args = ArgsIn.data();
2539 QualType ReturnType;
2540 ExprValueKind VK = VK_RValue;
2541 bool ClassMessage = (ReceiverType->isObjCClassType() ||
2542 ReceiverType->isObjCQualifiedClassType());
2543 if (CheckMessageArgumentTypes(ReceiverType, MultiExprArg(Args, NumArgs),
2544 Sel, SelectorLocs, Method,
2545 ClassMessage, SuperLoc.isValid(),
2546 LBracLoc, RBracLoc, ReturnType, VK))
2547 return ExprError();
2548
2549 if (Method && !Method->getReturnType()->isVoidType() &&
2550 RequireCompleteType(LBracLoc, Method->getReturnType(),
2551 diag::err_illegal_message_expr_incomplete_type))
2552 return ExprError();
2553
2554 // In ARC, forbid the user from sending messages to
2555 // retain/release/autorelease/dealloc/retainCount explicitly.
2556 if (getLangOpts().ObjCAutoRefCount) {
2557 ObjCMethodFamily family =
2558 (Method ? Method->getMethodFamily() : Sel.getMethodFamily());
2559 switch (family) {
2560 case OMF_init:
2561 if (Method)
2562 checkInitMethod(Method, ReceiverType);
2563
2564 case OMF_None:
2565 case OMF_alloc:
2566 case OMF_copy:
2567 case OMF_finalize:
2568 case OMF_mutableCopy:
2569 case OMF_new:
2570 case OMF_self:
2571 break;
2572
2573 case OMF_dealloc:
2574 case OMF_retain:
2575 case OMF_release:
2576 case OMF_autorelease:
2577 case OMF_retainCount:
2578 Diag(SelLoc, diag::err_arc_illegal_explicit_message)
2579 << Sel << RecRange;
2580 break;
2581
2582 case OMF_performSelector:
2583 if (Method && NumArgs >= 1) {
2584 if (ObjCSelectorExpr *SelExp = dyn_cast<ObjCSelectorExpr>(Args[0])) {
2585 Selector ArgSel = SelExp->getSelector();
2586 ObjCMethodDecl *SelMethod =
2587 LookupInstanceMethodInGlobalPool(ArgSel,
2588 SelExp->getSourceRange());
2589 if (!SelMethod)
2590 SelMethod =
2591 LookupFactoryMethodInGlobalPool(ArgSel,
2592 SelExp->getSourceRange());
2593 if (SelMethod) {
2594 ObjCMethodFamily SelFamily = SelMethod->getMethodFamily();
2595 switch (SelFamily) {
2596 case OMF_alloc:
2597 case OMF_copy:
2598 case OMF_mutableCopy:
2599 case OMF_new:
2600 case OMF_self:
2601 case OMF_init:
2602 // Issue error, unless ns_returns_not_retained.
2603 if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
2604 // selector names a +1 method
2605 Diag(SelLoc,
2606 diag::err_arc_perform_selector_retains);
2607 Diag(SelMethod->getLocation(), diag::note_method_declared_at)
2608 << SelMethod->getDeclName();
2609 }
2610 break;
2611 default:
2612 // +0 call. OK. unless ns_returns_retained.
2613 if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) {
2614 // selector names a +1 method
2615 Diag(SelLoc,
2616 diag::err_arc_perform_selector_retains);
2617 Diag(SelMethod->getLocation(), diag::note_method_declared_at)
2618 << SelMethod->getDeclName();
2619 }
2620 break;
2621 }
2622 }
2623 } else {
2624 // error (may leak).
2625 Diag(SelLoc, diag::warn_arc_perform_selector_leaks);
2626 Diag(Args[0]->getExprLoc(), diag::note_used_here);
2627 }
2628 }
2629 break;
2630 }
2631 }
2632
2633 // Construct the appropriate ObjCMessageExpr instance.
2634 ObjCMessageExpr *Result;
2635 if (SuperLoc.isValid())
2636 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2637 SuperLoc, /*IsInstanceSuper=*/true,
2638 ReceiverType, Sel, SelectorLocs, Method,
2639 makeArrayRef(Args, NumArgs), RBracLoc,
2640 isImplicit);
2641 else {
2642 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2643 Receiver, Sel, SelectorLocs, Method,
2644 makeArrayRef(Args, NumArgs), RBracLoc,
2645 isImplicit);
2646 if (!isImplicit)
2647 checkCocoaAPI(*this, Result);
2648 }
2649
2650 if (getLangOpts().ObjCAutoRefCount) {
2651 // Do not warn about IBOutlet weak property receivers being set to null
2652 // as this cannot asynchronously happen.
2653 bool WarnWeakReceiver = true;
2654 if (isImplicit && Method)
2655 if (const ObjCPropertyDecl *PropertyDecl = Method->findPropertyDecl())
2656 WarnWeakReceiver = !PropertyDecl->hasAttr<IBOutletAttr>();
2657 if (WarnWeakReceiver)
2658 DiagnoseARCUseOfWeakReceiver(*this, Receiver);
2659
2660 // In ARC, annotate delegate init calls.
2661 if (Result->getMethodFamily() == OMF_init &&
2662 (SuperLoc.isValid() || isSelfExpr(Receiver))) {
2663 // Only consider init calls *directly* in init implementations,
2664 // not within blocks.
2665 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(CurContext);
2666 if (method && method->getMethodFamily() == OMF_init) {
2667 // The implicit assignment to self means we also don't want to
2668 // consume the result.
2669 Result->setDelegateInitCall(true);
2670 return Result;
2671 }
2672 }
2673
2674 // In ARC, check for message sends which are likely to introduce
2675 // retain cycles.
2676 checkRetainCycles(Result);
2677
2678 if (!isImplicit && Method) {
2679 if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {
2680 bool IsWeak =
2681 Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak;
2682 if (!IsWeak && Sel.isUnarySelector())
2683 IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak;
2684 if (IsWeak &&
2685 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, LBracLoc))
2686 getCurFunction()->recordUseOfWeak(Result, Prop);
2687 }
2688 }
2689 }
2690
2691 return MaybeBindToTemporary(Result);
2692 }
2693
RemoveSelectorFromWarningCache(Sema & S,Expr * Arg)2694 static void RemoveSelectorFromWarningCache(Sema &S, Expr* Arg) {
2695 if (ObjCSelectorExpr *OSE =
2696 dyn_cast<ObjCSelectorExpr>(Arg->IgnoreParenCasts())) {
2697 Selector Sel = OSE->getSelector();
2698 SourceLocation Loc = OSE->getAtLoc();
2699 llvm::DenseMap<Selector, SourceLocation>::iterator Pos
2700 = S.ReferencedSelectors.find(Sel);
2701 if (Pos != S.ReferencedSelectors.end() && Pos->second == Loc)
2702 S.ReferencedSelectors.erase(Pos);
2703 }
2704 }
2705
2706 // ActOnInstanceMessage - used for both unary and keyword messages.
2707 // ArgExprs is optional - if it is present, the number of expressions
2708 // is obtained from Sel.getNumArgs().
ActOnInstanceMessage(Scope * S,Expr * Receiver,Selector Sel,SourceLocation LBracLoc,ArrayRef<SourceLocation> SelectorLocs,SourceLocation RBracLoc,MultiExprArg Args)2709 ExprResult Sema::ActOnInstanceMessage(Scope *S,
2710 Expr *Receiver,
2711 Selector Sel,
2712 SourceLocation LBracLoc,
2713 ArrayRef<SourceLocation> SelectorLocs,
2714 SourceLocation RBracLoc,
2715 MultiExprArg Args) {
2716 if (!Receiver)
2717 return ExprError();
2718
2719 // A ParenListExpr can show up while doing error recovery with invalid code.
2720 if (isa<ParenListExpr>(Receiver)) {
2721 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver);
2722 if (Result.isInvalid()) return ExprError();
2723 Receiver = Result.get();
2724 }
2725
2726 if (RespondsToSelectorSel.isNull()) {
2727 IdentifierInfo *SelectorId = &Context.Idents.get("respondsToSelector");
2728 RespondsToSelectorSel = Context.Selectors.getUnarySelector(SelectorId);
2729 }
2730 if (Sel == RespondsToSelectorSel)
2731 RemoveSelectorFromWarningCache(*this, Args[0]);
2732
2733 return BuildInstanceMessage(Receiver, Receiver->getType(),
2734 /*SuperLoc=*/SourceLocation(), Sel,
2735 /*Method=*/nullptr, LBracLoc, SelectorLocs,
2736 RBracLoc, Args);
2737 }
2738
2739 enum ARCConversionTypeClass {
2740 /// int, void, struct A
2741 ACTC_none,
2742
2743 /// id, void (^)()
2744 ACTC_retainable,
2745
2746 /// id*, id***, void (^*)(),
2747 ACTC_indirectRetainable,
2748
2749 /// void* might be a normal C type, or it might a CF type.
2750 ACTC_voidPtr,
2751
2752 /// struct A*
2753 ACTC_coreFoundation
2754 };
isAnyRetainable(ARCConversionTypeClass ACTC)2755 static bool isAnyRetainable(ARCConversionTypeClass ACTC) {
2756 return (ACTC == ACTC_retainable ||
2757 ACTC == ACTC_coreFoundation ||
2758 ACTC == ACTC_voidPtr);
2759 }
isAnyCLike(ARCConversionTypeClass ACTC)2760 static bool isAnyCLike(ARCConversionTypeClass ACTC) {
2761 return ACTC == ACTC_none ||
2762 ACTC == ACTC_voidPtr ||
2763 ACTC == ACTC_coreFoundation;
2764 }
2765
classifyTypeForARCConversion(QualType type)2766 static ARCConversionTypeClass classifyTypeForARCConversion(QualType type) {
2767 bool isIndirect = false;
2768
2769 // Ignore an outermost reference type.
2770 if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
2771 type = ref->getPointeeType();
2772 isIndirect = true;
2773 }
2774
2775 // Drill through pointers and arrays recursively.
2776 while (true) {
2777 if (const PointerType *ptr = type->getAs<PointerType>()) {
2778 type = ptr->getPointeeType();
2779
2780 // The first level of pointer may be the innermost pointer on a CF type.
2781 if (!isIndirect) {
2782 if (type->isVoidType()) return ACTC_voidPtr;
2783 if (type->isRecordType()) return ACTC_coreFoundation;
2784 }
2785 } else if (const ArrayType *array = type->getAsArrayTypeUnsafe()) {
2786 type = QualType(array->getElementType()->getBaseElementTypeUnsafe(), 0);
2787 } else {
2788 break;
2789 }
2790 isIndirect = true;
2791 }
2792
2793 if (isIndirect) {
2794 if (type->isObjCARCBridgableType())
2795 return ACTC_indirectRetainable;
2796 return ACTC_none;
2797 }
2798
2799 if (type->isObjCARCBridgableType())
2800 return ACTC_retainable;
2801
2802 return ACTC_none;
2803 }
2804
2805 namespace {
2806 /// A result from the cast checker.
2807 enum ACCResult {
2808 /// Cannot be casted.
2809 ACC_invalid,
2810
2811 /// Can be safely retained or not retained.
2812 ACC_bottom,
2813
2814 /// Can be casted at +0.
2815 ACC_plusZero,
2816
2817 /// Can be casted at +1.
2818 ACC_plusOne
2819 };
merge(ACCResult left,ACCResult right)2820 ACCResult merge(ACCResult left, ACCResult right) {
2821 if (left == right) return left;
2822 if (left == ACC_bottom) return right;
2823 if (right == ACC_bottom) return left;
2824 return ACC_invalid;
2825 }
2826
2827 /// A checker which white-lists certain expressions whose conversion
2828 /// to or from retainable type would otherwise be forbidden in ARC.
2829 class ARCCastChecker : public StmtVisitor<ARCCastChecker, ACCResult> {
2830 typedef StmtVisitor<ARCCastChecker, ACCResult> super;
2831
2832 ASTContext &Context;
2833 ARCConversionTypeClass SourceClass;
2834 ARCConversionTypeClass TargetClass;
2835 bool Diagnose;
2836
isCFType(QualType type)2837 static bool isCFType(QualType type) {
2838 // Someday this can use ns_bridged. For now, it has to do this.
2839 return type->isCARCBridgableType();
2840 }
2841
2842 public:
ARCCastChecker(ASTContext & Context,ARCConversionTypeClass source,ARCConversionTypeClass target,bool diagnose)2843 ARCCastChecker(ASTContext &Context, ARCConversionTypeClass source,
2844 ARCConversionTypeClass target, bool diagnose)
2845 : Context(Context), SourceClass(source), TargetClass(target),
2846 Diagnose(diagnose) {}
2847
2848 using super::Visit;
Visit(Expr * e)2849 ACCResult Visit(Expr *e) {
2850 return super::Visit(e->IgnoreParens());
2851 }
2852
VisitStmt(Stmt * s)2853 ACCResult VisitStmt(Stmt *s) {
2854 return ACC_invalid;
2855 }
2856
2857 /// Null pointer constants can be casted however you please.
VisitExpr(Expr * e)2858 ACCResult VisitExpr(Expr *e) {
2859 if (e->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull))
2860 return ACC_bottom;
2861 return ACC_invalid;
2862 }
2863
2864 /// Objective-C string literals can be safely casted.
VisitObjCStringLiteral(ObjCStringLiteral * e)2865 ACCResult VisitObjCStringLiteral(ObjCStringLiteral *e) {
2866 // If we're casting to any retainable type, go ahead. Global
2867 // strings are immune to retains, so this is bottom.
2868 if (isAnyRetainable(TargetClass)) return ACC_bottom;
2869
2870 return ACC_invalid;
2871 }
2872
2873 /// Look through certain implicit and explicit casts.
VisitCastExpr(CastExpr * e)2874 ACCResult VisitCastExpr(CastExpr *e) {
2875 switch (e->getCastKind()) {
2876 case CK_NullToPointer:
2877 return ACC_bottom;
2878
2879 case CK_NoOp:
2880 case CK_LValueToRValue:
2881 case CK_BitCast:
2882 case CK_CPointerToObjCPointerCast:
2883 case CK_BlockPointerToObjCPointerCast:
2884 case CK_AnyPointerToBlockPointerCast:
2885 return Visit(e->getSubExpr());
2886
2887 default:
2888 return ACC_invalid;
2889 }
2890 }
2891
2892 /// Look through unary extension.
VisitUnaryExtension(UnaryOperator * e)2893 ACCResult VisitUnaryExtension(UnaryOperator *e) {
2894 return Visit(e->getSubExpr());
2895 }
2896
2897 /// Ignore the LHS of a comma operator.
VisitBinComma(BinaryOperator * e)2898 ACCResult VisitBinComma(BinaryOperator *e) {
2899 return Visit(e->getRHS());
2900 }
2901
2902 /// Conditional operators are okay if both sides are okay.
VisitConditionalOperator(ConditionalOperator * e)2903 ACCResult VisitConditionalOperator(ConditionalOperator *e) {
2904 ACCResult left = Visit(e->getTrueExpr());
2905 if (left == ACC_invalid) return ACC_invalid;
2906 return merge(left, Visit(e->getFalseExpr()));
2907 }
2908
2909 /// Look through pseudo-objects.
VisitPseudoObjectExpr(PseudoObjectExpr * e)2910 ACCResult VisitPseudoObjectExpr(PseudoObjectExpr *e) {
2911 // If we're getting here, we should always have a result.
2912 return Visit(e->getResultExpr());
2913 }
2914
2915 /// Statement expressions are okay if their result expression is okay.
VisitStmtExpr(StmtExpr * e)2916 ACCResult VisitStmtExpr(StmtExpr *e) {
2917 return Visit(e->getSubStmt()->body_back());
2918 }
2919
2920 /// Some declaration references are okay.
VisitDeclRefExpr(DeclRefExpr * e)2921 ACCResult VisitDeclRefExpr(DeclRefExpr *e) {
2922 // References to global constants from system headers are okay.
2923 // These are things like 'kCFStringTransformToLatin'. They are
2924 // can also be assumed to be immune to retains.
2925 VarDecl *var = dyn_cast<VarDecl>(e->getDecl());
2926 if (isAnyRetainable(TargetClass) &&
2927 isAnyRetainable(SourceClass) &&
2928 var &&
2929 var->getStorageClass() == SC_Extern &&
2930 var->getType().isConstQualified() &&
2931 Context.getSourceManager().isInSystemHeader(var->getLocation())) {
2932 return ACC_bottom;
2933 }
2934
2935 // Nothing else.
2936 return ACC_invalid;
2937 }
2938
2939 /// Some calls are okay.
VisitCallExpr(CallExpr * e)2940 ACCResult VisitCallExpr(CallExpr *e) {
2941 if (FunctionDecl *fn = e->getDirectCallee())
2942 if (ACCResult result = checkCallToFunction(fn))
2943 return result;
2944
2945 return super::VisitCallExpr(e);
2946 }
2947
checkCallToFunction(FunctionDecl * fn)2948 ACCResult checkCallToFunction(FunctionDecl *fn) {
2949 // Require a CF*Ref return type.
2950 if (!isCFType(fn->getReturnType()))
2951 return ACC_invalid;
2952
2953 if (!isAnyRetainable(TargetClass))
2954 return ACC_invalid;
2955
2956 // Honor an explicit 'not retained' attribute.
2957 if (fn->hasAttr<CFReturnsNotRetainedAttr>())
2958 return ACC_plusZero;
2959
2960 // Honor an explicit 'retained' attribute, except that for
2961 // now we're not going to permit implicit handling of +1 results,
2962 // because it's a bit frightening.
2963 if (fn->hasAttr<CFReturnsRetainedAttr>())
2964 return Diagnose ? ACC_plusOne
2965 : ACC_invalid; // ACC_plusOne if we start accepting this
2966
2967 // Recognize this specific builtin function, which is used by CFSTR.
2968 unsigned builtinID = fn->getBuiltinID();
2969 if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString)
2970 return ACC_bottom;
2971
2972 // Otherwise, don't do anything implicit with an unaudited function.
2973 if (!fn->hasAttr<CFAuditedTransferAttr>())
2974 return ACC_invalid;
2975
2976 // Otherwise, it's +0 unless it follows the create convention.
2977 if (ento::coreFoundation::followsCreateRule(fn))
2978 return Diagnose ? ACC_plusOne
2979 : ACC_invalid; // ACC_plusOne if we start accepting this
2980
2981 return ACC_plusZero;
2982 }
2983
VisitObjCMessageExpr(ObjCMessageExpr * e)2984 ACCResult VisitObjCMessageExpr(ObjCMessageExpr *e) {
2985 return checkCallToMethod(e->getMethodDecl());
2986 }
2987
VisitObjCPropertyRefExpr(ObjCPropertyRefExpr * e)2988 ACCResult VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *e) {
2989 ObjCMethodDecl *method;
2990 if (e->isExplicitProperty())
2991 method = e->getExplicitProperty()->getGetterMethodDecl();
2992 else
2993 method = e->getImplicitPropertyGetter();
2994 return checkCallToMethod(method);
2995 }
2996
checkCallToMethod(ObjCMethodDecl * method)2997 ACCResult checkCallToMethod(ObjCMethodDecl *method) {
2998 if (!method) return ACC_invalid;
2999
3000 // Check for message sends to functions returning CF types. We
3001 // just obey the Cocoa conventions with these, even though the
3002 // return type is CF.
3003 if (!isAnyRetainable(TargetClass) || !isCFType(method->getReturnType()))
3004 return ACC_invalid;
3005
3006 // If the method is explicitly marked not-retained, it's +0.
3007 if (method->hasAttr<CFReturnsNotRetainedAttr>())
3008 return ACC_plusZero;
3009
3010 // If the method is explicitly marked as returning retained, or its
3011 // selector follows a +1 Cocoa convention, treat it as +1.
3012 if (method->hasAttr<CFReturnsRetainedAttr>())
3013 return ACC_plusOne;
3014
3015 switch (method->getSelector().getMethodFamily()) {
3016 case OMF_alloc:
3017 case OMF_copy:
3018 case OMF_mutableCopy:
3019 case OMF_new:
3020 return ACC_plusOne;
3021
3022 default:
3023 // Otherwise, treat it as +0.
3024 return ACC_plusZero;
3025 }
3026 }
3027 };
3028 }
3029
isKnownName(StringRef name)3030 bool Sema::isKnownName(StringRef name) {
3031 if (name.empty())
3032 return false;
3033 LookupResult R(*this, &Context.Idents.get(name), SourceLocation(),
3034 Sema::LookupOrdinaryName);
3035 return LookupName(R, TUScope, false);
3036 }
3037
addFixitForObjCARCConversion(Sema & S,DiagnosticBuilder & DiagB,Sema::CheckedConversionKind CCK,SourceLocation afterLParen,QualType castType,Expr * castExpr,Expr * realCast,const char * bridgeKeyword,const char * CFBridgeName)3038 static void addFixitForObjCARCConversion(Sema &S,
3039 DiagnosticBuilder &DiagB,
3040 Sema::CheckedConversionKind CCK,
3041 SourceLocation afterLParen,
3042 QualType castType,
3043 Expr *castExpr,
3044 Expr *realCast,
3045 const char *bridgeKeyword,
3046 const char *CFBridgeName) {
3047 // We handle C-style and implicit casts here.
3048 switch (CCK) {
3049 case Sema::CCK_ImplicitConversion:
3050 case Sema::CCK_CStyleCast:
3051 case Sema::CCK_OtherCast:
3052 break;
3053 case Sema::CCK_FunctionalCast:
3054 return;
3055 }
3056
3057 if (CFBridgeName) {
3058 if (CCK == Sema::CCK_OtherCast) {
3059 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
3060 SourceRange range(NCE->getOperatorLoc(),
3061 NCE->getAngleBrackets().getEnd());
3062 SmallString<32> BridgeCall;
3063
3064 SourceManager &SM = S.getSourceManager();
3065 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
3066 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
3067 BridgeCall += ' ';
3068
3069 BridgeCall += CFBridgeName;
3070 DiagB.AddFixItHint(FixItHint::CreateReplacement(range, BridgeCall));
3071 }
3072 return;
3073 }
3074 Expr *castedE = castExpr;
3075 if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(castedE))
3076 castedE = CCE->getSubExpr();
3077 castedE = castedE->IgnoreImpCasts();
3078 SourceRange range = castedE->getSourceRange();
3079
3080 SmallString<32> BridgeCall;
3081
3082 SourceManager &SM = S.getSourceManager();
3083 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
3084 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
3085 BridgeCall += ' ';
3086
3087 BridgeCall += CFBridgeName;
3088
3089 if (isa<ParenExpr>(castedE)) {
3090 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3091 BridgeCall));
3092 } else {
3093 BridgeCall += '(';
3094 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3095 BridgeCall));
3096 DiagB.AddFixItHint(FixItHint::CreateInsertion(
3097 S.PP.getLocForEndOfToken(range.getEnd()),
3098 ")"));
3099 }
3100 return;
3101 }
3102
3103 if (CCK == Sema::CCK_CStyleCast) {
3104 DiagB.AddFixItHint(FixItHint::CreateInsertion(afterLParen, bridgeKeyword));
3105 } else if (CCK == Sema::CCK_OtherCast) {
3106 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
3107 std::string castCode = "(";
3108 castCode += bridgeKeyword;
3109 castCode += castType.getAsString();
3110 castCode += ")";
3111 SourceRange Range(NCE->getOperatorLoc(),
3112 NCE->getAngleBrackets().getEnd());
3113 DiagB.AddFixItHint(FixItHint::CreateReplacement(Range, castCode));
3114 }
3115 } else {
3116 std::string castCode = "(";
3117 castCode += bridgeKeyword;
3118 castCode += castType.getAsString();
3119 castCode += ")";
3120 Expr *castedE = castExpr->IgnoreImpCasts();
3121 SourceRange range = castedE->getSourceRange();
3122 if (isa<ParenExpr>(castedE)) {
3123 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3124 castCode));
3125 } else {
3126 castCode += "(";
3127 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3128 castCode));
3129 DiagB.AddFixItHint(FixItHint::CreateInsertion(
3130 S.PP.getLocForEndOfToken(range.getEnd()),
3131 ")"));
3132 }
3133 }
3134 }
3135
3136 template <typename T>
getObjCBridgeAttr(const TypedefType * TD)3137 static inline T *getObjCBridgeAttr(const TypedefType *TD) {
3138 TypedefNameDecl *TDNDecl = TD->getDecl();
3139 QualType QT = TDNDecl->getUnderlyingType();
3140 if (QT->isPointerType()) {
3141 QT = QT->getPointeeType();
3142 if (const RecordType *RT = QT->getAs<RecordType>())
3143 if (RecordDecl *RD = RT->getDecl()->getMostRecentDecl())
3144 return RD->getAttr<T>();
3145 }
3146 return nullptr;
3147 }
3148
ObjCBridgeRelatedAttrFromType(QualType T,TypedefNameDecl * & TDNDecl)3149 static ObjCBridgeRelatedAttr *ObjCBridgeRelatedAttrFromType(QualType T,
3150 TypedefNameDecl *&TDNDecl) {
3151 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3152 TDNDecl = TD->getDecl();
3153 if (ObjCBridgeRelatedAttr *ObjCBAttr =
3154 getObjCBridgeAttr<ObjCBridgeRelatedAttr>(TD))
3155 return ObjCBAttr;
3156 T = TDNDecl->getUnderlyingType();
3157 }
3158 return nullptr;
3159 }
3160
3161 static void
diagnoseObjCARCConversion(Sema & S,SourceRange castRange,QualType castType,ARCConversionTypeClass castACTC,Expr * castExpr,Expr * realCast,ARCConversionTypeClass exprACTC,Sema::CheckedConversionKind CCK)3162 diagnoseObjCARCConversion(Sema &S, SourceRange castRange,
3163 QualType castType, ARCConversionTypeClass castACTC,
3164 Expr *castExpr, Expr *realCast,
3165 ARCConversionTypeClass exprACTC,
3166 Sema::CheckedConversionKind CCK) {
3167 SourceLocation loc =
3168 (castRange.isValid() ? castRange.getBegin() : castExpr->getExprLoc());
3169
3170 if (S.makeUnavailableInSystemHeader(loc,
3171 "converts between Objective-C and C pointers in -fobjc-arc"))
3172 return;
3173
3174 QualType castExprType = castExpr->getType();
3175 TypedefNameDecl *TDNDecl = nullptr;
3176 if ((castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable &&
3177 ObjCBridgeRelatedAttrFromType(castType, TDNDecl)) ||
3178 (exprACTC == ACTC_coreFoundation && castACTC == ACTC_retainable &&
3179 ObjCBridgeRelatedAttrFromType(castExprType, TDNDecl)))
3180 return;
3181
3182 unsigned srcKind = 0;
3183 switch (exprACTC) {
3184 case ACTC_none:
3185 case ACTC_coreFoundation:
3186 case ACTC_voidPtr:
3187 srcKind = (castExprType->isPointerType() ? 1 : 0);
3188 break;
3189 case ACTC_retainable:
3190 srcKind = (castExprType->isBlockPointerType() ? 2 : 3);
3191 break;
3192 case ACTC_indirectRetainable:
3193 srcKind = 4;
3194 break;
3195 }
3196
3197 // Check whether this could be fixed with a bridge cast.
3198 SourceLocation afterLParen = S.PP.getLocForEndOfToken(castRange.getBegin());
3199 SourceLocation noteLoc = afterLParen.isValid() ? afterLParen : loc;
3200
3201 // Bridge from an ARC type to a CF type.
3202 if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {
3203
3204 S.Diag(loc, diag::err_arc_cast_requires_bridge)
3205 << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit
3206 << 2 // of C pointer type
3207 << castExprType
3208 << unsigned(castType->isBlockPointerType()) // to ObjC|block type
3209 << castType
3210 << castRange
3211 << castExpr->getSourceRange();
3212 bool br = S.isKnownName("CFBridgingRelease");
3213 ACCResult CreateRule =
3214 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3215 assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3216 if (CreateRule != ACC_plusOne)
3217 {
3218 DiagnosticBuilder DiagB =
3219 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3220 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3221
3222 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3223 castType, castExpr, realCast, "__bridge ",
3224 nullptr);
3225 }
3226 if (CreateRule != ACC_plusZero)
3227 {
3228 DiagnosticBuilder DiagB =
3229 (CCK == Sema::CCK_OtherCast && !br) ?
3230 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer) << castExprType :
3231 S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3232 diag::note_arc_bridge_transfer)
3233 << castExprType << br;
3234
3235 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3236 castType, castExpr, realCast, "__bridge_transfer ",
3237 br ? "CFBridgingRelease" : nullptr);
3238 }
3239
3240 return;
3241 }
3242
3243 // Bridge from a CF type to an ARC type.
3244 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {
3245 bool br = S.isKnownName("CFBridgingRetain");
3246 S.Diag(loc, diag::err_arc_cast_requires_bridge)
3247 << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit
3248 << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type
3249 << castExprType
3250 << 2 // to C pointer type
3251 << castType
3252 << castRange
3253 << castExpr->getSourceRange();
3254 ACCResult CreateRule =
3255 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3256 assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3257 if (CreateRule != ACC_plusOne)
3258 {
3259 DiagnosticBuilder DiagB =
3260 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3261 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3262 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3263 castType, castExpr, realCast, "__bridge ",
3264 nullptr);
3265 }
3266 if (CreateRule != ACC_plusZero)
3267 {
3268 DiagnosticBuilder DiagB =
3269 (CCK == Sema::CCK_OtherCast && !br) ?
3270 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType :
3271 S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3272 diag::note_arc_bridge_retained)
3273 << castType << br;
3274
3275 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3276 castType, castExpr, realCast, "__bridge_retained ",
3277 br ? "CFBridgingRetain" : nullptr);
3278 }
3279
3280 return;
3281 }
3282
3283 S.Diag(loc, diag::err_arc_mismatched_cast)
3284 << (CCK != Sema::CCK_ImplicitConversion)
3285 << srcKind << castExprType << castType
3286 << castRange << castExpr->getSourceRange();
3287 }
3288
3289 template <typename TB>
CheckObjCBridgeNSCast(Sema & S,QualType castType,Expr * castExpr,bool & HadTheAttribute,bool warn)3290 static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr,
3291 bool &HadTheAttribute, bool warn) {
3292 QualType T = castExpr->getType();
3293 HadTheAttribute = false;
3294 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3295 TypedefNameDecl *TDNDecl = TD->getDecl();
3296 if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {
3297 if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {
3298 HadTheAttribute = true;
3299 NamedDecl *Target = nullptr;
3300 // Check for an existing type with this name.
3301 LookupResult R(S, DeclarationName(Parm), SourceLocation(),
3302 Sema::LookupOrdinaryName);
3303 if (S.LookupName(R, S.TUScope)) {
3304 Target = R.getFoundDecl();
3305 if (Target && isa<ObjCInterfaceDecl>(Target)) {
3306 ObjCInterfaceDecl *ExprClass = cast<ObjCInterfaceDecl>(Target);
3307 if (const ObjCObjectPointerType *InterfacePointerType =
3308 castType->getAsObjCInterfacePointerType()) {
3309 ObjCInterfaceDecl *CastClass
3310 = InterfacePointerType->getObjectType()->getInterface();
3311 if ((CastClass == ExprClass) ||
3312 (CastClass && ExprClass->isSuperClassOf(CastClass)))
3313 return true;
3314 if (warn)
3315 S.Diag(castExpr->getLocStart(), diag::warn_objc_invalid_bridge)
3316 << T << Target->getName() << castType->getPointeeType();
3317 return false;
3318 } else if (castType->isObjCIdType() ||
3319 (S.Context.ObjCObjectAdoptsQTypeProtocols(
3320 castType, ExprClass)))
3321 // ok to cast to 'id'.
3322 // casting to id<p-list> is ok if bridge type adopts all of
3323 // p-list protocols.
3324 return true;
3325 else {
3326 if (warn) {
3327 S.Diag(castExpr->getLocStart(), diag::warn_objc_invalid_bridge)
3328 << T << Target->getName() << castType;
3329 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3330 S.Diag(Target->getLocStart(), diag::note_declared_at);
3331 }
3332 return false;
3333 }
3334 }
3335 }
3336 S.Diag(castExpr->getLocStart(), diag::err_objc_cf_bridged_not_interface)
3337 << castExpr->getType() << Parm;
3338 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3339 if (Target)
3340 S.Diag(Target->getLocStart(), diag::note_declared_at);
3341 return true;
3342 }
3343 return false;
3344 }
3345 T = TDNDecl->getUnderlyingType();
3346 }
3347 return true;
3348 }
3349
3350 template <typename TB>
CheckObjCBridgeCFCast(Sema & S,QualType castType,Expr * castExpr,bool & HadTheAttribute,bool warn)3351 static bool CheckObjCBridgeCFCast(Sema &S, QualType castType, Expr *castExpr,
3352 bool &HadTheAttribute, bool warn) {
3353 QualType T = castType;
3354 HadTheAttribute = false;
3355 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3356 TypedefNameDecl *TDNDecl = TD->getDecl();
3357 if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {
3358 if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {
3359 HadTheAttribute = true;
3360 NamedDecl *Target = nullptr;
3361 // Check for an existing type with this name.
3362 LookupResult R(S, DeclarationName(Parm), SourceLocation(),
3363 Sema::LookupOrdinaryName);
3364 if (S.LookupName(R, S.TUScope)) {
3365 Target = R.getFoundDecl();
3366 if (Target && isa<ObjCInterfaceDecl>(Target)) {
3367 ObjCInterfaceDecl *CastClass = cast<ObjCInterfaceDecl>(Target);
3368 if (const ObjCObjectPointerType *InterfacePointerType =
3369 castExpr->getType()->getAsObjCInterfacePointerType()) {
3370 ObjCInterfaceDecl *ExprClass
3371 = InterfacePointerType->getObjectType()->getInterface();
3372 if ((CastClass == ExprClass) ||
3373 (ExprClass && CastClass->isSuperClassOf(ExprClass)))
3374 return true;
3375 if (warn) {
3376 S.Diag(castExpr->getLocStart(), diag::warn_objc_invalid_bridge_to_cf)
3377 << castExpr->getType()->getPointeeType() << T;
3378 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3379 }
3380 return false;
3381 } else if (castExpr->getType()->isObjCIdType() ||
3382 (S.Context.QIdProtocolsAdoptObjCObjectProtocols(
3383 castExpr->getType(), CastClass)))
3384 // ok to cast an 'id' expression to a CFtype.
3385 // ok to cast an 'id<plist>' expression to CFtype provided plist
3386 // adopts all of CFtype's ObjetiveC's class plist.
3387 return true;
3388 else {
3389 if (warn) {
3390 S.Diag(castExpr->getLocStart(), diag::warn_objc_invalid_bridge_to_cf)
3391 << castExpr->getType() << castType;
3392 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3393 S.Diag(Target->getLocStart(), diag::note_declared_at);
3394 }
3395 return false;
3396 }
3397 }
3398 }
3399 S.Diag(castExpr->getLocStart(), diag::err_objc_ns_bridged_invalid_cfobject)
3400 << castExpr->getType() << castType;
3401 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3402 if (Target)
3403 S.Diag(Target->getLocStart(), diag::note_declared_at);
3404 return true;
3405 }
3406 return false;
3407 }
3408 T = TDNDecl->getUnderlyingType();
3409 }
3410 return true;
3411 }
3412
CheckTollFreeBridgeCast(QualType castType,Expr * castExpr)3413 void Sema::CheckTollFreeBridgeCast(QualType castType, Expr *castExpr) {
3414 if (!getLangOpts().ObjC1)
3415 return;
3416 // warn in presence of __bridge casting to or from a toll free bridge cast.
3417 ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExpr->getType());
3418 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType);
3419 if (castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) {
3420 bool HasObjCBridgeAttr;
3421 bool ObjCBridgeAttrWillNotWarn =
3422 CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3423 false);
3424 if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr)
3425 return;
3426 bool HasObjCBridgeMutableAttr;
3427 bool ObjCBridgeMutableAttrWillNotWarn =
3428 CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3429 HasObjCBridgeMutableAttr, false);
3430 if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr)
3431 return;
3432
3433 if (HasObjCBridgeAttr)
3434 CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3435 true);
3436 else if (HasObjCBridgeMutableAttr)
3437 CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3438 HasObjCBridgeMutableAttr, true);
3439 }
3440 else if (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable) {
3441 bool HasObjCBridgeAttr;
3442 bool ObjCBridgeAttrWillNotWarn =
3443 CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3444 false);
3445 if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr)
3446 return;
3447 bool HasObjCBridgeMutableAttr;
3448 bool ObjCBridgeMutableAttrWillNotWarn =
3449 CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3450 HasObjCBridgeMutableAttr, false);
3451 if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr)
3452 return;
3453
3454 if (HasObjCBridgeAttr)
3455 CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3456 true);
3457 else if (HasObjCBridgeMutableAttr)
3458 CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3459 HasObjCBridgeMutableAttr, true);
3460 }
3461 }
3462
CheckObjCBridgeRelatedCast(QualType castType,Expr * castExpr)3463 void Sema::CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr) {
3464 QualType SrcType = castExpr->getType();
3465 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(castExpr)) {
3466 if (PRE->isExplicitProperty()) {
3467 if (ObjCPropertyDecl *PDecl = PRE->getExplicitProperty())
3468 SrcType = PDecl->getType();
3469 }
3470 else if (PRE->isImplicitProperty()) {
3471 if (ObjCMethodDecl *Getter = PRE->getImplicitPropertyGetter())
3472 SrcType = Getter->getReturnType();
3473
3474 }
3475 }
3476
3477 ARCConversionTypeClass srcExprACTC = classifyTypeForARCConversion(SrcType);
3478 ARCConversionTypeClass castExprACTC = classifyTypeForARCConversion(castType);
3479 if (srcExprACTC != ACTC_retainable || castExprACTC != ACTC_coreFoundation)
3480 return;
3481 CheckObjCBridgeRelatedConversions(castExpr->getLocStart(),
3482 castType, SrcType, castExpr);
3483 return;
3484 }
3485
CheckTollFreeBridgeStaticCast(QualType castType,Expr * castExpr,CastKind & Kind)3486 bool Sema::CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
3487 CastKind &Kind) {
3488 if (!getLangOpts().ObjC1)
3489 return false;
3490 ARCConversionTypeClass exprACTC =
3491 classifyTypeForARCConversion(castExpr->getType());
3492 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType);
3493 if ((castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) ||
3494 (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable)) {
3495 CheckTollFreeBridgeCast(castType, castExpr);
3496 Kind = (castACTC == ACTC_coreFoundation) ? CK_BitCast
3497 : CK_CPointerToObjCPointerCast;
3498 return true;
3499 }
3500 return false;
3501 }
3502
checkObjCBridgeRelatedComponents(SourceLocation Loc,QualType DestType,QualType SrcType,ObjCInterfaceDecl * & RelatedClass,ObjCMethodDecl * & ClassMethod,ObjCMethodDecl * & InstanceMethod,TypedefNameDecl * & TDNDecl,bool CfToNs)3503 bool Sema::checkObjCBridgeRelatedComponents(SourceLocation Loc,
3504 QualType DestType, QualType SrcType,
3505 ObjCInterfaceDecl *&RelatedClass,
3506 ObjCMethodDecl *&ClassMethod,
3507 ObjCMethodDecl *&InstanceMethod,
3508 TypedefNameDecl *&TDNDecl,
3509 bool CfToNs) {
3510 QualType T = CfToNs ? SrcType : DestType;
3511 ObjCBridgeRelatedAttr *ObjCBAttr = ObjCBridgeRelatedAttrFromType(T, TDNDecl);
3512 if (!ObjCBAttr)
3513 return false;
3514
3515 IdentifierInfo *RCId = ObjCBAttr->getRelatedClass();
3516 IdentifierInfo *CMId = ObjCBAttr->getClassMethod();
3517 IdentifierInfo *IMId = ObjCBAttr->getInstanceMethod();
3518 if (!RCId)
3519 return false;
3520 NamedDecl *Target = nullptr;
3521 // Check for an existing type with this name.
3522 LookupResult R(*this, DeclarationName(RCId), SourceLocation(),
3523 Sema::LookupOrdinaryName);
3524 if (!LookupName(R, TUScope)) {
3525 Diag(Loc, diag::err_objc_bridged_related_invalid_class) << RCId
3526 << SrcType << DestType;
3527 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3528 return false;
3529 }
3530 Target = R.getFoundDecl();
3531 if (Target && isa<ObjCInterfaceDecl>(Target))
3532 RelatedClass = cast<ObjCInterfaceDecl>(Target);
3533 else {
3534 Diag(Loc, diag::err_objc_bridged_related_invalid_class_name) << RCId
3535 << SrcType << DestType;
3536 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3537 if (Target)
3538 Diag(Target->getLocStart(), diag::note_declared_at);
3539 return false;
3540 }
3541
3542 // Check for an existing class method with the given selector name.
3543 if (CfToNs && CMId) {
3544 Selector Sel = Context.Selectors.getUnarySelector(CMId);
3545 ClassMethod = RelatedClass->lookupMethod(Sel, false);
3546 if (!ClassMethod) {
3547 Diag(Loc, diag::err_objc_bridged_related_known_method)
3548 << SrcType << DestType << Sel << false;
3549 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3550 return false;
3551 }
3552 }
3553
3554 // Check for an existing instance method with the given selector name.
3555 if (!CfToNs && IMId) {
3556 Selector Sel = Context.Selectors.getNullarySelector(IMId);
3557 InstanceMethod = RelatedClass->lookupMethod(Sel, true);
3558 if (!InstanceMethod) {
3559 Diag(Loc, diag::err_objc_bridged_related_known_method)
3560 << SrcType << DestType << Sel << true;
3561 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3562 return false;
3563 }
3564 }
3565 return true;
3566 }
3567
3568 bool
CheckObjCBridgeRelatedConversions(SourceLocation Loc,QualType DestType,QualType SrcType,Expr * & SrcExpr)3569 Sema::CheckObjCBridgeRelatedConversions(SourceLocation Loc,
3570 QualType DestType, QualType SrcType,
3571 Expr *&SrcExpr) {
3572 ARCConversionTypeClass rhsExprACTC = classifyTypeForARCConversion(SrcType);
3573 ARCConversionTypeClass lhsExprACTC = classifyTypeForARCConversion(DestType);
3574 bool CfToNs = (rhsExprACTC == ACTC_coreFoundation && lhsExprACTC == ACTC_retainable);
3575 bool NsToCf = (rhsExprACTC == ACTC_retainable && lhsExprACTC == ACTC_coreFoundation);
3576 if (!CfToNs && !NsToCf)
3577 return false;
3578
3579 ObjCInterfaceDecl *RelatedClass;
3580 ObjCMethodDecl *ClassMethod = nullptr;
3581 ObjCMethodDecl *InstanceMethod = nullptr;
3582 TypedefNameDecl *TDNDecl = nullptr;
3583 if (!checkObjCBridgeRelatedComponents(Loc, DestType, SrcType, RelatedClass,
3584 ClassMethod, InstanceMethod, TDNDecl, CfToNs))
3585 return false;
3586
3587 if (CfToNs) {
3588 // Implicit conversion from CF to ObjC object is needed.
3589 if (ClassMethod) {
3590 std::string ExpressionString = "[";
3591 ExpressionString += RelatedClass->getNameAsString();
3592 ExpressionString += " ";
3593 ExpressionString += ClassMethod->getSelector().getAsString();
3594 SourceLocation SrcExprEndLoc = PP.getLocForEndOfToken(SrcExpr->getLocEnd());
3595 // Provide a fixit: [RelatedClass ClassMethod SrcExpr]
3596 Diag(Loc, diag::err_objc_bridged_related_known_method)
3597 << SrcType << DestType << ClassMethod->getSelector() << false
3598 << FixItHint::CreateInsertion(SrcExpr->getLocStart(), ExpressionString)
3599 << FixItHint::CreateInsertion(SrcExprEndLoc, "]");
3600 Diag(RelatedClass->getLocStart(), diag::note_declared_at);
3601 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3602
3603 QualType receiverType =
3604 Context.getObjCInterfaceType(RelatedClass);
3605 // Argument.
3606 Expr *args[] = { SrcExpr };
3607 ExprResult msg = BuildClassMessageImplicit(receiverType, false,
3608 ClassMethod->getLocation(),
3609 ClassMethod->getSelector(), ClassMethod,
3610 MultiExprArg(args, 1));
3611 SrcExpr = msg.get();
3612 return true;
3613 }
3614 }
3615 else {
3616 // Implicit conversion from ObjC type to CF object is needed.
3617 if (InstanceMethod) {
3618 std::string ExpressionString;
3619 SourceLocation SrcExprEndLoc = PP.getLocForEndOfToken(SrcExpr->getLocEnd());
3620 if (InstanceMethod->isPropertyAccessor())
3621 if (const ObjCPropertyDecl *PDecl = InstanceMethod->findPropertyDecl()) {
3622 // fixit: ObjectExpr.propertyname when it is aproperty accessor.
3623 ExpressionString = ".";
3624 ExpressionString += PDecl->getNameAsString();
3625 Diag(Loc, diag::err_objc_bridged_related_known_method)
3626 << SrcType << DestType << InstanceMethod->getSelector() << true
3627 << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString);
3628 }
3629 if (ExpressionString.empty()) {
3630 // Provide a fixit: [ObjectExpr InstanceMethod]
3631 ExpressionString = " ";
3632 ExpressionString += InstanceMethod->getSelector().getAsString();
3633 ExpressionString += "]";
3634
3635 Diag(Loc, diag::err_objc_bridged_related_known_method)
3636 << SrcType << DestType << InstanceMethod->getSelector() << true
3637 << FixItHint::CreateInsertion(SrcExpr->getLocStart(), "[")
3638 << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString);
3639 }
3640 Diag(RelatedClass->getLocStart(), diag::note_declared_at);
3641 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3642
3643 ExprResult msg =
3644 BuildInstanceMessageImplicit(SrcExpr, SrcType,
3645 InstanceMethod->getLocation(),
3646 InstanceMethod->getSelector(),
3647 InstanceMethod, None);
3648 SrcExpr = msg.get();
3649 return true;
3650 }
3651 }
3652 return false;
3653 }
3654
3655 Sema::ARCConversionResult
CheckObjCARCConversion(SourceRange castRange,QualType castType,Expr * & castExpr,CheckedConversionKind CCK,bool DiagnoseCFAudited,BinaryOperatorKind Opc)3656 Sema::CheckObjCARCConversion(SourceRange castRange, QualType castType,
3657 Expr *&castExpr, CheckedConversionKind CCK,
3658 bool DiagnoseCFAudited,
3659 BinaryOperatorKind Opc) {
3660 QualType castExprType = castExpr->getType();
3661
3662 // For the purposes of the classification, we assume reference types
3663 // will bind to temporaries.
3664 QualType effCastType = castType;
3665 if (const ReferenceType *ref = castType->getAs<ReferenceType>())
3666 effCastType = ref->getPointeeType();
3667
3668 ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExprType);
3669 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(effCastType);
3670 if (exprACTC == castACTC) {
3671 // check for viablity and report error if casting an rvalue to a
3672 // life-time qualifier.
3673 if ((castACTC == ACTC_retainable) &&
3674 (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) &&
3675 (castType != castExprType)) {
3676 const Type *DT = castType.getTypePtr();
3677 QualType QDT = castType;
3678 // We desugar some types but not others. We ignore those
3679 // that cannot happen in a cast; i.e. auto, and those which
3680 // should not be de-sugared; i.e typedef.
3681 if (const ParenType *PT = dyn_cast<ParenType>(DT))
3682 QDT = PT->desugar();
3683 else if (const TypeOfType *TP = dyn_cast<TypeOfType>(DT))
3684 QDT = TP->desugar();
3685 else if (const AttributedType *AT = dyn_cast<AttributedType>(DT))
3686 QDT = AT->desugar();
3687 if (QDT != castType &&
3688 QDT.getObjCLifetime() != Qualifiers::OCL_None) {
3689 SourceLocation loc =
3690 (castRange.isValid() ? castRange.getBegin()
3691 : castExpr->getExprLoc());
3692 Diag(loc, diag::err_arc_nolifetime_behavior);
3693 }
3694 }
3695 return ACR_okay;
3696 }
3697
3698 if (isAnyCLike(exprACTC) && isAnyCLike(castACTC)) return ACR_okay;
3699
3700 // Allow all of these types to be cast to integer types (but not
3701 // vice-versa).
3702 if (castACTC == ACTC_none && castType->isIntegralType(Context))
3703 return ACR_okay;
3704
3705 // Allow casts between pointers to lifetime types (e.g., __strong id*)
3706 // and pointers to void (e.g., cv void *). Casting from void* to lifetime*
3707 // must be explicit.
3708 if (exprACTC == ACTC_indirectRetainable && castACTC == ACTC_voidPtr)
3709 return ACR_okay;
3710 if (castACTC == ACTC_indirectRetainable && exprACTC == ACTC_voidPtr &&
3711 CCK != CCK_ImplicitConversion)
3712 return ACR_okay;
3713
3714 switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) {
3715 // For invalid casts, fall through.
3716 case ACC_invalid:
3717 break;
3718
3719 // Do nothing for both bottom and +0.
3720 case ACC_bottom:
3721 case ACC_plusZero:
3722 return ACR_okay;
3723
3724 // If the result is +1, consume it here.
3725 case ACC_plusOne:
3726 castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(),
3727 CK_ARCConsumeObject, castExpr,
3728 nullptr, VK_RValue);
3729 ExprNeedsCleanups = true;
3730 return ACR_okay;
3731 }
3732
3733 // If this is a non-implicit cast from id or block type to a
3734 // CoreFoundation type, delay complaining in case the cast is used
3735 // in an acceptable context.
3736 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) &&
3737 CCK != CCK_ImplicitConversion)
3738 return ACR_unbridged;
3739
3740 // Do not issue bridge cast" diagnostic when implicit casting a cstring
3741 // to 'NSString *'. Let caller issue a normal mismatched diagnostic with
3742 // suitable fix-it.
3743 if (castACTC == ACTC_retainable && exprACTC == ACTC_none &&
3744 ConversionToObjCStringLiteralCheck(castType, castExpr))
3745 return ACR_okay;
3746
3747 // Do not issue "bridge cast" diagnostic when implicit casting
3748 // a retainable object to a CF type parameter belonging to an audited
3749 // CF API function. Let caller issue a normal type mismatched diagnostic
3750 // instead.
3751 if (!DiagnoseCFAudited || exprACTC != ACTC_retainable ||
3752 castACTC != ACTC_coreFoundation)
3753 if (!(exprACTC == ACTC_voidPtr && castACTC == ACTC_retainable &&
3754 (Opc == BO_NE || Opc == BO_EQ)))
3755 diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
3756 castExpr, castExpr, exprACTC, CCK);
3757 return ACR_okay;
3758 }
3759
3760 /// Given that we saw an expression with the ARCUnbridgedCastTy
3761 /// placeholder type, complain bitterly.
diagnoseARCUnbridgedCast(Expr * e)3762 void Sema::diagnoseARCUnbridgedCast(Expr *e) {
3763 // We expect the spurious ImplicitCastExpr to already have been stripped.
3764 assert(!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
3765 CastExpr *realCast = cast<CastExpr>(e->IgnoreParens());
3766
3767 SourceRange castRange;
3768 QualType castType;
3769 CheckedConversionKind CCK;
3770
3771 if (CStyleCastExpr *cast = dyn_cast<CStyleCastExpr>(realCast)) {
3772 castRange = SourceRange(cast->getLParenLoc(), cast->getRParenLoc());
3773 castType = cast->getTypeAsWritten();
3774 CCK = CCK_CStyleCast;
3775 } else if (ExplicitCastExpr *cast = dyn_cast<ExplicitCastExpr>(realCast)) {
3776 castRange = cast->getTypeInfoAsWritten()->getTypeLoc().getSourceRange();
3777 castType = cast->getTypeAsWritten();
3778 CCK = CCK_OtherCast;
3779 } else {
3780 castType = cast->getType();
3781 CCK = CCK_ImplicitConversion;
3782 }
3783
3784 ARCConversionTypeClass castACTC =
3785 classifyTypeForARCConversion(castType.getNonReferenceType());
3786
3787 Expr *castExpr = realCast->getSubExpr();
3788 assert(classifyTypeForARCConversion(castExpr->getType()) == ACTC_retainable);
3789
3790 diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
3791 castExpr, realCast, ACTC_retainable, CCK);
3792 }
3793
3794 /// stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast
3795 /// type, remove the placeholder cast.
stripARCUnbridgedCast(Expr * e)3796 Expr *Sema::stripARCUnbridgedCast(Expr *e) {
3797 assert(e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
3798
3799 if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) {
3800 Expr *sub = stripARCUnbridgedCast(pe->getSubExpr());
3801 return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub);
3802 } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) {
3803 assert(uo->getOpcode() == UO_Extension);
3804 Expr *sub = stripARCUnbridgedCast(uo->getSubExpr());
3805 return new (Context) UnaryOperator(sub, UO_Extension, sub->getType(),
3806 sub->getValueKind(), sub->getObjectKind(),
3807 uo->getOperatorLoc());
3808 } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
3809 assert(!gse->isResultDependent());
3810
3811 unsigned n = gse->getNumAssocs();
3812 SmallVector<Expr*, 4> subExprs(n);
3813 SmallVector<TypeSourceInfo*, 4> subTypes(n);
3814 for (unsigned i = 0; i != n; ++i) {
3815 subTypes[i] = gse->getAssocTypeSourceInfo(i);
3816 Expr *sub = gse->getAssocExpr(i);
3817 if (i == gse->getResultIndex())
3818 sub = stripARCUnbridgedCast(sub);
3819 subExprs[i] = sub;
3820 }
3821
3822 return new (Context) GenericSelectionExpr(Context, gse->getGenericLoc(),
3823 gse->getControllingExpr(),
3824 subTypes, subExprs,
3825 gse->getDefaultLoc(),
3826 gse->getRParenLoc(),
3827 gse->containsUnexpandedParameterPack(),
3828 gse->getResultIndex());
3829 } else {
3830 assert(isa<ImplicitCastExpr>(e) && "bad form of unbridged cast!");
3831 return cast<ImplicitCastExpr>(e)->getSubExpr();
3832 }
3833 }
3834
CheckObjCARCUnavailableWeakConversion(QualType castType,QualType exprType)3835 bool Sema::CheckObjCARCUnavailableWeakConversion(QualType castType,
3836 QualType exprType) {
3837 QualType canCastType =
3838 Context.getCanonicalType(castType).getUnqualifiedType();
3839 QualType canExprType =
3840 Context.getCanonicalType(exprType).getUnqualifiedType();
3841 if (isa<ObjCObjectPointerType>(canCastType) &&
3842 castType.getObjCLifetime() == Qualifiers::OCL_Weak &&
3843 canExprType->isObjCObjectPointerType()) {
3844 if (const ObjCObjectPointerType *ObjT =
3845 canExprType->getAs<ObjCObjectPointerType>())
3846 if (const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl())
3847 return !ObjI->isArcWeakrefUnavailable();
3848 }
3849 return true;
3850 }
3851
3852 /// Look for an ObjCReclaimReturnedObject cast and destroy it.
maybeUndoReclaimObject(Expr * e)3853 static Expr *maybeUndoReclaimObject(Expr *e) {
3854 // For now, we just undo operands that are *immediately* reclaim
3855 // expressions, which prevents the vast majority of potential
3856 // problems here. To catch them all, we'd need to rebuild arbitrary
3857 // value-propagating subexpressions --- we can't reliably rebuild
3858 // in-place because of expression sharing.
3859 if (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
3860 if (ice->getCastKind() == CK_ARCReclaimReturnedObject)
3861 return ice->getSubExpr();
3862
3863 return e;
3864 }
3865
BuildObjCBridgedCast(SourceLocation LParenLoc,ObjCBridgeCastKind Kind,SourceLocation BridgeKeywordLoc,TypeSourceInfo * TSInfo,Expr * SubExpr)3866 ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc,
3867 ObjCBridgeCastKind Kind,
3868 SourceLocation BridgeKeywordLoc,
3869 TypeSourceInfo *TSInfo,
3870 Expr *SubExpr) {
3871 ExprResult SubResult = UsualUnaryConversions(SubExpr);
3872 if (SubResult.isInvalid()) return ExprError();
3873 SubExpr = SubResult.get();
3874
3875 QualType T = TSInfo->getType();
3876 QualType FromType = SubExpr->getType();
3877
3878 CastKind CK;
3879
3880 bool MustConsume = false;
3881 if (T->isDependentType() || SubExpr->isTypeDependent()) {
3882 // Okay: we'll build a dependent expression type.
3883 CK = CK_Dependent;
3884 } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {
3885 // Casting CF -> id
3886 CK = (T->isBlockPointerType() ? CK_AnyPointerToBlockPointerCast
3887 : CK_CPointerToObjCPointerCast);
3888 switch (Kind) {
3889 case OBC_Bridge:
3890 break;
3891
3892 case OBC_BridgeRetained: {
3893 bool br = isKnownName("CFBridgingRelease");
3894 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
3895 << 2
3896 << FromType
3897 << (T->isBlockPointerType()? 1 : 0)
3898 << T
3899 << SubExpr->getSourceRange()
3900 << Kind;
3901 Diag(BridgeKeywordLoc, diag::note_arc_bridge)
3902 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge");
3903 Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer)
3904 << FromType << br
3905 << FixItHint::CreateReplacement(BridgeKeywordLoc,
3906 br ? "CFBridgingRelease "
3907 : "__bridge_transfer ");
3908
3909 Kind = OBC_Bridge;
3910 break;
3911 }
3912
3913 case OBC_BridgeTransfer:
3914 // We must consume the Objective-C object produced by the cast.
3915 MustConsume = true;
3916 break;
3917 }
3918 } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {
3919 // Okay: id -> CF
3920 CK = CK_BitCast;
3921 switch (Kind) {
3922 case OBC_Bridge:
3923 // Reclaiming a value that's going to be __bridge-casted to CF
3924 // is very dangerous, so we don't do it.
3925 SubExpr = maybeUndoReclaimObject(SubExpr);
3926 break;
3927
3928 case OBC_BridgeRetained:
3929 // Produce the object before casting it.
3930 SubExpr = ImplicitCastExpr::Create(Context, FromType,
3931 CK_ARCProduceObject,
3932 SubExpr, nullptr, VK_RValue);
3933 break;
3934
3935 case OBC_BridgeTransfer: {
3936 bool br = isKnownName("CFBridgingRetain");
3937 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
3938 << (FromType->isBlockPointerType()? 1 : 0)
3939 << FromType
3940 << 2
3941 << T
3942 << SubExpr->getSourceRange()
3943 << Kind;
3944
3945 Diag(BridgeKeywordLoc, diag::note_arc_bridge)
3946 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge ");
3947 Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained)
3948 << T << br
3949 << FixItHint::CreateReplacement(BridgeKeywordLoc,
3950 br ? "CFBridgingRetain " : "__bridge_retained");
3951
3952 Kind = OBC_Bridge;
3953 break;
3954 }
3955 }
3956 } else {
3957 Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible)
3958 << FromType << T << Kind
3959 << SubExpr->getSourceRange()
3960 << TSInfo->getTypeLoc().getSourceRange();
3961 return ExprError();
3962 }
3963
3964 Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK,
3965 BridgeKeywordLoc,
3966 TSInfo, SubExpr);
3967
3968 if (MustConsume) {
3969 ExprNeedsCleanups = true;
3970 Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result,
3971 nullptr, VK_RValue);
3972 }
3973
3974 return Result;
3975 }
3976
ActOnObjCBridgedCast(Scope * S,SourceLocation LParenLoc,ObjCBridgeCastKind Kind,SourceLocation BridgeKeywordLoc,ParsedType Type,SourceLocation RParenLoc,Expr * SubExpr)3977 ExprResult Sema::ActOnObjCBridgedCast(Scope *S,
3978 SourceLocation LParenLoc,
3979 ObjCBridgeCastKind Kind,
3980 SourceLocation BridgeKeywordLoc,
3981 ParsedType Type,
3982 SourceLocation RParenLoc,
3983 Expr *SubExpr) {
3984 TypeSourceInfo *TSInfo = nullptr;
3985 QualType T = GetTypeFromParser(Type, &TSInfo);
3986 if (Kind == OBC_Bridge)
3987 CheckTollFreeBridgeCast(T, SubExpr);
3988 if (!TSInfo)
3989 TSInfo = Context.getTrivialTypeSourceInfo(T, LParenLoc);
3990 return BuildObjCBridgedCast(LParenLoc, Kind, BridgeKeywordLoc, TSInfo,
3991 SubExpr);
3992 }
3993