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