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