1 //===--- SemaExprObjC.cpp - Semantic Analysis for ObjC Expressions --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis for Objective-C expressions.
12 //===----------------------------------------------------------------------===//
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"
30 using namespace clang;
32 using llvm::makeArrayRef;
34 ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
36 unsigned NumStrings) {
37 StringLiteral **Strings = reinterpret_cast<StringLiteral**>(strings);
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];
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;
51 for (unsigned i = 0; i != NumStrings; ++i) {
54 // ObjC strings can't be wide or UTF.
56 Diag(S->getLocStart(), diag::err_cfstring_literal_not_string_constant)
57 << S->getSourceRange();
62 StrBuf += S->getString();
64 // Get the locations of the string tokens.
65 StrLocs.append(S->tokloc_begin(), S->tokloc_end());
68 // Create the aggregate string with the appropriate content and location
70 S = StringLiteral::Create(Context, StrBuf,
71 StringLiteral::Ascii, /*Pascal=*/false,
72 Context.getPointerType(Context.CharTy),
73 &StrLocs[0], StrLocs.size());
76 return BuildObjCStringLiteral(AtLocs[0], S);
79 ExprResult Sema::BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S){
80 // Verify that this composite string is acceptable for ObjC strings.
81 if (CheckObjCString(S))
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();
90 Ty = Context.getObjCObjectPointerType(Ty);
91 } else if (getLangOpts().NoConstantCFStrings) {
92 IdentifierInfo *NSIdent=0;
93 std::string StringClass(getLangOpts().ObjCConstantStringClass);
95 if (StringClass.empty())
96 NSIdent = &Context.Idents.get("NSConstantString");
98 NSIdent = &Context.Idents.get(StringClass);
100 NamedDecl *IF = LookupSingleName(TUScope, NSIdent, AtLoc,
102 if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) {
103 Context.setObjCConstantStringInterface(StrIF);
104 Ty = Context.getObjCConstantStringInterface();
105 Ty = Context.getObjCObjectPointerType(Ty);
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();
114 IdentifierInfo *NSIdent = NSAPIObj->getNSClassId(NSAPI::ClassId_NSString);
115 NamedDecl *IF = LookupSingleName(TUScope, NSIdent, AtLoc,
117 if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) {
118 Context.setObjCConstantStringInterface(StrIF);
119 Ty = Context.getObjCConstantStringInterface();
120 Ty = Context.getObjCObjectPointerType(Ty);
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();
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);
136 Ty = Context.getObjCObjectPointerType(Ty);
140 return new (Context) ObjCStringLiteral(S, Ty, AtLoc);
143 /// \brief Emits an error if the given method does not exist, or if the return
144 /// type is not an Objective-C object.
145 static bool validateBoxingMethod(Sema &S, SourceLocation Loc,
146 const ObjCInterfaceDecl *Class,
147 Selector Sel, const ObjCMethodDecl *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();
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)
159 S.Diag(Method->getLocation(), diag::note_objc_literal_method_return)
167 /// \brief Retrieve the NSNumber factory method that should be used to create
168 /// an Objective-C literal for the given type.
169 static ObjCMethodDecl *getNSNumberFactoryMethod(Sema &S, SourceLocation Loc,
171 bool isLiteral = false,
172 SourceRange R = SourceRange()) {
173 Optional<NSAPI::NSNumberLiteralMethodKind> Kind =
174 S.NSAPIObj->getNSNumberFactoryMethodKind(NumberType);
178 S.Diag(Loc, diag::err_invalid_nsnumber_type)
184 // If we already looked up this method, we're done.
185 if (S.NSNumberLiteralMethods[*Kind])
186 return S.NSNumberLiteralMethods[*Kind];
188 Selector Sel = S.NSAPIObj->getNSNumberLiteralSelector(*Kind,
191 ASTContext &CX = S.Context;
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());
209 // Otherwise, require a declaration of NSNumber.
210 S.Diag(Loc, diag::err_undeclared_nsnumber);
213 } else if (!S.NSNumberDecl->hasDefinition()) {
214 S.Diag(Loc, diag::err_undeclared_nsnumber);
218 // generate the pointer to NSNumber type.
219 QualType NSNumberObject = CX.getObjCInterfaceType(S.NSNumberDecl);
220 S.NSNumberPointer = CX.getObjCObjectPointerType(NSNumberObject);
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,
231 /*isInstance=*/false, /*isVariadic=*/false,
232 /*isPropertyAccessor=*/false,
233 /*isImplicitlyDeclared=*/true,
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,
242 Method->setMethodParams(S.Context, value, None);
245 if (!validateBoxingMethod(S, Loc, S.NSNumberDecl, Sel, Method))
248 // Note: if the parameter type is out-of-line, we'll catch it later in the
249 // implicit conversion.
251 S.NSNumberLiteralMethods[*Kind] = Method;
255 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
256 /// numeric literal expression. Type of the expression will be "NSNumber *".
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;
268 case CharacterLiteral::Wide:
269 NumberType = Context.getWCharType();
272 case CharacterLiteral::UTF16:
273 NumberType = Context.Char16Ty;
276 case CharacterLiteral::UTF32:
277 NumberType = Context.Char32Ty;
282 // Look for the appropriate method within NSNumber.
283 // Construct the literal.
284 SourceRange NR(Number->getSourceRange());
285 ObjCMethodDecl *Method = getNSNumberFactoryMethod(*this, AtLoc, NumberType,
290 // Convert the number to the type that the parameter expects.
291 ParmVarDecl *ParamDecl = Method->param_begin()[0];
292 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
294 ExprResult ConvertedNumber = PerformCopyInitialization(Entity,
297 if (ConvertedNumber.isInvalid())
299 Number = ConvertedNumber.get();
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())));
307 ExprResult Sema::ActOnObjCBoolLiteral(SourceLocation AtLoc,
308 SourceLocation ValueLoc,
311 if (getLangOpts().CPlusPlus) {
312 Inner = ActOnCXXBoolLiteral(ValueLoc, Value? tok::kw_true : tok::kw_false);
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);
321 return BuildObjCNumericLiteral(AtLoc, Inner.get());
324 /// \brief Check that the given expression is a valid element of an Objective-C
325 /// collection literal.
326 static ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element,
328 // If the expression is type-dependent, there's nothing for us to do.
329 if (Element->isTypeDependent())
332 ExprResult Result = S.CheckPlaceholderExpr(Element);
333 if (Result.isInvalid())
335 Element = Result.get();
337 // In C++, check for an implicit conversion to an Objective-C object pointer
339 if (S.getLangOpts().CPlusPlus && Element->getType()->isRecordType()) {
340 InitializedEntity Entity
341 = InitializedEntity::InitializeParameter(S.Context, T,
343 InitializationKind Kind
344 = InitializationKind::CreateCopy(Element->getLocStart(),
346 InitializationSequence Seq(S, Entity, Kind, Element);
348 return Seq.Perform(S, Entity, Kind, Element);
351 Expr *OrigElement = Element;
353 // Perform lvalue-to-rvalue conversion.
354 Result = S.DefaultLvalueConversion(Element);
355 if (Result.isInvalid())
357 Element = Result.get();
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;
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
376 S.Diag(OrigElement->getLocStart(), diag::err_box_literal_collection)
377 << Which << OrigElement->getSourceRange()
378 << FixItHint::CreateInsertion(OrigElement->getLocStart(), "@");
380 Result = S.BuildObjCNumericLiteral(OrigElement->getLocStart(),
382 if (Result.isInvalid())
385 Element = Result.get();
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(), "@");
396 Result = S.BuildObjCStringLiteral(OrigElement->getLocStart(), String);
397 if (Result.isInvalid())
400 Element = Result.get();
406 S.Diag(Element->getLocStart(), diag::err_invalid_collection_element)
407 << Element->getType();
412 // Make sure that the element has the type that the container factory
414 return S.PerformCopyInitialization(
415 InitializedEntity::InitializeParameter(S.Context, T,
417 Element->getLocStart(), Element);
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);
426 ObjCMethodDecl *BoxingMethod = NULL;
428 // Convert the expression to an RValue, so we can check for pointer types...
429 ExprResult RValue = DefaultFunctionArrayLvalueConversion(ValueExpr);
430 if (RValue.isInvalid()) {
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)) {
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);
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,
452 0, SourceLocation());
454 Diag(SR.getBegin(), diag::err_undeclared_nsstring);
457 } else if (!NSStringDecl->hasDefinition()) {
458 Diag(SR.getBegin(), diag::err_undeclared_nsstring);
461 assert(NSStringDecl && "NSStringDecl should not be NULL");
462 QualType NSStringObject = Context.getObjCInterfaceType(NSStringDecl);
463 NSStringPointer = Context.getObjCObjectPointerType(NSStringObject);
466 if (!StringWithUTF8StringMethod) {
467 IdentifierInfo *II = &Context.Idents.get("stringWithUTF8String");
468 Selector stringWithUTF8String = Context.Selectors.getUnarySelector(II);
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;
476 ObjCMethodDecl::Create(Context, SourceLocation(), SourceLocation(),
477 stringWithUTF8String, NSStringPointer,
478 ResultTInfo, NSStringDecl,
479 /*isInstance=*/false, /*isVariadic=*/false,
480 /*isPropertyAccessor=*/false,
481 /*isImplicitlyDeclared=*/true,
483 ObjCMethodDecl::Required,
484 /*HasRelatedResultType=*/false);
485 QualType ConstCharType = Context.CharTy.withConst();
487 ParmVarDecl::Create(Context, M,
488 SourceLocation(), SourceLocation(),
489 &Context.Idents.get("value"),
490 Context.getPointerType(ConstCharType),
493 M->setMethodParams(Context, value, None);
497 if (!validateBoxingMethod(*this, SR.getBegin(), NSStringDecl,
498 stringWithUTF8String, BoxingMethod))
501 StringWithUTF8StringMethod = BoxingMethod;
504 BoxingMethod = StringWithUTF8StringMethod;
505 BoxedType = NSStringPointer;
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>
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;
523 case CharacterLiteral::Wide:
524 ValueType = Context.getWCharType();
527 case CharacterLiteral::UTF16:
528 ValueType = Context.Char16Ty;
531 case CharacterLiteral::UTF32:
532 ValueType = Context.Char32Ty;
537 // FIXME: Do I need to do anything special with BoolTy expressions?
539 // Look for the appropriate method within NSNumber.
540 BoxingMethod = getNSNumberFactoryMethod(*this, SR.getBegin(), ValueType);
541 BoxedType = NSNumberPointer;
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();
550 BoxingMethod = getNSNumberFactoryMethod(*this, SR.getBegin(),
551 ET->getDecl()->getIntegerType());
552 BoxedType = NSNumberPointer;
556 Diag(SR.getBegin(), diag::err_objc_illegal_boxed_expression_type)
557 << ValueType << ValueExpr->getSourceRange();
561 // Convert the expression to the type that the parameter requires.
562 ParmVarDecl *ParamDecl = BoxingMethod->param_begin()[0];
563 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
565 ExprResult ConvertedValueExpr = PerformCopyInitialization(Entity,
568 if (ConvertedValueExpr.isInvalid())
570 ValueExpr = ConvertedValueExpr.get();
572 ObjCBoxedExpr *BoxedExpr =
573 new (Context) ObjCBoxedExpr(ValueExpr, BoxedType,
575 return MaybeBindToTemporary(BoxedExpr);
578 /// Build an ObjC subscript pseudo-object expression, given that
579 /// that's supported by the runtime.
580 ExprResult Sema::BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
582 ObjCMethodDecl *getterMethod,
583 ObjCMethodDecl *setterMethod) {
584 assert(!LangOpts.ObjCRuntime.isSubscriptPointerArithmetic());
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");
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())
596 IndexExpr = Result.get();
598 // Perform lvalue-to-rvalue conversion on the base.
599 Result = DefaultLvalueConversion(BaseExpr);
600 if (Result.isInvalid())
602 BaseExpr = Result.get();
604 // Build the pseudo-object expression.
605 return Owned(ObjCSubscriptRefExpr::Create(Context,
608 Context.PseudoObjectTy,
614 ExprResult Sema::BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements) {
615 // Look up the NSArray class, if we haven't done so already.
617 NamedDecl *IF = LookupSingleName(TUScope,
618 NSAPIObj->getNSClassId(NSAPI::ClassId_NSArray),
621 NSArrayDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
622 if (!NSArrayDecl && getLangOpts().DebuggerObjCLiteral)
623 NSArrayDecl = ObjCInterfaceDecl::Create (Context,
624 Context.getTranslationUnitDecl(),
626 NSAPIObj->getNSClassId(NSAPI::ClassId_NSArray),
627 0, SourceLocation());
630 Diag(SR.getBegin(), diag::err_undeclared_nsarray);
635 // Find the arrayWithObjects:count: method, if we haven't done so already.
636 QualType IdT = Context.getObjCIdType();
637 if (!ArrayWithObjectsMethod) {
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,
647 Context.getTranslationUnitDecl(),
648 false /*Instance*/, false/*isVariadic*/,
649 /*isPropertyAccessor=*/false,
650 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
651 ObjCMethodDecl::Required,
653 SmallVector<ParmVarDecl *, 2> Params;
654 ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
657 &Context.Idents.get("objects"),
658 Context.getPointerType(IdT),
659 /*TInfo=*/0, SC_None, 0);
660 Params.push_back(objects);
661 ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
664 &Context.Idents.get("cnt"),
665 Context.UnsignedLongTy,
666 /*TInfo=*/0, SC_None, 0);
667 Params.push_back(cnt);
668 Method->setMethodParams(Context, Params, None);
671 if (!validateBoxingMethod(*this, SR.getBegin(), NSArrayDecl, Sel, Method))
674 // Dig out the type that all elements should be converted to.
675 QualType T = Method->param_begin()[0]->getType();
676 const PointerType *PtrT = T->getAs<PointerType>();
678 !Context.hasSameUnqualifiedType(PtrT->getPointeeType(), IdT)) {
679 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
681 Diag(Method->param_begin()[0]->getLocation(),
682 diag::note_objc_literal_method_param)
684 << Context.getPointerType(IdT.withConst());
688 // Check that the 'count' parameter is integral.
689 if (!Method->param_begin()[1]->getType()->isIntegerType()) {
690 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
692 Diag(Method->param_begin()[1]->getLocation(),
693 diag::note_objc_literal_method_param)
695 << Method->param_begin()[1]->getType()
700 // We've found a good +arrayWithObjects:count: method. Save it!
701 ArrayWithObjectsMethod = Method;
704 QualType ObjectsType = ArrayWithObjectsMethod->param_begin()[0]->getType();
705 QualType RequiredType = ObjectsType->castAs<PointerType>()->getPointeeType();
707 // Check that each of the elements provided is valid in a collection literal,
708 // performing conversions as necessary.
709 Expr **ElementsBuffer = Elements.data();
710 for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
711 ExprResult Converted = CheckObjCCollectionLiteralElement(*this,
714 if (Converted.isInvalid())
717 ElementsBuffer[I] = Converted.get();
721 = Context.getObjCObjectPointerType(
722 Context.getObjCInterfaceType(NSArrayDecl));
724 return MaybeBindToTemporary(
725 ObjCArrayLiteral::Create(Context, Elements, Ty,
726 ArrayWithObjectsMethod, SR));
729 ExprResult Sema::BuildObjCDictionaryLiteral(SourceRange SR,
730 ObjCDictionaryElement *Elements,
731 unsigned NumElements) {
732 // Look up the NSDictionary class, if we haven't done so already.
733 if (!NSDictionaryDecl) {
734 NamedDecl *IF = LookupSingleName(TUScope,
735 NSAPIObj->getNSClassId(NSAPI::ClassId_NSDictionary),
736 SR.getBegin(), LookupOrdinaryName);
737 NSDictionaryDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
738 if (!NSDictionaryDecl && getLangOpts().DebuggerObjCLiteral)
739 NSDictionaryDecl = ObjCInterfaceDecl::Create (Context,
740 Context.getTranslationUnitDecl(),
742 NSAPIObj->getNSClassId(NSAPI::ClassId_NSDictionary),
743 0, SourceLocation());
745 if (!NSDictionaryDecl) {
746 Diag(SR.getBegin(), diag::err_undeclared_nsdictionary);
751 // Find the dictionaryWithObjects:forKeys:count: method, if we haven't done
753 QualType IdT = Context.getObjCIdType();
754 if (!DictionaryWithObjectsMethod) {
755 Selector Sel = NSAPIObj->getNSDictionarySelector(
756 NSAPI::NSDict_dictionaryWithObjectsForKeysCount);
757 ObjCMethodDecl *Method = NSDictionaryDecl->lookupClassMethod(Sel);
758 if (!Method && getLangOpts().DebuggerObjCLiteral) {
759 Method = ObjCMethodDecl::Create(Context,
760 SourceLocation(), SourceLocation(), Sel,
762 0 /*TypeSourceInfo */,
763 Context.getTranslationUnitDecl(),
764 false /*Instance*/, false/*isVariadic*/,
765 /*isPropertyAccessor=*/false,
766 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
767 ObjCMethodDecl::Required,
769 SmallVector<ParmVarDecl *, 3> Params;
770 ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
773 &Context.Idents.get("objects"),
774 Context.getPointerType(IdT),
775 /*TInfo=*/0, SC_None, 0);
776 Params.push_back(objects);
777 ParmVarDecl *keys = ParmVarDecl::Create(Context, Method,
780 &Context.Idents.get("keys"),
781 Context.getPointerType(IdT),
782 /*TInfo=*/0, SC_None, 0);
783 Params.push_back(keys);
784 ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
787 &Context.Idents.get("cnt"),
788 Context.UnsignedLongTy,
789 /*TInfo=*/0, SC_None, 0);
790 Params.push_back(cnt);
791 Method->setMethodParams(Context, Params, None);
794 if (!validateBoxingMethod(*this, SR.getBegin(), NSDictionaryDecl, Sel,
798 // Dig out the type that all values should be converted to.
799 QualType ValueT = Method->param_begin()[0]->getType();
800 const PointerType *PtrValue = ValueT->getAs<PointerType>();
802 !Context.hasSameUnqualifiedType(PtrValue->getPointeeType(), IdT)) {
803 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
805 Diag(Method->param_begin()[0]->getLocation(),
806 diag::note_objc_literal_method_param)
808 << Context.getPointerType(IdT.withConst());
812 // Dig out the type that all keys should be converted to.
813 QualType KeyT = Method->param_begin()[1]->getType();
814 const PointerType *PtrKey = KeyT->getAs<PointerType>();
816 !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
820 if (QIDNSCopying.isNull()) {
821 // key argument of selector is id<NSCopying>?
822 if (ObjCProtocolDecl *NSCopyingPDecl =
823 LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) {
824 ObjCProtocolDecl *PQ[] = {NSCopyingPDecl};
826 Context.getObjCObjectType(Context.ObjCBuiltinIdTy,
827 (ObjCProtocolDecl**) PQ,1);
828 QIDNSCopying = Context.getObjCObjectPointerType(QIDNSCopying);
831 if (!QIDNSCopying.isNull())
832 err = !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
837 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
839 Diag(Method->param_begin()[1]->getLocation(),
840 diag::note_objc_literal_method_param)
842 << Context.getPointerType(IdT.withConst());
847 // Check that the 'count' parameter is integral.
848 QualType CountType = Method->param_begin()[2]->getType();
849 if (!CountType->isIntegerType()) {
850 Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
852 Diag(Method->param_begin()[2]->getLocation(),
853 diag::note_objc_literal_method_param)
859 // We've found a good +dictionaryWithObjects:keys:count: method; save it!
860 DictionaryWithObjectsMethod = Method;
863 QualType ValuesT = DictionaryWithObjectsMethod->param_begin()[0]->getType();
864 QualType ValueT = ValuesT->castAs<PointerType>()->getPointeeType();
865 QualType KeysT = DictionaryWithObjectsMethod->param_begin()[1]->getType();
866 QualType KeyT = KeysT->castAs<PointerType>()->getPointeeType();
868 // Check that each of the keys and values provided is valid in a collection
869 // literal, performing conversions as necessary.
870 bool HasPackExpansions = false;
871 for (unsigned I = 0, N = NumElements; I != N; ++I) {
873 ExprResult Key = CheckObjCCollectionLiteralElement(*this, Elements[I].Key,
880 = CheckObjCCollectionLiteralElement(*this, Elements[I].Value, ValueT);
881 if (Value.isInvalid())
884 Elements[I].Key = Key.get();
885 Elements[I].Value = Value.get();
887 if (Elements[I].EllipsisLoc.isInvalid())
890 if (!Elements[I].Key->containsUnexpandedParameterPack() &&
891 !Elements[I].Value->containsUnexpandedParameterPack()) {
892 Diag(Elements[I].EllipsisLoc,
893 diag::err_pack_expansion_without_parameter_packs)
894 << SourceRange(Elements[I].Key->getLocStart(),
895 Elements[I].Value->getLocEnd());
899 HasPackExpansions = true;
904 = Context.getObjCObjectPointerType(
905 Context.getObjCInterfaceType(NSDictionaryDecl));
906 return MaybeBindToTemporary(
907 ObjCDictionaryLiteral::Create(Context,
908 llvm::makeArrayRef(Elements,
912 DictionaryWithObjectsMethod, SR));
915 ExprResult Sema::BuildObjCEncodeExpression(SourceLocation AtLoc,
916 TypeSourceInfo *EncodedTypeInfo,
917 SourceLocation RParenLoc) {
918 QualType EncodedType = EncodedTypeInfo->getType();
920 if (EncodedType->isDependentType())
921 StrTy = Context.DependentTy;
923 if (!EncodedType->getAsArrayTypeUnsafe() && //// Incomplete array is handled.
924 !EncodedType->isVoidType()) // void is handled too.
925 if (RequireCompleteType(AtLoc, EncodedType,
926 diag::err_incomplete_type_objc_at_encode,
927 EncodedTypeInfo->getTypeLoc()))
931 Context.getObjCEncodingForType(EncodedType, Str);
933 // The type of @encode is the same as the type of the corresponding string,
934 // which is an array type.
935 StrTy = Context.CharTy;
936 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
937 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings)
939 StrTy = Context.getConstantArrayType(StrTy, llvm::APInt(32, Str.size()+1),
940 ArrayType::Normal, 0);
943 return new (Context) ObjCEncodeExpr(StrTy, EncodedTypeInfo, AtLoc, RParenLoc);
946 ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc,
947 SourceLocation EncodeLoc,
948 SourceLocation LParenLoc,
950 SourceLocation RParenLoc) {
951 // FIXME: Preserve type source info ?
952 TypeSourceInfo *TInfo;
953 QualType EncodedType = GetTypeFromParser(ty, &TInfo);
955 TInfo = Context.getTrivialTypeSourceInfo(EncodedType,
956 PP.getLocForEndOfToken(LParenLoc));
958 return BuildObjCEncodeExpression(AtLoc, TInfo, RParenLoc);
961 ExprResult Sema::ParseObjCSelectorExpression(Selector Sel,
962 SourceLocation AtLoc,
963 SourceLocation SelLoc,
964 SourceLocation LParenLoc,
965 SourceLocation RParenLoc) {
966 ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel,
967 SourceRange(LParenLoc, RParenLoc), false, false);
969 Method = LookupFactoryMethodInGlobalPool(Sel,
970 SourceRange(LParenLoc, RParenLoc));
972 Diag(SelLoc, diag::warn_undeclared_selector) << Sel;
975 Method->getImplementationControl() != ObjCMethodDecl::Optional) {
976 llvm::DenseMap<Selector, SourceLocation>::iterator Pos
977 = ReferencedSelectors.find(Sel);
978 if (Pos == ReferencedSelectors.end())
979 ReferencedSelectors.insert(std::make_pair(Sel, AtLoc));
982 // In ARC, forbid the user from using @selector for
983 // retain/release/autorelease/dealloc/retainCount.
984 if (getLangOpts().ObjCAutoRefCount) {
985 switch (Sel.getMethodFamily()) {
988 case OMF_autorelease:
989 case OMF_retainCount:
991 Diag(AtLoc, diag::err_arc_illegal_selector) <<
992 Sel << SourceRange(LParenLoc, RParenLoc);
1000 case OMF_mutableCopy:
1003 case OMF_performSelector:
1007 QualType Ty = Context.getObjCSelType();
1008 return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc);
1011 ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
1012 SourceLocation AtLoc,
1013 SourceLocation ProtoLoc,
1014 SourceLocation LParenLoc,
1015 SourceLocation ProtoIdLoc,
1016 SourceLocation RParenLoc) {
1017 ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoIdLoc);
1019 Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;
1023 QualType Ty = Context.getObjCProtoType();
1026 Ty = Context.getObjCObjectPointerType(Ty);
1027 return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, ProtoIdLoc, RParenLoc);
1030 /// Try to capture an implicit reference to 'self'.
1031 ObjCMethodDecl *Sema::tryCaptureObjCSelf(SourceLocation Loc) {
1032 DeclContext *DC = getFunctionLevelDeclContext();
1034 // If we're not in an ObjC method, error out. Note that, unlike the
1035 // C++ case, we don't require an instance method --- class methods
1036 // still have a 'self', and we really do still need to capture it!
1037 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(DC);
1041 tryCaptureVariable(method->getSelfDecl(), Loc);
1046 static QualType stripObjCInstanceType(ASTContext &Context, QualType T) {
1047 if (T == Context.getObjCInstanceType())
1048 return Context.getObjCIdType();
1053 QualType Sema::getMessageSendResultType(QualType ReceiverType,
1054 ObjCMethodDecl *Method,
1055 bool isClassMessage, bool isSuperMessage) {
1056 assert(Method && "Must have a method");
1057 if (!Method->hasRelatedResultType())
1058 return Method->getSendResultType();
1060 // If a method has a related return type:
1061 // - if the method found is an instance method, but the message send
1062 // was a class message send, T is the declared return type of the method
1064 if (Method->isInstanceMethod() && isClassMessage)
1065 return stripObjCInstanceType(Context, Method->getSendResultType());
1067 // - if the receiver is super, T is a pointer to the class of the
1068 // enclosing method definition
1069 if (isSuperMessage) {
1070 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
1071 if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface())
1072 return Context.getObjCObjectPointerType(
1073 Context.getObjCInterfaceType(Class));
1076 // - if the receiver is the name of a class U, T is a pointer to U
1077 if (ReceiverType->getAs<ObjCInterfaceType>() ||
1078 ReceiverType->isObjCQualifiedInterfaceType())
1079 return Context.getObjCObjectPointerType(ReceiverType);
1080 // - if the receiver is of type Class or qualified Class type,
1081 // T is the declared return type of the method.
1082 if (ReceiverType->isObjCClassType() ||
1083 ReceiverType->isObjCQualifiedClassType())
1084 return stripObjCInstanceType(Context, Method->getSendResultType());
1086 // - if the receiver is id, qualified id, Class, or qualified Class, T
1087 // is the receiver type, otherwise
1088 // - T is the type of the receiver expression.
1089 return ReceiverType;
1092 /// Look for an ObjC method whose result type exactly matches the given type.
1093 static const ObjCMethodDecl *
1094 findExplicitInstancetypeDeclarer(const ObjCMethodDecl *MD,
1095 QualType instancetype) {
1096 if (MD->getResultType() == instancetype) return MD;
1098 // For these purposes, a method in an @implementation overrides a
1099 // declaration in the @interface.
1100 if (const ObjCImplDecl *impl =
1101 dyn_cast<ObjCImplDecl>(MD->getDeclContext())) {
1102 const ObjCContainerDecl *iface;
1103 if (const ObjCCategoryImplDecl *catImpl =
1104 dyn_cast<ObjCCategoryImplDecl>(impl)) {
1105 iface = catImpl->getCategoryDecl();
1107 iface = impl->getClassInterface();
1110 const ObjCMethodDecl *ifaceMD =
1111 iface->getMethod(MD->getSelector(), MD->isInstanceMethod());
1112 if (ifaceMD) return findExplicitInstancetypeDeclarer(ifaceMD, instancetype);
1115 SmallVector<const ObjCMethodDecl *, 4> overrides;
1116 MD->getOverriddenMethods(overrides);
1117 for (unsigned i = 0, e = overrides.size(); i != e; ++i) {
1118 if (const ObjCMethodDecl *result =
1119 findExplicitInstancetypeDeclarer(overrides[i], instancetype))
1126 void Sema::EmitRelatedResultTypeNoteForReturn(QualType destType) {
1127 // Only complain if we're in an ObjC method and the required return
1128 // type doesn't match the method's declared return type.
1129 ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurContext);
1130 if (!MD || !MD->hasRelatedResultType() ||
1131 Context.hasSameUnqualifiedType(destType, MD->getResultType()))
1134 // Look for a method overridden by this method which explicitly uses
1136 if (const ObjCMethodDecl *overridden =
1137 findExplicitInstancetypeDeclarer(MD, Context.getObjCInstanceType())) {
1140 if (TypeSourceInfo *TSI = overridden->getResultTypeSourceInfo()) {
1141 range = TSI->getTypeLoc().getSourceRange();
1142 loc = range.getBegin();
1144 if (loc.isInvalid())
1145 loc = overridden->getLocation();
1146 Diag(loc, diag::note_related_result_type_explicit)
1147 << /*current method*/ 1 << range;
1151 // Otherwise, if we have an interesting method family, note that.
1152 // This should always trigger if the above didn't.
1153 if (ObjCMethodFamily family = MD->getMethodFamily())
1154 Diag(MD->getLocation(), diag::note_related_result_type_family)
1155 << /*current method*/ 1
1159 void Sema::EmitRelatedResultTypeNote(const Expr *E) {
1160 E = E->IgnoreParenImpCasts();
1161 const ObjCMessageExpr *MsgSend = dyn_cast<ObjCMessageExpr>(E);
1165 const ObjCMethodDecl *Method = MsgSend->getMethodDecl();
1169 if (!Method->hasRelatedResultType())
1172 if (Context.hasSameUnqualifiedType(Method->getResultType()
1173 .getNonReferenceType(),
1174 MsgSend->getType()))
1177 if (!Context.hasSameUnqualifiedType(Method->getResultType(),
1178 Context.getObjCInstanceType()))
1181 Diag(Method->getLocation(), diag::note_related_result_type_inferred)
1182 << Method->isInstanceMethod() << Method->getSelector()
1183 << MsgSend->getType();
1186 bool Sema::CheckMessageArgumentTypes(QualType ReceiverType,
1187 Expr **Args, unsigned NumArgs,
1189 ArrayRef<SourceLocation> SelectorLocs,
1190 ObjCMethodDecl *Method,
1191 bool isClassMessage, bool isSuperMessage,
1192 SourceLocation lbrac, SourceLocation rbrac,
1193 QualType &ReturnType, ExprValueKind &VK) {
1194 SourceLocation SelLoc;
1195 if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
1196 SelLoc = SelectorLocs.front();
1201 // Apply default argument promotion as for (C99 6.5.2.2p6).
1202 for (unsigned i = 0; i != NumArgs; i++) {
1203 if (Args[i]->isTypeDependent())
1207 if (getLangOpts().DebuggerSupport) {
1208 QualType paramTy; // ignored
1209 result = checkUnknownAnyArg(SelLoc, Args[i], paramTy);
1211 result = DefaultArgumentPromotion(Args[i]);
1213 if (result.isInvalid())
1215 Args[i] = result.take();
1219 if (getLangOpts().ObjCAutoRefCount)
1220 DiagID = diag::err_arc_method_not_found;
1222 DiagID = isClassMessage ? diag::warn_class_method_not_found
1223 : diag::warn_inst_method_not_found;
1224 if (!getLangOpts().DebuggerSupport)
1225 Diag(SelLoc, DiagID)
1226 << Sel << isClassMessage << SourceRange(SelectorLocs.front(),
1227 SelectorLocs.back());
1229 // In debuggers, we want to use __unknown_anytype for these
1230 // results so that clients can cast them.
1231 if (getLangOpts().DebuggerSupport) {
1232 ReturnType = Context.UnknownAnyTy;
1234 ReturnType = Context.getObjCIdType();
1240 ReturnType = getMessageSendResultType(ReceiverType, Method, isClassMessage,
1242 VK = Expr::getValueKindForType(Method->getResultType());
1244 unsigned NumNamedArgs = Sel.getNumArgs();
1245 // Method might have more arguments than selector indicates. This is due
1246 // to addition of c-style arguments in method.
1247 if (Method->param_size() > Sel.getNumArgs())
1248 NumNamedArgs = Method->param_size();
1249 // FIXME. This need be cleaned up.
1250 if (NumArgs < NumNamedArgs) {
1251 Diag(SelLoc, diag::err_typecheck_call_too_few_args)
1252 << 2 << NumNamedArgs << NumArgs;
1256 bool IsError = false;
1257 for (unsigned i = 0; i < NumNamedArgs; i++) {
1258 // We can't do any type-checking on a type-dependent argument.
1259 if (Args[i]->isTypeDependent())
1262 Expr *argExpr = Args[i];
1264 ParmVarDecl *param = Method->param_begin()[i];
1265 assert(argExpr && "CheckMessageArgumentTypes(): missing expression");
1267 // Strip the unbridged-cast placeholder expression off unless it's
1268 // a consumed argument.
1269 if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
1270 !param->hasAttr<CFConsumedAttr>())
1271 argExpr = stripARCUnbridgedCast(argExpr);
1273 // If the parameter is __unknown_anytype, infer its type
1274 // from the argument.
1275 if (param->getType() == Context.UnknownAnyTy) {
1277 ExprResult argE = checkUnknownAnyArg(SelLoc, argExpr, paramType);
1278 if (argE.isInvalid()) {
1281 Args[i] = argE.take();
1283 // Update the parameter type in-place.
1284 param->setType(paramType);
1289 if (RequireCompleteType(argExpr->getSourceRange().getBegin(),
1291 diag::err_call_incomplete_argument, argExpr))
1294 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
1296 ExprResult ArgE = PerformCopyInitialization(Entity, SelLoc, Owned(argExpr));
1297 if (ArgE.isInvalid())
1300 Args[i] = ArgE.takeAs<Expr>();
1303 // Promote additional arguments to variadic methods.
1304 if (Method->isVariadic()) {
1305 for (unsigned i = NumNamedArgs; i < NumArgs; ++i) {
1306 if (Args[i]->isTypeDependent())
1309 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
1311 IsError |= Arg.isInvalid();
1312 Args[i] = Arg.take();
1315 // Check for extra arguments to non-variadic methods.
1316 if (NumArgs != NumNamedArgs) {
1317 Diag(Args[NumNamedArgs]->getLocStart(),
1318 diag::err_typecheck_call_too_many_args)
1319 << 2 /*method*/ << NumNamedArgs << NumArgs
1320 << Method->getSourceRange()
1321 << SourceRange(Args[NumNamedArgs]->getLocStart(),
1322 Args[NumArgs-1]->getLocEnd());
1326 DiagnoseSentinelCalls(Method, SelLoc, Args, NumArgs);
1328 // Do additional checkings on method.
1329 IsError |= CheckObjCMethodCall(Method, SelLoc,
1330 llvm::makeArrayRef<const Expr *>(Args, NumArgs));
1335 bool Sema::isSelfExpr(Expr *receiver) {
1336 // 'self' is objc 'self' in an objc method only.
1337 ObjCMethodDecl *method =
1338 dyn_cast_or_null<ObjCMethodDecl>(CurContext->getNonClosureAncestor());
1339 if (!method) return false;
1341 receiver = receiver->IgnoreParenLValueCasts();
1342 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(receiver))
1343 if (DRE->getDecl() == method->getSelfDecl())
1348 /// LookupMethodInType - Look up a method in an ObjCObjectType.
1349 ObjCMethodDecl *Sema::LookupMethodInObjectType(Selector sel, QualType type,
1351 const ObjCObjectType *objType = type->castAs<ObjCObjectType>();
1352 if (ObjCInterfaceDecl *iface = objType->getInterface()) {
1353 // Look it up in the main interface (and categories, etc.)
1354 if (ObjCMethodDecl *method = iface->lookupMethod(sel, isInstance))
1357 // Okay, look for "private" methods declared in any
1358 // @implementations we've seen.
1359 if (ObjCMethodDecl *method = iface->lookupPrivateMethod(sel, isInstance))
1363 // Check qualifiers.
1364 for (ObjCObjectType::qual_iterator
1365 i = objType->qual_begin(), e = objType->qual_end(); i != e; ++i)
1366 if (ObjCMethodDecl *method = (*i)->lookupMethod(sel, isInstance))
1372 /// LookupMethodInQualifiedType - Lookups up a method in protocol qualifier
1373 /// list of a qualified objective pointer type.
1374 ObjCMethodDecl *Sema::LookupMethodInQualifiedType(Selector Sel,
1375 const ObjCObjectPointerType *OPT,
1378 ObjCMethodDecl *MD = 0;
1379 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
1380 E = OPT->qual_end(); I != E; ++I) {
1381 ObjCProtocolDecl *PROTO = (*I);
1382 if ((MD = PROTO->lookupMethod(Sel, Instance))) {
1389 static void DiagnoseARCUseOfWeakReceiver(Sema &S, Expr *Receiver) {
1393 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Receiver))
1394 Receiver = OVE->getSourceExpr();
1396 Expr *RExpr = Receiver->IgnoreParenImpCasts();
1397 SourceLocation Loc = RExpr->getLocStart();
1398 QualType T = RExpr->getType();
1399 const ObjCPropertyDecl *PDecl = 0;
1400 const ObjCMethodDecl *GDecl = 0;
1401 if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(RExpr)) {
1402 RExpr = POE->getSyntacticForm();
1403 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(RExpr)) {
1404 if (PRE->isImplicitProperty()) {
1405 GDecl = PRE->getImplicitPropertyGetter();
1407 T = GDecl->getResultType();
1411 PDecl = PRE->getExplicitProperty();
1413 T = PDecl->getType();
1418 else if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(RExpr)) {
1419 // See if receiver is a method which envokes a synthesized getter
1420 // backing a 'weak' property.
1421 ObjCMethodDecl *Method = ME->getMethodDecl();
1422 if (Method && Method->getSelector().getNumArgs() == 0) {
1423 PDecl = Method->findPropertyDecl();
1425 T = PDecl->getType();
1429 if (T.getObjCLifetime() != Qualifiers::OCL_Weak) {
1432 if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak))
1436 S.Diag(Loc, diag::warn_receiver_is_weak)
1437 << ((!PDecl && !GDecl) ? 0 : (PDecl ? 1 : 2));
1440 S.Diag(PDecl->getLocation(), diag::note_property_declare);
1442 S.Diag(GDecl->getLocation(), diag::note_method_declared_at) << GDecl;
1444 S.Diag(Loc, diag::note_arc_assign_to_strong);
1447 /// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an
1448 /// objective C interface. This is a property reference expression.
1450 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
1451 Expr *BaseExpr, SourceLocation OpLoc,
1452 DeclarationName MemberName,
1453 SourceLocation MemberLoc,
1454 SourceLocation SuperLoc, QualType SuperType,
1456 const ObjCInterfaceType *IFaceT = OPT->getInterfaceType();
1457 ObjCInterfaceDecl *IFace = IFaceT->getDecl();
1459 if (!MemberName.isIdentifier()) {
1460 Diag(MemberLoc, diag::err_invalid_property_name)
1461 << MemberName << QualType(OPT, 0);
1465 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1467 SourceRange BaseRange = Super? SourceRange(SuperLoc)
1468 : BaseExpr->getSourceRange();
1469 if (RequireCompleteType(MemberLoc, OPT->getPointeeType(),
1470 diag::err_property_not_found_forward_class,
1471 MemberName, BaseRange))
1474 // Search for a declared property first.
1475 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Member)) {
1476 // Check whether we can reference this property.
1477 if (DiagnoseUseOfDecl(PD, MemberLoc))
1480 return Owned(new (Context) ObjCPropertyRefExpr(PD, Context.PseudoObjectTy,
1481 VK_LValue, OK_ObjCProperty,
1483 SuperLoc, SuperType));
1485 return Owned(new (Context) ObjCPropertyRefExpr(PD, Context.PseudoObjectTy,
1486 VK_LValue, OK_ObjCProperty,
1487 MemberLoc, BaseExpr));
1489 // Check protocols on qualified interfaces.
1490 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
1491 E = OPT->qual_end(); I != E; ++I)
1492 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) {
1493 // Check whether we can reference this property.
1494 if (DiagnoseUseOfDecl(PD, MemberLoc))
1498 return Owned(new (Context) ObjCPropertyRefExpr(PD,
1499 Context.PseudoObjectTy,
1503 SuperLoc, SuperType));
1505 return Owned(new (Context) ObjCPropertyRefExpr(PD,
1506 Context.PseudoObjectTy,
1512 // If that failed, look for an "implicit" property by seeing if the nullary
1513 // selector is implemented.
1515 // FIXME: The logic for looking up nullary and unary selectors should be
1516 // shared with the code in ActOnInstanceMessage.
1518 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
1519 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
1521 // May be founf in property's qualified list.
1523 Getter = LookupMethodInQualifiedType(Sel, OPT, true);
1525 // If this reference is in an @implementation, check for 'private' methods.
1527 Getter = IFace->lookupPrivateMethod(Sel);
1530 // Check if we can reference this property.
1531 if (DiagnoseUseOfDecl(Getter, MemberLoc))
1534 // If we found a getter then this may be a valid dot-reference, we
1535 // will look for the matching setter, in case it is needed.
1536 Selector SetterSel =
1537 SelectorTable::constructSetterName(PP.getIdentifierTable(),
1538 PP.getSelectorTable(), Member);
1539 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
1541 // May be founf in property's qualified list.
1543 Setter = LookupMethodInQualifiedType(SetterSel, OPT, true);
1546 // If this reference is in an @implementation, also check for 'private'
1548 Setter = IFace->lookupPrivateMethod(SetterSel);
1551 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
1554 if (Getter || Setter) {
1556 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1557 Context.PseudoObjectTy,
1558 VK_LValue, OK_ObjCProperty,
1560 SuperLoc, SuperType));
1562 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1563 Context.PseudoObjectTy,
1564 VK_LValue, OK_ObjCProperty,
1565 MemberLoc, BaseExpr));
1569 // Attempt to correct for typos in property names.
1570 DeclFilterCCC<ObjCPropertyDecl> Validator;
1571 if (TypoCorrection Corrected = CorrectTypo(
1572 DeclarationNameInfo(MemberName, MemberLoc), LookupOrdinaryName, NULL,
1573 NULL, Validator, IFace, false, OPT)) {
1574 ObjCPropertyDecl *Property =
1575 Corrected.getCorrectionDeclAs<ObjCPropertyDecl>();
1576 DeclarationName TypoResult = Corrected.getCorrection();
1577 Diag(MemberLoc, diag::err_property_not_found_suggest)
1578 << MemberName << QualType(OPT, 0) << TypoResult
1579 << FixItHint::CreateReplacement(MemberLoc, TypoResult.getAsString());
1580 Diag(Property->getLocation(), diag::note_previous_decl)
1581 << Property->getDeclName();
1582 return HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc,
1583 TypoResult, MemberLoc,
1584 SuperLoc, SuperType, Super);
1586 ObjCInterfaceDecl *ClassDeclared;
1587 if (ObjCIvarDecl *Ivar =
1588 IFace->lookupInstanceVariable(Member, ClassDeclared)) {
1589 QualType T = Ivar->getType();
1590 if (const ObjCObjectPointerType * OBJPT =
1591 T->getAsObjCInterfacePointerType()) {
1592 if (RequireCompleteType(MemberLoc, OBJPT->getPointeeType(),
1593 diag::err_property_not_as_forward_class,
1594 MemberName, BaseExpr))
1598 diag::err_ivar_access_using_property_syntax_suggest)
1599 << MemberName << QualType(OPT, 0) << Ivar->getDeclName()
1600 << FixItHint::CreateReplacement(OpLoc, "->");
1604 Diag(MemberLoc, diag::err_property_not_found)
1605 << MemberName << QualType(OPT, 0);
1607 Diag(Setter->getLocation(), diag::note_getter_unavailable)
1608 << MemberName << BaseExpr->getSourceRange();
1615 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
1616 IdentifierInfo &propertyName,
1617 SourceLocation receiverNameLoc,
1618 SourceLocation propertyNameLoc) {
1620 IdentifierInfo *receiverNamePtr = &receiverName;
1621 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(receiverNamePtr,
1624 bool IsSuper = false;
1626 // If the "receiver" is 'super' in a method, handle it as an expression-like
1627 // property reference.
1628 if (receiverNamePtr->isStr("super")) {
1631 if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) {
1632 if (CurMethod->isInstanceMethod()) {
1633 ObjCInterfaceDecl *Super =
1634 CurMethod->getClassInterface()->getSuperClass();
1636 // The current class does not have a superclass.
1637 Diag(receiverNameLoc, diag::error_root_class_cannot_use_super)
1638 << CurMethod->getClassInterface()->getIdentifier();
1641 QualType T = Context.getObjCInterfaceType(Super);
1642 T = Context.getObjCObjectPointerType(T);
1644 return HandleExprPropertyRefExpr(T->getAsObjCInterfacePointerType(),
1646 SourceLocation()/*OpLoc*/,
1649 receiverNameLoc, T, true);
1652 // Otherwise, if this is a class method, try dispatching to our
1654 IFace = CurMethod->getClassInterface()->getSuperClass();
1659 Diag(receiverNameLoc, diag::err_expected_ident_or_lparen);
1664 // Search for a declared property first.
1665 Selector Sel = PP.getSelectorTable().getNullarySelector(&propertyName);
1666 ObjCMethodDecl *Getter = IFace->lookupClassMethod(Sel);
1668 // If this reference is in an @implementation, check for 'private' methods.
1670 if (ObjCMethodDecl *CurMeth = getCurMethodDecl())
1671 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
1672 if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation())
1673 Getter = ImpDecl->getClassMethod(Sel);
1676 // FIXME: refactor/share with ActOnMemberReference().
1677 // Check if we can reference this property.
1678 if (DiagnoseUseOfDecl(Getter, propertyNameLoc))
1682 // Look for the matching setter, in case it is needed.
1683 Selector SetterSel =
1684 SelectorTable::constructSetterName(PP.getIdentifierTable(),
1685 PP.getSelectorTable(), &propertyName);
1687 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1689 // If this reference is in an @implementation, also check for 'private'
1691 if (ObjCMethodDecl *CurMeth = getCurMethodDecl())
1692 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
1693 if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation())
1694 Setter = ImpDecl->getClassMethod(SetterSel);
1696 // Look through local category implementations associated with the class.
1698 Setter = IFace->getCategoryClassMethod(SetterSel);
1700 if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc))
1703 if (Getter || Setter) {
1705 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1706 Context.PseudoObjectTy,
1707 VK_LValue, OK_ObjCProperty,
1710 Context.getObjCInterfaceType(IFace)));
1712 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1713 Context.PseudoObjectTy,
1714 VK_LValue, OK_ObjCProperty,
1716 receiverNameLoc, IFace));
1718 return ExprError(Diag(propertyNameLoc, diag::err_property_not_found)
1719 << &propertyName << Context.getObjCInterfaceType(IFace));
1724 class ObjCInterfaceOrSuperCCC : public CorrectionCandidateCallback {
1726 ObjCInterfaceOrSuperCCC(ObjCMethodDecl *Method) {
1727 // Determine whether "super" is acceptable in the current context.
1728 if (Method && Method->getClassInterface())
1729 WantObjCSuper = Method->getClassInterface()->getSuperClass();
1732 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
1733 return candidate.getCorrectionDeclAs<ObjCInterfaceDecl>() ||
1734 candidate.isKeyword("super");
1740 Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S,
1741 IdentifierInfo *Name,
1742 SourceLocation NameLoc,
1744 bool HasTrailingDot,
1745 ParsedType &ReceiverType) {
1746 ReceiverType = ParsedType();
1748 // If the identifier is "super" and there is no trailing dot, we're
1749 // messaging super. If the identifier is "super" and there is a
1750 // trailing dot, it's an instance message.
1751 if (IsSuper && S->isInObjcMethodScope())
1752 return HasTrailingDot? ObjCInstanceMessage : ObjCSuperMessage;
1754 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
1755 LookupName(Result, S);
1757 switch (Result.getResultKind()) {
1758 case LookupResult::NotFound:
1759 // Normal name lookup didn't find anything. If we're in an
1760 // Objective-C method, look for ivars. If we find one, we're done!
1761 // FIXME: This is a hack. Ivar lookup should be part of normal
1763 if (ObjCMethodDecl *Method = getCurMethodDecl()) {
1764 if (!Method->getClassInterface()) {
1765 // Fall back: let the parser try to parse it as an instance message.
1766 return ObjCInstanceMessage;
1769 ObjCInterfaceDecl *ClassDeclared;
1770 if (Method->getClassInterface()->lookupInstanceVariable(Name,
1772 return ObjCInstanceMessage;
1775 // Break out; we'll perform typo correction below.
1778 case LookupResult::NotFoundInCurrentInstantiation:
1779 case LookupResult::FoundOverloaded:
1780 case LookupResult::FoundUnresolvedValue:
1781 case LookupResult::Ambiguous:
1782 Result.suppressDiagnostics();
1783 return ObjCInstanceMessage;
1785 case LookupResult::Found: {
1786 // If the identifier is a class or not, and there is a trailing dot,
1787 // it's an instance message.
1789 return ObjCInstanceMessage;
1790 // We found something. If it's a type, then we have a class
1791 // message. Otherwise, it's an instance message.
1792 NamedDecl *ND = Result.getFoundDecl();
1794 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(ND))
1795 T = Context.getObjCInterfaceType(Class);
1796 else if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) {
1797 T = Context.getTypeDeclType(Type);
1798 DiagnoseUseOfDecl(Type, NameLoc);
1801 return ObjCInstanceMessage;
1803 // We have a class message, and T is the type we're
1804 // messaging. Build source-location information for it.
1805 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
1806 ReceiverType = CreateParsedType(T, TSInfo);
1807 return ObjCClassMessage;
1811 ObjCInterfaceOrSuperCCC Validator(getCurMethodDecl());
1812 if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
1813 Result.getLookupKind(), S, NULL,
1815 if (Corrected.isKeyword()) {
1816 // If we've found the keyword "super" (the only keyword that would be
1817 // returned by CorrectTypo), this is a send to super.
1818 Diag(NameLoc, diag::err_unknown_receiver_suggest)
1819 << Name << Corrected.getCorrection()
1820 << FixItHint::CreateReplacement(SourceRange(NameLoc), "super");
1821 return ObjCSuperMessage;
1822 } else if (ObjCInterfaceDecl *Class =
1823 Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
1824 // If we found a declaration, correct when it refers to an Objective-C
1826 Diag(NameLoc, diag::err_unknown_receiver_suggest)
1827 << Name << Corrected.getCorrection()
1828 << FixItHint::CreateReplacement(SourceRange(NameLoc),
1829 Class->getNameAsString());
1830 Diag(Class->getLocation(), diag::note_previous_decl)
1831 << Corrected.getCorrection();
1833 QualType T = Context.getObjCInterfaceType(Class);
1834 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
1835 ReceiverType = CreateParsedType(T, TSInfo);
1836 return ObjCClassMessage;
1840 // Fall back: let the parser try to parse it as an instance message.
1841 return ObjCInstanceMessage;
1844 ExprResult Sema::ActOnSuperMessage(Scope *S,
1845 SourceLocation SuperLoc,
1847 SourceLocation LBracLoc,
1848 ArrayRef<SourceLocation> SelectorLocs,
1849 SourceLocation RBracLoc,
1850 MultiExprArg Args) {
1851 // Determine whether we are inside a method or not.
1852 ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc);
1854 Diag(SuperLoc, diag::err_invalid_receiver_to_message_super);
1858 ObjCInterfaceDecl *Class = Method->getClassInterface();
1860 Diag(SuperLoc, diag::error_no_super_class_message)
1861 << Method->getDeclName();
1865 ObjCInterfaceDecl *Super = Class->getSuperClass();
1867 // The current class does not have a superclass.
1868 Diag(SuperLoc, diag::error_root_class_cannot_use_super)
1869 << Class->getIdentifier();
1873 // We are in a method whose class has a superclass, so 'super'
1874 // is acting as a keyword.
1875 if (Method->getSelector() == Sel)
1876 getCurFunction()->ObjCShouldCallSuper = false;
1878 if (Method->isInstanceMethod()) {
1879 // Since we are in an instance method, this is an instance
1880 // message to the superclass instance.
1881 QualType SuperTy = Context.getObjCInterfaceType(Super);
1882 SuperTy = Context.getObjCObjectPointerType(SuperTy);
1883 return BuildInstanceMessage(0, SuperTy, SuperLoc,
1885 LBracLoc, SelectorLocs, RBracLoc, Args);
1888 // Since we are in a class method, this is a class message to
1890 return BuildClassMessage(/*ReceiverTypeInfo=*/0,
1891 Context.getObjCInterfaceType(Super),
1892 SuperLoc, Sel, /*Method=*/0,
1893 LBracLoc, SelectorLocs, RBracLoc, Args);
1897 ExprResult Sema::BuildClassMessageImplicit(QualType ReceiverType,
1898 bool isSuperReceiver,
1901 ObjCMethodDecl *Method,
1902 MultiExprArg Args) {
1903 TypeSourceInfo *receiverTypeInfo = 0;
1904 if (!ReceiverType.isNull())
1905 receiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType);
1907 return BuildClassMessage(receiverTypeInfo, ReceiverType,
1908 /*SuperLoc=*/isSuperReceiver ? Loc : SourceLocation(),
1909 Sel, Method, Loc, Loc, Loc, Args,
1910 /*isImplicit=*/true);
1914 static void applyCocoaAPICheck(Sema &S, const ObjCMessageExpr *Msg,
1916 bool (*refactor)(const ObjCMessageExpr *,
1917 const NSAPI &, edit::Commit &)) {
1918 SourceLocation MsgLoc = Msg->getExprLoc();
1919 if (S.Diags.getDiagnosticLevel(DiagID, MsgLoc) == DiagnosticsEngine::Ignored)
1922 SourceManager &SM = S.SourceMgr;
1923 edit::Commit ECommit(SM, S.LangOpts);
1924 if (refactor(Msg,*S.NSAPIObj, ECommit)) {
1925 DiagnosticBuilder Builder = S.Diag(MsgLoc, DiagID)
1926 << Msg->getSelector() << Msg->getSourceRange();
1927 // FIXME: Don't emit diagnostic at all if fixits are non-commitable.
1928 if (!ECommit.isCommitable())
1930 for (edit::Commit::edit_iterator
1931 I = ECommit.edit_begin(), E = ECommit.edit_end(); I != E; ++I) {
1932 const edit::Commit::Edit &Edit = *I;
1933 switch (Edit.Kind) {
1934 case edit::Commit::Act_Insert:
1935 Builder.AddFixItHint(FixItHint::CreateInsertion(Edit.OrigLoc,
1939 case edit::Commit::Act_InsertFromRange:
1940 Builder.AddFixItHint(
1941 FixItHint::CreateInsertionFromRange(Edit.OrigLoc,
1942 Edit.getInsertFromRange(SM),
1945 case edit::Commit::Act_Remove:
1946 Builder.AddFixItHint(FixItHint::CreateRemoval(Edit.getFileRange(SM)));
1953 static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) {
1954 applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use,
1955 edit::rewriteObjCRedundantCallWithLiteral);
1958 /// \brief Build an Objective-C class message expression.
1960 /// This routine takes care of both normal class messages and
1961 /// class messages to the superclass.
1963 /// \param ReceiverTypeInfo Type source information that describes the
1964 /// receiver of this message. This may be NULL, in which case we are
1965 /// sending to the superclass and \p SuperLoc must be a valid source
1968 /// \param ReceiverType The type of the object receiving the
1969 /// message. When \p ReceiverTypeInfo is non-NULL, this is the same
1970 /// type as that refers to. For a superclass send, this is the type of
1973 /// \param SuperLoc The location of the "super" keyword in a
1974 /// superclass message.
1976 /// \param Sel The selector to which the message is being sent.
1978 /// \param Method The method that this class message is invoking, if
1981 /// \param LBracLoc The location of the opening square bracket ']'.
1983 /// \param RBracLoc The location of the closing square bracket ']'.
1985 /// \param ArgsIn The message arguments.
1986 ExprResult Sema::BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
1987 QualType ReceiverType,
1988 SourceLocation SuperLoc,
1990 ObjCMethodDecl *Method,
1991 SourceLocation LBracLoc,
1992 ArrayRef<SourceLocation> SelectorLocs,
1993 SourceLocation RBracLoc,
1994 MultiExprArg ArgsIn,
1996 SourceLocation Loc = SuperLoc.isValid()? SuperLoc
1997 : ReceiverTypeInfo->getTypeLoc().getSourceRange().getBegin();
1998 if (LBracLoc.isInvalid()) {
1999 Diag(Loc, diag::err_missing_open_square_message_send)
2000 << FixItHint::CreateInsertion(Loc, "[");
2003 SourceLocation SelLoc;
2004 if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2005 SelLoc = SelectorLocs.front();
2009 if (ReceiverType->isDependentType()) {
2010 // If the receiver type is dependent, we can't type-check anything
2011 // at this point. Build a dependent expression.
2012 unsigned NumArgs = ArgsIn.size();
2013 Expr **Args = ArgsIn.data();
2014 assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2015 return Owned(ObjCMessageExpr::Create(Context, ReceiverType,
2016 VK_RValue, LBracLoc, ReceiverTypeInfo,
2017 Sel, SelectorLocs, /*Method=*/0,
2018 makeArrayRef(Args, NumArgs),RBracLoc,
2022 // Find the class to which we are sending this message.
2023 ObjCInterfaceDecl *Class = 0;
2024 const ObjCObjectType *ClassType = ReceiverType->getAs<ObjCObjectType>();
2025 if (!ClassType || !(Class = ClassType->getInterface())) {
2026 Diag(Loc, diag::err_invalid_receiver_class_message)
2030 assert(Class && "We don't know which class we're messaging?");
2031 // objc++ diagnoses during typename annotation.
2032 if (!getLangOpts().CPlusPlus)
2033 (void)DiagnoseUseOfDecl(Class, SelLoc);
2034 // Find the method we are messaging.
2036 SourceRange TypeRange
2037 = SuperLoc.isValid()? SourceRange(SuperLoc)
2038 : ReceiverTypeInfo->getTypeLoc().getSourceRange();
2039 if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class),
2040 (getLangOpts().ObjCAutoRefCount
2041 ? diag::err_arc_receiver_forward_class
2042 : diag::warn_receiver_forward_class),
2044 // A forward class used in messaging is treated as a 'Class'
2045 Method = LookupFactoryMethodInGlobalPool(Sel,
2046 SourceRange(LBracLoc, RBracLoc));
2047 if (Method && !getLangOpts().ObjCAutoRefCount)
2048 Diag(Method->getLocation(), diag::note_method_sent_forward_class)
2049 << Method->getDeclName();
2052 Method = Class->lookupClassMethod(Sel);
2054 // If we have an implementation in scope, check "private" methods.
2056 Method = Class->lookupPrivateClassMethod(Sel);
2058 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2062 // Check the argument types and determine the result type.
2063 QualType ReturnType;
2064 ExprValueKind VK = VK_RValue;
2066 unsigned NumArgs = ArgsIn.size();
2067 Expr **Args = ArgsIn.data();
2068 if (CheckMessageArgumentTypes(ReceiverType, Args, NumArgs, Sel, SelectorLocs,
2070 SuperLoc.isValid(), LBracLoc, RBracLoc,
2074 if (Method && !Method->getResultType()->isVoidType() &&
2075 RequireCompleteType(LBracLoc, Method->getResultType(),
2076 diag::err_illegal_message_expr_incomplete_type))
2079 // Construct the appropriate ObjCMessageExpr.
2080 ObjCMessageExpr *Result;
2081 if (SuperLoc.isValid())
2082 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2083 SuperLoc, /*IsInstanceSuper=*/false,
2084 ReceiverType, Sel, SelectorLocs,
2085 Method, makeArrayRef(Args, NumArgs),
2086 RBracLoc, isImplicit);
2088 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2089 ReceiverTypeInfo, Sel, SelectorLocs,
2090 Method, makeArrayRef(Args, NumArgs),
2091 RBracLoc, isImplicit);
2093 checkCocoaAPI(*this, Result);
2095 return MaybeBindToTemporary(Result);
2098 // ActOnClassMessage - used for both unary and keyword messages.
2099 // ArgExprs is optional - if it is present, the number of expressions
2100 // is obtained from Sel.getNumArgs().
2101 ExprResult Sema::ActOnClassMessage(Scope *S,
2102 ParsedType Receiver,
2104 SourceLocation LBracLoc,
2105 ArrayRef<SourceLocation> SelectorLocs,
2106 SourceLocation RBracLoc,
2107 MultiExprArg Args) {
2108 TypeSourceInfo *ReceiverTypeInfo;
2109 QualType ReceiverType = GetTypeFromParser(Receiver, &ReceiverTypeInfo);
2110 if (ReceiverType.isNull())
2114 if (!ReceiverTypeInfo)
2115 ReceiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType, LBracLoc);
2117 return BuildClassMessage(ReceiverTypeInfo, ReceiverType,
2118 /*SuperLoc=*/SourceLocation(), Sel, /*Method=*/0,
2119 LBracLoc, SelectorLocs, RBracLoc, Args);
2122 ExprResult Sema::BuildInstanceMessageImplicit(Expr *Receiver,
2123 QualType ReceiverType,
2126 ObjCMethodDecl *Method,
2127 MultiExprArg Args) {
2128 return BuildInstanceMessage(Receiver, ReceiverType,
2129 /*SuperLoc=*/!Receiver ? Loc : SourceLocation(),
2130 Sel, Method, Loc, Loc, Loc, Args,
2131 /*isImplicit=*/true);
2134 /// \brief Build an Objective-C instance message expression.
2136 /// This routine takes care of both normal instance messages and
2137 /// instance messages to the superclass instance.
2139 /// \param Receiver The expression that computes the object that will
2140 /// receive this message. This may be empty, in which case we are
2141 /// sending to the superclass instance and \p SuperLoc must be a valid
2142 /// source location.
2144 /// \param ReceiverType The (static) type of the object receiving the
2145 /// message. When a \p Receiver expression is provided, this is the
2146 /// same type as that expression. For a superclass instance send, this
2147 /// is a pointer to the type of the superclass.
2149 /// \param SuperLoc The location of the "super" keyword in a
2150 /// superclass instance message.
2152 /// \param Sel The selector to which the message is being sent.
2154 /// \param Method The method that this instance message is invoking, if
2157 /// \param LBracLoc The location of the opening square bracket ']'.
2159 /// \param RBracLoc The location of the closing square bracket ']'.
2161 /// \param ArgsIn The message arguments.
2162 ExprResult Sema::BuildInstanceMessage(Expr *Receiver,
2163 QualType ReceiverType,
2164 SourceLocation SuperLoc,
2166 ObjCMethodDecl *Method,
2167 SourceLocation LBracLoc,
2168 ArrayRef<SourceLocation> SelectorLocs,
2169 SourceLocation RBracLoc,
2170 MultiExprArg ArgsIn,
2172 // The location of the receiver.
2173 SourceLocation Loc = SuperLoc.isValid()? SuperLoc : Receiver->getLocStart();
2174 SourceRange RecRange =
2175 SuperLoc.isValid()? SuperLoc : Receiver->getSourceRange();
2176 SourceLocation SelLoc;
2177 if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2178 SelLoc = SelectorLocs.front();
2182 if (LBracLoc.isInvalid()) {
2183 Diag(Loc, diag::err_missing_open_square_message_send)
2184 << FixItHint::CreateInsertion(Loc, "[");
2188 // If we have a receiver expression, perform appropriate promotions
2189 // and determine receiver type.
2191 if (Receiver->hasPlaceholderType()) {
2193 if (Receiver->getType() == Context.UnknownAnyTy)
2194 Result = forceUnknownAnyToType(Receiver, Context.getObjCIdType());
2196 Result = CheckPlaceholderExpr(Receiver);
2197 if (Result.isInvalid()) return ExprError();
2198 Receiver = Result.take();
2201 if (Receiver->isTypeDependent()) {
2202 // If the receiver is type-dependent, we can't type-check anything
2203 // at this point. Build a dependent expression.
2204 unsigned NumArgs = ArgsIn.size();
2205 Expr **Args = ArgsIn.data();
2206 assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2207 return Owned(ObjCMessageExpr::Create(Context, Context.DependentTy,
2208 VK_RValue, LBracLoc, Receiver, Sel,
2209 SelectorLocs, /*Method=*/0,
2210 makeArrayRef(Args, NumArgs),
2211 RBracLoc, isImplicit));
2214 // If necessary, apply function/array conversion to the receiver.
2215 // C99 6.7.5.3p[7,8].
2216 ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver);
2217 if (Result.isInvalid())
2219 Receiver = Result.take();
2220 ReceiverType = Receiver->getType();
2222 // If the receiver is an ObjC pointer, a block pointer, or an
2223 // __attribute__((NSObject)) pointer, we don't need to do any
2224 // special conversion in order to look up a receiver.
2225 if (ReceiverType->isObjCRetainableType()) {
2227 } else if (!getLangOpts().ObjCAutoRefCount &&
2228 !Context.getObjCIdType().isNull() &&
2229 (ReceiverType->isPointerType() ||
2230 ReceiverType->isIntegerType())) {
2231 // Implicitly convert integers and pointers to 'id' but emit a warning.
2233 Diag(Loc, diag::warn_bad_receiver_type)
2235 << Receiver->getSourceRange();
2236 if (ReceiverType->isPointerType()) {
2237 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2238 CK_CPointerToObjCPointerCast).take();
2240 // TODO: specialized warning on null receivers?
2241 bool IsNull = Receiver->isNullPointerConstant(Context,
2242 Expr::NPC_ValueDependentIsNull);
2243 CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer;
2244 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2247 ReceiverType = Receiver->getType();
2248 } else if (getLangOpts().CPlusPlus) {
2249 ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver);
2250 if (result.isUsable()) {
2251 Receiver = result.take();
2252 ReceiverType = Receiver->getType();
2257 // There's a somewhat weird interaction here where we assume that we
2258 // won't actually have a method unless we also don't need to do some
2259 // of the more detailed type-checking on the receiver.
2262 // Handle messages to id.
2263 bool receiverIsId = ReceiverType->isObjCIdType();
2264 if (receiverIsId || ReceiverType->isBlockPointerType() ||
2265 (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) {
2266 Method = LookupInstanceMethodInGlobalPool(Sel,
2267 SourceRange(LBracLoc, RBracLoc),
2270 Method = LookupFactoryMethodInGlobalPool(Sel,
2271 SourceRange(LBracLoc,RBracLoc),
2273 } else if (ReceiverType->isObjCClassType() ||
2274 ReceiverType->isObjCQualifiedClassType()) {
2275 // Handle messages to Class.
2276 // We allow sending a message to a qualified Class ("Class<foo>"), which
2277 // is ok as long as one of the protocols implements the selector (if not, warn).
2278 if (const ObjCObjectPointerType *QClassTy
2279 = ReceiverType->getAsObjCQualifiedClassType()) {
2280 // Search protocols for class methods.
2281 Method = LookupMethodInQualifiedType(Sel, QClassTy, false);
2283 Method = LookupMethodInQualifiedType(Sel, QClassTy, true);
2284 // warn if instance method found for a Class message.
2286 Diag(SelLoc, diag::warn_instance_method_on_class_found)
2287 << Method->getSelector() << Sel;
2288 Diag(Method->getLocation(), diag::note_method_declared_at)
2289 << Method->getDeclName();
2293 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2294 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) {
2295 // First check the public methods in the class interface.
2296 Method = ClassDecl->lookupClassMethod(Sel);
2299 Method = ClassDecl->lookupPrivateClassMethod(Sel);
2301 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2305 // If not messaging 'self', look for any factory method named 'Sel'.
2306 if (!Receiver || !isSelfExpr(Receiver)) {
2307 Method = LookupFactoryMethodInGlobalPool(Sel,
2308 SourceRange(LBracLoc, RBracLoc),
2311 // If no class (factory) method was found, check if an _instance_
2312 // method of the same name exists in the root class only.
2313 Method = LookupInstanceMethodInGlobalPool(Sel,
2314 SourceRange(LBracLoc, RBracLoc),
2317 if (const ObjCInterfaceDecl *ID =
2318 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
2319 if (ID->getSuperClass())
2320 Diag(SelLoc, diag::warn_root_inst_method_not_found)
2321 << Sel << SourceRange(LBracLoc, RBracLoc);
2328 ObjCInterfaceDecl* ClassDecl = 0;
2330 // We allow sending a message to a qualified ID ("id<foo>"), which is ok as
2331 // long as one of the protocols implements the selector (if not, warn).
2332 // And as long as message is not deprecated/unavailable (warn if it is).
2333 if (const ObjCObjectPointerType *QIdTy
2334 = ReceiverType->getAsObjCQualifiedIdType()) {
2335 // Search protocols for instance methods.
2336 Method = LookupMethodInQualifiedType(Sel, QIdTy, true);
2338 Method = LookupMethodInQualifiedType(Sel, QIdTy, false);
2339 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2341 } else if (const ObjCObjectPointerType *OCIType
2342 = ReceiverType->getAsObjCInterfacePointerType()) {
2343 // We allow sending a message to a pointer to an interface (an object).
2344 ClassDecl = OCIType->getInterfaceDecl();
2346 // Try to complete the type. Under ARC, this is a hard error from which
2347 // we don't try to recover.
2348 const ObjCInterfaceDecl *forwardClass = 0;
2349 if (RequireCompleteType(Loc, OCIType->getPointeeType(),
2350 getLangOpts().ObjCAutoRefCount
2351 ? diag::err_arc_receiver_forward_instance
2352 : diag::warn_receiver_forward_instance,
2353 Receiver? Receiver->getSourceRange()
2354 : SourceRange(SuperLoc))) {
2355 if (getLangOpts().ObjCAutoRefCount)
2358 forwardClass = OCIType->getInterfaceDecl();
2359 Diag(Receiver ? Receiver->getLocStart()
2360 : SuperLoc, diag::note_receiver_is_id);
2363 Method = ClassDecl->lookupInstanceMethod(Sel);
2367 // Search protocol qualifiers.
2368 Method = LookupMethodInQualifiedType(Sel, OCIType, true);
2371 // If we have implementations in scope, check "private" methods.
2372 Method = ClassDecl->lookupPrivateMethod(Sel);
2374 if (!Method && getLangOpts().ObjCAutoRefCount) {
2375 Diag(SelLoc, diag::err_arc_may_not_respond)
2376 << OCIType->getPointeeType() << Sel << RecRange
2377 << SourceRange(SelectorLocs.front(), SelectorLocs.back());
2381 if (!Method && (!Receiver || !isSelfExpr(Receiver))) {
2382 // If we still haven't found a method, look in the global pool. This
2383 // behavior isn't very desirable, however we need it for GCC
2384 // compatibility. FIXME: should we deviate??
2385 if (OCIType->qual_empty()) {
2386 Method = LookupInstanceMethodInGlobalPool(Sel,
2387 SourceRange(LBracLoc, RBracLoc));
2388 if (Method && !forwardClass)
2389 Diag(SelLoc, diag::warn_maynot_respond)
2390 << OCIType->getInterfaceDecl()->getIdentifier()
2395 if (Method && DiagnoseUseOfDecl(Method, SelLoc, forwardClass))
2398 // Reject other random receiver types (e.g. structs).
2399 Diag(Loc, diag::err_bad_receiver_type)
2400 << ReceiverType << Receiver->getSourceRange();
2406 // Check the message arguments.
2407 unsigned NumArgs = ArgsIn.size();
2408 Expr **Args = ArgsIn.data();
2409 QualType ReturnType;
2410 ExprValueKind VK = VK_RValue;
2411 bool ClassMessage = (ReceiverType->isObjCClassType() ||
2412 ReceiverType->isObjCQualifiedClassType());
2413 if (CheckMessageArgumentTypes(ReceiverType, Args, NumArgs, Sel,
2414 SelectorLocs, Method,
2415 ClassMessage, SuperLoc.isValid(),
2416 LBracLoc, RBracLoc, ReturnType, VK))
2419 if (Method && !Method->getResultType()->isVoidType() &&
2420 RequireCompleteType(LBracLoc, Method->getResultType(),
2421 diag::err_illegal_message_expr_incomplete_type))
2424 // In ARC, forbid the user from sending messages to
2425 // retain/release/autorelease/dealloc/retainCount explicitly.
2426 if (getLangOpts().ObjCAutoRefCount) {
2427 ObjCMethodFamily family =
2428 (Method ? Method->getMethodFamily() : Sel.getMethodFamily());
2432 checkInitMethod(Method, ReceiverType);
2438 case OMF_mutableCopy:
2446 case OMF_autorelease:
2447 case OMF_retainCount:
2448 Diag(SelLoc, diag::err_arc_illegal_explicit_message)
2452 case OMF_performSelector:
2453 if (Method && NumArgs >= 1) {
2454 if (ObjCSelectorExpr *SelExp = dyn_cast<ObjCSelectorExpr>(Args[0])) {
2455 Selector ArgSel = SelExp->getSelector();
2456 ObjCMethodDecl *SelMethod =
2457 LookupInstanceMethodInGlobalPool(ArgSel,
2458 SelExp->getSourceRange());
2461 LookupFactoryMethodInGlobalPool(ArgSel,
2462 SelExp->getSourceRange());
2464 ObjCMethodFamily SelFamily = SelMethod->getMethodFamily();
2465 switch (SelFamily) {
2468 case OMF_mutableCopy:
2472 // Issue error, unless ns_returns_not_retained.
2473 if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
2474 // selector names a +1 method
2476 diag::err_arc_perform_selector_retains);
2477 Diag(SelMethod->getLocation(), diag::note_method_declared_at)
2478 << SelMethod->getDeclName();
2482 // +0 call. OK. unless ns_returns_retained.
2483 if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) {
2484 // selector names a +1 method
2486 diag::err_arc_perform_selector_retains);
2487 Diag(SelMethod->getLocation(), diag::note_method_declared_at)
2488 << SelMethod->getDeclName();
2494 // error (may leak).
2495 Diag(SelLoc, diag::warn_arc_perform_selector_leaks);
2496 Diag(Args[0]->getExprLoc(), diag::note_used_here);
2503 // Construct the appropriate ObjCMessageExpr instance.
2504 ObjCMessageExpr *Result;
2505 if (SuperLoc.isValid())
2506 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2507 SuperLoc, /*IsInstanceSuper=*/true,
2508 ReceiverType, Sel, SelectorLocs, Method,
2509 makeArrayRef(Args, NumArgs), RBracLoc,
2512 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2513 Receiver, Sel, SelectorLocs, Method,
2514 makeArrayRef(Args, NumArgs), RBracLoc,
2517 checkCocoaAPI(*this, Result);
2520 if (getLangOpts().ObjCAutoRefCount) {
2521 DiagnoseARCUseOfWeakReceiver(*this, Receiver);
2523 // In ARC, annotate delegate init calls.
2524 if (Result->getMethodFamily() == OMF_init &&
2525 (SuperLoc.isValid() || isSelfExpr(Receiver))) {
2526 // Only consider init calls *directly* in init implementations,
2527 // not within blocks.
2528 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(CurContext);
2529 if (method && method->getMethodFamily() == OMF_init) {
2530 // The implicit assignment to self means we also don't want to
2531 // consume the result.
2532 Result->setDelegateInitCall(true);
2533 return Owned(Result);
2537 // In ARC, check for message sends which are likely to introduce
2539 checkRetainCycles(Result);
2541 if (!isImplicit && Method) {
2542 if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {
2544 Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak;
2545 if (!IsWeak && Sel.isUnarySelector())
2546 IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak;
2549 DiagnosticsEngine::Level Level =
2550 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak,
2552 if (Level != DiagnosticsEngine::Ignored)
2553 getCurFunction()->recordUseOfWeak(Result, Prop);
2560 return MaybeBindToTemporary(Result);
2563 static void RemoveSelectorFromWarningCache(Sema &S, Expr* Arg) {
2564 if (ObjCSelectorExpr *OSE =
2565 dyn_cast<ObjCSelectorExpr>(Arg->IgnoreParenCasts())) {
2566 Selector Sel = OSE->getSelector();
2567 SourceLocation Loc = OSE->getAtLoc();
2568 llvm::DenseMap<Selector, SourceLocation>::iterator Pos
2569 = S.ReferencedSelectors.find(Sel);
2570 if (Pos != S.ReferencedSelectors.end() && Pos->second == Loc)
2571 S.ReferencedSelectors.erase(Pos);
2575 // ActOnInstanceMessage - used for both unary and keyword messages.
2576 // ArgExprs is optional - if it is present, the number of expressions
2577 // is obtained from Sel.getNumArgs().
2578 ExprResult Sema::ActOnInstanceMessage(Scope *S,
2581 SourceLocation LBracLoc,
2582 ArrayRef<SourceLocation> SelectorLocs,
2583 SourceLocation RBracLoc,
2584 MultiExprArg Args) {
2588 // A ParenListExpr can show up while doing error recovery with invalid code.
2589 if (isa<ParenListExpr>(Receiver)) {
2590 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver);
2591 if (Result.isInvalid()) return ExprError();
2592 Receiver = Result.take();
2595 if (RespondsToSelectorSel.isNull()) {
2596 IdentifierInfo *SelectorId = &Context.Idents.get("respondsToSelector");
2597 RespondsToSelectorSel = Context.Selectors.getUnarySelector(SelectorId);
2599 if (Sel == RespondsToSelectorSel)
2600 RemoveSelectorFromWarningCache(*this, Args[0]);
2602 return BuildInstanceMessage(Receiver, Receiver->getType(),
2603 /*SuperLoc=*/SourceLocation(), Sel, /*Method=*/0,
2604 LBracLoc, SelectorLocs, RBracLoc, Args);
2607 enum ARCConversionTypeClass {
2608 /// int, void, struct A
2614 /// id*, id***, void (^*)(),
2615 ACTC_indirectRetainable,
2617 /// void* might be a normal C type, or it might a CF type.
2623 static bool isAnyRetainable(ARCConversionTypeClass ACTC) {
2624 return (ACTC == ACTC_retainable ||
2625 ACTC == ACTC_coreFoundation ||
2626 ACTC == ACTC_voidPtr);
2628 static bool isAnyCLike(ARCConversionTypeClass ACTC) {
2629 return ACTC == ACTC_none ||
2630 ACTC == ACTC_voidPtr ||
2631 ACTC == ACTC_coreFoundation;
2634 static ARCConversionTypeClass classifyTypeForARCConversion(QualType type) {
2635 bool isIndirect = false;
2637 // Ignore an outermost reference type.
2638 if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
2639 type = ref->getPointeeType();
2643 // Drill through pointers and arrays recursively.
2645 if (const PointerType *ptr = type->getAs<PointerType>()) {
2646 type = ptr->getPointeeType();
2648 // The first level of pointer may be the innermost pointer on a CF type.
2650 if (type->isVoidType()) return ACTC_voidPtr;
2651 if (type->isRecordType()) return ACTC_coreFoundation;
2653 } else if (const ArrayType *array = type->getAsArrayTypeUnsafe()) {
2654 type = QualType(array->getElementType()->getBaseElementTypeUnsafe(), 0);
2662 if (type->isObjCARCBridgableType())
2663 return ACTC_indirectRetainable;
2667 if (type->isObjCARCBridgableType())
2668 return ACTC_retainable;
2674 /// A result from the cast checker.
2676 /// Cannot be casted.
2679 /// Can be safely retained or not retained.
2682 /// Can be casted at +0.
2685 /// Can be casted at +1.
2688 ACCResult merge(ACCResult left, ACCResult right) {
2689 if (left == right) return left;
2690 if (left == ACC_bottom) return right;
2691 if (right == ACC_bottom) return left;
2695 /// A checker which white-lists certain expressions whose conversion
2696 /// to or from retainable type would otherwise be forbidden in ARC.
2697 class ARCCastChecker : public StmtVisitor<ARCCastChecker, ACCResult> {
2698 typedef StmtVisitor<ARCCastChecker, ACCResult> super;
2700 ASTContext &Context;
2701 ARCConversionTypeClass SourceClass;
2702 ARCConversionTypeClass TargetClass;
2705 static bool isCFType(QualType type) {
2706 // Someday this can use ns_bridged. For now, it has to do this.
2707 return type->isCARCBridgableType();
2711 ARCCastChecker(ASTContext &Context, ARCConversionTypeClass source,
2712 ARCConversionTypeClass target, bool diagnose)
2713 : Context(Context), SourceClass(source), TargetClass(target),
2714 Diagnose(diagnose) {}
2717 ACCResult Visit(Expr *e) {
2718 return super::Visit(e->IgnoreParens());
2721 ACCResult VisitStmt(Stmt *s) {
2725 /// Null pointer constants can be casted however you please.
2726 ACCResult VisitExpr(Expr *e) {
2727 if (e->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull))
2732 /// Objective-C string literals can be safely casted.
2733 ACCResult VisitObjCStringLiteral(ObjCStringLiteral *e) {
2734 // If we're casting to any retainable type, go ahead. Global
2735 // strings are immune to retains, so this is bottom.
2736 if (isAnyRetainable(TargetClass)) return ACC_bottom;
2741 /// Look through certain implicit and explicit casts.
2742 ACCResult VisitCastExpr(CastExpr *e) {
2743 switch (e->getCastKind()) {
2744 case CK_NullToPointer:
2748 case CK_LValueToRValue:
2750 case CK_CPointerToObjCPointerCast:
2751 case CK_BlockPointerToObjCPointerCast:
2752 case CK_AnyPointerToBlockPointerCast:
2753 return Visit(e->getSubExpr());
2760 /// Look through unary extension.
2761 ACCResult VisitUnaryExtension(UnaryOperator *e) {
2762 return Visit(e->getSubExpr());
2765 /// Ignore the LHS of a comma operator.
2766 ACCResult VisitBinComma(BinaryOperator *e) {
2767 return Visit(e->getRHS());
2770 /// Conditional operators are okay if both sides are okay.
2771 ACCResult VisitConditionalOperator(ConditionalOperator *e) {
2772 ACCResult left = Visit(e->getTrueExpr());
2773 if (left == ACC_invalid) return ACC_invalid;
2774 return merge(left, Visit(e->getFalseExpr()));
2777 /// Look through pseudo-objects.
2778 ACCResult VisitPseudoObjectExpr(PseudoObjectExpr *e) {
2779 // If we're getting here, we should always have a result.
2780 return Visit(e->getResultExpr());
2783 /// Statement expressions are okay if their result expression is okay.
2784 ACCResult VisitStmtExpr(StmtExpr *e) {
2785 return Visit(e->getSubStmt()->body_back());
2788 /// Some declaration references are okay.
2789 ACCResult VisitDeclRefExpr(DeclRefExpr *e) {
2790 // References to global constants from system headers are okay.
2791 // These are things like 'kCFStringTransformToLatin'. They are
2792 // can also be assumed to be immune to retains.
2793 VarDecl *var = dyn_cast<VarDecl>(e->getDecl());
2794 if (isAnyRetainable(TargetClass) &&
2795 isAnyRetainable(SourceClass) &&
2797 var->getStorageClass() == SC_Extern &&
2798 var->getType().isConstQualified() &&
2799 Context.getSourceManager().isInSystemHeader(var->getLocation())) {
2807 /// Some calls are okay.
2808 ACCResult VisitCallExpr(CallExpr *e) {
2809 if (FunctionDecl *fn = e->getDirectCallee())
2810 if (ACCResult result = checkCallToFunction(fn))
2813 return super::VisitCallExpr(e);
2816 ACCResult checkCallToFunction(FunctionDecl *fn) {
2817 // Require a CF*Ref return type.
2818 if (!isCFType(fn->getResultType()))
2821 if (!isAnyRetainable(TargetClass))
2824 // Honor an explicit 'not retained' attribute.
2825 if (fn->hasAttr<CFReturnsNotRetainedAttr>())
2826 return ACC_plusZero;
2828 // Honor an explicit 'retained' attribute, except that for
2829 // now we're not going to permit implicit handling of +1 results,
2830 // because it's a bit frightening.
2831 if (fn->hasAttr<CFReturnsRetainedAttr>())
2832 return Diagnose ? ACC_plusOne
2833 : ACC_invalid; // ACC_plusOne if we start accepting this
2835 // Recognize this specific builtin function, which is used by CFSTR.
2836 unsigned builtinID = fn->getBuiltinID();
2837 if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString)
2840 // Otherwise, don't do anything implicit with an unaudited function.
2841 if (!fn->hasAttr<CFAuditedTransferAttr>())
2844 // Otherwise, it's +0 unless it follows the create convention.
2845 if (ento::coreFoundation::followsCreateRule(fn))
2846 return Diagnose ? ACC_plusOne
2847 : ACC_invalid; // ACC_plusOne if we start accepting this
2849 return ACC_plusZero;
2852 ACCResult VisitObjCMessageExpr(ObjCMessageExpr *e) {
2853 return checkCallToMethod(e->getMethodDecl());
2856 ACCResult VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *e) {
2857 ObjCMethodDecl *method;
2858 if (e->isExplicitProperty())
2859 method = e->getExplicitProperty()->getGetterMethodDecl();
2861 method = e->getImplicitPropertyGetter();
2862 return checkCallToMethod(method);
2865 ACCResult checkCallToMethod(ObjCMethodDecl *method) {
2866 if (!method) return ACC_invalid;
2868 // Check for message sends to functions returning CF types. We
2869 // just obey the Cocoa conventions with these, even though the
2870 // return type is CF.
2871 if (!isAnyRetainable(TargetClass) || !isCFType(method->getResultType()))
2874 // If the method is explicitly marked not-retained, it's +0.
2875 if (method->hasAttr<CFReturnsNotRetainedAttr>())
2876 return ACC_plusZero;
2878 // If the method is explicitly marked as returning retained, or its
2879 // selector follows a +1 Cocoa convention, treat it as +1.
2880 if (method->hasAttr<CFReturnsRetainedAttr>())
2883 switch (method->getSelector().getMethodFamily()) {
2886 case OMF_mutableCopy:
2891 // Otherwise, treat it as +0.
2892 return ACC_plusZero;
2898 bool Sema::isKnownName(StringRef name) {
2901 LookupResult R(*this, &Context.Idents.get(name), SourceLocation(),
2902 Sema::LookupOrdinaryName);
2903 return LookupName(R, TUScope, false);
2906 static void addFixitForObjCARCConversion(Sema &S,
2907 DiagnosticBuilder &DiagB,
2908 Sema::CheckedConversionKind CCK,
2909 SourceLocation afterLParen,
2913 const char *bridgeKeyword,
2914 const char *CFBridgeName) {
2915 // We handle C-style and implicit casts here.
2917 case Sema::CCK_ImplicitConversion:
2918 case Sema::CCK_CStyleCast:
2919 case Sema::CCK_OtherCast:
2921 case Sema::CCK_FunctionalCast:
2926 if (CCK == Sema::CCK_OtherCast) {
2927 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
2928 SourceRange range(NCE->getOperatorLoc(),
2929 NCE->getAngleBrackets().getEnd());
2930 SmallString<32> BridgeCall;
2932 SourceManager &SM = S.getSourceManager();
2933 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
2934 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
2937 BridgeCall += CFBridgeName;
2938 DiagB.AddFixItHint(FixItHint::CreateReplacement(range, BridgeCall));
2942 Expr *castedE = castExpr;
2943 if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(castedE))
2944 castedE = CCE->getSubExpr();
2945 castedE = castedE->IgnoreImpCasts();
2946 SourceRange range = castedE->getSourceRange();
2948 SmallString<32> BridgeCall;
2950 SourceManager &SM = S.getSourceManager();
2951 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
2952 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
2955 BridgeCall += CFBridgeName;
2957 if (isa<ParenExpr>(castedE)) {
2958 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
2962 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
2964 DiagB.AddFixItHint(FixItHint::CreateInsertion(
2965 S.PP.getLocForEndOfToken(range.getEnd()),
2971 if (CCK == Sema::CCK_CStyleCast) {
2972 DiagB.AddFixItHint(FixItHint::CreateInsertion(afterLParen, bridgeKeyword));
2973 } else if (CCK == Sema::CCK_OtherCast) {
2974 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
2975 std::string castCode = "(";
2976 castCode += bridgeKeyword;
2977 castCode += castType.getAsString();
2979 SourceRange Range(NCE->getOperatorLoc(),
2980 NCE->getAngleBrackets().getEnd());
2981 DiagB.AddFixItHint(FixItHint::CreateReplacement(Range, castCode));
2984 std::string castCode = "(";
2985 castCode += bridgeKeyword;
2986 castCode += castType.getAsString();
2988 Expr *castedE = castExpr->IgnoreImpCasts();
2989 SourceRange range = castedE->getSourceRange();
2990 if (isa<ParenExpr>(castedE)) {
2991 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
2995 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
2997 DiagB.AddFixItHint(FixItHint::CreateInsertion(
2998 S.PP.getLocForEndOfToken(range.getEnd()),
3005 diagnoseObjCARCConversion(Sema &S, SourceRange castRange,
3006 QualType castType, ARCConversionTypeClass castACTC,
3007 Expr *castExpr, Expr *realCast,
3008 ARCConversionTypeClass exprACTC,
3009 Sema::CheckedConversionKind CCK) {
3010 SourceLocation loc =
3011 (castRange.isValid() ? castRange.getBegin() : castExpr->getExprLoc());
3013 if (S.makeUnavailableInSystemHeader(loc,
3014 "converts between Objective-C and C pointers in -fobjc-arc"))
3017 QualType castExprType = castExpr->getType();
3019 unsigned srcKind = 0;
3022 case ACTC_coreFoundation:
3024 srcKind = (castExprType->isPointerType() ? 1 : 0);
3026 case ACTC_retainable:
3027 srcKind = (castExprType->isBlockPointerType() ? 2 : 3);
3029 case ACTC_indirectRetainable:
3034 // Check whether this could be fixed with a bridge cast.
3035 SourceLocation afterLParen = S.PP.getLocForEndOfToken(castRange.getBegin());
3036 SourceLocation noteLoc = afterLParen.isValid() ? afterLParen : loc;
3038 // Bridge from an ARC type to a CF type.
3039 if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {
3041 S.Diag(loc, diag::err_arc_cast_requires_bridge)
3042 << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit
3043 << 2 // of C pointer type
3045 << unsigned(castType->isBlockPointerType()) // to ObjC|block type
3048 << castExpr->getSourceRange();
3049 bool br = S.isKnownName("CFBridgingRelease");
3050 ACCResult CreateRule =
3051 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3052 assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3053 if (CreateRule != ACC_plusOne)
3055 DiagnosticBuilder DiagB =
3056 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3057 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3059 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3060 castType, castExpr, realCast, "__bridge ", 0);
3062 if (CreateRule != ACC_plusZero)
3064 DiagnosticBuilder DiagB =
3065 (CCK == Sema::CCK_OtherCast && !br) ?
3066 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer) << castExprType :
3067 S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3068 diag::note_arc_bridge_transfer)
3069 << castExprType << br;
3071 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3072 castType, castExpr, realCast, "__bridge_transfer ",
3073 br ? "CFBridgingRelease" : 0);
3079 // Bridge from a CF type to an ARC type.
3080 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {
3081 bool br = S.isKnownName("CFBridgingRetain");
3082 S.Diag(loc, diag::err_arc_cast_requires_bridge)
3083 << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit
3084 << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type
3086 << 2 // to C pointer type
3089 << castExpr->getSourceRange();
3090 ACCResult CreateRule =
3091 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3092 assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3093 if (CreateRule != ACC_plusOne)
3095 DiagnosticBuilder DiagB =
3096 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3097 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3098 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3099 castType, castExpr, realCast, "__bridge ", 0);
3101 if (CreateRule != ACC_plusZero)
3103 DiagnosticBuilder DiagB =
3104 (CCK == Sema::CCK_OtherCast && !br) ?
3105 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType :
3106 S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3107 diag::note_arc_bridge_retained)
3110 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3111 castType, castExpr, realCast, "__bridge_retained ",
3112 br ? "CFBridgingRetain" : 0);
3118 S.Diag(loc, diag::err_arc_mismatched_cast)
3119 << (CCK != Sema::CCK_ImplicitConversion)
3120 << srcKind << castExprType << castType
3121 << castRange << castExpr->getSourceRange();
3124 Sema::ARCConversionResult
3125 Sema::CheckObjCARCConversion(SourceRange castRange, QualType castType,
3126 Expr *&castExpr, CheckedConversionKind CCK) {
3127 QualType castExprType = castExpr->getType();
3129 // For the purposes of the classification, we assume reference types
3130 // will bind to temporaries.
3131 QualType effCastType = castType;
3132 if (const ReferenceType *ref = castType->getAs<ReferenceType>())
3133 effCastType = ref->getPointeeType();
3135 ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExprType);
3136 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(effCastType);
3137 if (exprACTC == castACTC) {
3138 // check for viablity and report error if casting an rvalue to a
3139 // life-time qualifier.
3140 if ((castACTC == ACTC_retainable) &&
3141 (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) &&
3142 (castType != castExprType)) {
3143 const Type *DT = castType.getTypePtr();
3144 QualType QDT = castType;
3145 // We desugar some types but not others. We ignore those
3146 // that cannot happen in a cast; i.e. auto, and those which
3147 // should not be de-sugared; i.e typedef.
3148 if (const ParenType *PT = dyn_cast<ParenType>(DT))
3149 QDT = PT->desugar();
3150 else if (const TypeOfType *TP = dyn_cast<TypeOfType>(DT))
3151 QDT = TP->desugar();
3152 else if (const AttributedType *AT = dyn_cast<AttributedType>(DT))
3153 QDT = AT->desugar();
3154 if (QDT != castType &&
3155 QDT.getObjCLifetime() != Qualifiers::OCL_None) {
3156 SourceLocation loc =
3157 (castRange.isValid() ? castRange.getBegin()
3158 : castExpr->getExprLoc());
3159 Diag(loc, diag::err_arc_nolifetime_behavior);
3165 if (isAnyCLike(exprACTC) && isAnyCLike(castACTC)) return ACR_okay;
3167 // Allow all of these types to be cast to integer types (but not
3169 if (castACTC == ACTC_none && castType->isIntegralType(Context))
3172 // Allow casts between pointers to lifetime types (e.g., __strong id*)
3173 // and pointers to void (e.g., cv void *). Casting from void* to lifetime*
3174 // must be explicit.
3175 if (exprACTC == ACTC_indirectRetainable && castACTC == ACTC_voidPtr)
3177 if (castACTC == ACTC_indirectRetainable && exprACTC == ACTC_voidPtr &&
3178 CCK != CCK_ImplicitConversion)
3181 switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) {
3182 // For invalid casts, fall through.
3186 // Do nothing for both bottom and +0.
3191 // If the result is +1, consume it here.
3193 castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(),
3194 CK_ARCConsumeObject, castExpr,
3196 ExprNeedsCleanups = true;
3200 // If this is a non-implicit cast from id or block type to a
3201 // CoreFoundation type, delay complaining in case the cast is used
3202 // in an acceptable context.
3203 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) &&
3204 CCK != CCK_ImplicitConversion)
3205 return ACR_unbridged;
3207 diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
3208 castExpr, castExpr, exprACTC, CCK);
3212 /// Given that we saw an expression with the ARCUnbridgedCastTy
3213 /// placeholder type, complain bitterly.
3214 void Sema::diagnoseARCUnbridgedCast(Expr *e) {
3215 // We expect the spurious ImplicitCastExpr to already have been stripped.
3216 assert(!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
3217 CastExpr *realCast = cast<CastExpr>(e->IgnoreParens());
3219 SourceRange castRange;
3221 CheckedConversionKind CCK;
3223 if (CStyleCastExpr *cast = dyn_cast<CStyleCastExpr>(realCast)) {
3224 castRange = SourceRange(cast->getLParenLoc(), cast->getRParenLoc());
3225 castType = cast->getTypeAsWritten();
3226 CCK = CCK_CStyleCast;
3227 } else if (ExplicitCastExpr *cast = dyn_cast<ExplicitCastExpr>(realCast)) {
3228 castRange = cast->getTypeInfoAsWritten()->getTypeLoc().getSourceRange();
3229 castType = cast->getTypeAsWritten();
3230 CCK = CCK_OtherCast;
3232 castType = cast->getType();
3233 CCK = CCK_ImplicitConversion;
3236 ARCConversionTypeClass castACTC =
3237 classifyTypeForARCConversion(castType.getNonReferenceType());
3239 Expr *castExpr = realCast->getSubExpr();
3240 assert(classifyTypeForARCConversion(castExpr->getType()) == ACTC_retainable);
3242 diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
3243 castExpr, realCast, ACTC_retainable, CCK);
3246 /// stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast
3247 /// type, remove the placeholder cast.
3248 Expr *Sema::stripARCUnbridgedCast(Expr *e) {
3249 assert(e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
3251 if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) {
3252 Expr *sub = stripARCUnbridgedCast(pe->getSubExpr());
3253 return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub);
3254 } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) {
3255 assert(uo->getOpcode() == UO_Extension);
3256 Expr *sub = stripARCUnbridgedCast(uo->getSubExpr());
3257 return new (Context) UnaryOperator(sub, UO_Extension, sub->getType(),
3258 sub->getValueKind(), sub->getObjectKind(),
3259 uo->getOperatorLoc());
3260 } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
3261 assert(!gse->isResultDependent());
3263 unsigned n = gse->getNumAssocs();
3264 SmallVector<Expr*, 4> subExprs(n);
3265 SmallVector<TypeSourceInfo*, 4> subTypes(n);
3266 for (unsigned i = 0; i != n; ++i) {
3267 subTypes[i] = gse->getAssocTypeSourceInfo(i);
3268 Expr *sub = gse->getAssocExpr(i);
3269 if (i == gse->getResultIndex())
3270 sub = stripARCUnbridgedCast(sub);
3274 return new (Context) GenericSelectionExpr(Context, gse->getGenericLoc(),
3275 gse->getControllingExpr(),
3277 gse->getDefaultLoc(),
3278 gse->getRParenLoc(),
3279 gse->containsUnexpandedParameterPack(),
3280 gse->getResultIndex());
3282 assert(isa<ImplicitCastExpr>(e) && "bad form of unbridged cast!");
3283 return cast<ImplicitCastExpr>(e)->getSubExpr();
3287 bool Sema::CheckObjCARCUnavailableWeakConversion(QualType castType,
3288 QualType exprType) {
3289 QualType canCastType =
3290 Context.getCanonicalType(castType).getUnqualifiedType();
3291 QualType canExprType =
3292 Context.getCanonicalType(exprType).getUnqualifiedType();
3293 if (isa<ObjCObjectPointerType>(canCastType) &&
3294 castType.getObjCLifetime() == Qualifiers::OCL_Weak &&
3295 canExprType->isObjCObjectPointerType()) {
3296 if (const ObjCObjectPointerType *ObjT =
3297 canExprType->getAs<ObjCObjectPointerType>())
3298 if (const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl())
3299 return !ObjI->isArcWeakrefUnavailable();
3304 /// Look for an ObjCReclaimReturnedObject cast and destroy it.
3305 static Expr *maybeUndoReclaimObject(Expr *e) {
3306 // For now, we just undo operands that are *immediately* reclaim
3307 // expressions, which prevents the vast majority of potential
3308 // problems here. To catch them all, we'd need to rebuild arbitrary
3309 // value-propagating subexpressions --- we can't reliably rebuild
3310 // in-place because of expression sharing.
3311 if (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
3312 if (ice->getCastKind() == CK_ARCReclaimReturnedObject)
3313 return ice->getSubExpr();
3318 ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc,
3319 ObjCBridgeCastKind Kind,
3320 SourceLocation BridgeKeywordLoc,
3321 TypeSourceInfo *TSInfo,
3323 ExprResult SubResult = UsualUnaryConversions(SubExpr);
3324 if (SubResult.isInvalid()) return ExprError();
3325 SubExpr = SubResult.take();
3327 QualType T = TSInfo->getType();
3328 QualType FromType = SubExpr->getType();
3332 bool MustConsume = false;
3333 if (T->isDependentType() || SubExpr->isTypeDependent()) {
3334 // Okay: we'll build a dependent expression type.
3336 } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {
3338 CK = (T->isBlockPointerType() ? CK_AnyPointerToBlockPointerCast
3339 : CK_CPointerToObjCPointerCast);
3344 case OBC_BridgeRetained: {
3345 bool br = isKnownName("CFBridgingRelease");
3346 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
3349 << (T->isBlockPointerType()? 1 : 0)
3351 << SubExpr->getSourceRange()
3353 Diag(BridgeKeywordLoc, diag::note_arc_bridge)
3354 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge");
3355 Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer)
3357 << FixItHint::CreateReplacement(BridgeKeywordLoc,
3358 br ? "CFBridgingRelease "
3359 : "__bridge_transfer ");
3365 case OBC_BridgeTransfer:
3366 // We must consume the Objective-C object produced by the cast.
3370 } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {
3375 // Reclaiming a value that's going to be __bridge-casted to CF
3376 // is very dangerous, so we don't do it.
3377 SubExpr = maybeUndoReclaimObject(SubExpr);
3380 case OBC_BridgeRetained:
3381 // Produce the object before casting it.
3382 SubExpr = ImplicitCastExpr::Create(Context, FromType,
3383 CK_ARCProduceObject,
3384 SubExpr, 0, VK_RValue);
3387 case OBC_BridgeTransfer: {
3388 bool br = isKnownName("CFBridgingRetain");
3389 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
3390 << (FromType->isBlockPointerType()? 1 : 0)
3394 << SubExpr->getSourceRange()
3397 Diag(BridgeKeywordLoc, diag::note_arc_bridge)
3398 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge ");
3399 Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained)
3401 << FixItHint::CreateReplacement(BridgeKeywordLoc,
3402 br ? "CFBridgingRetain " : "__bridge_retained");
3409 Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible)
3410 << FromType << T << Kind
3411 << SubExpr->getSourceRange()
3412 << TSInfo->getTypeLoc().getSourceRange();
3416 Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK,
3421 ExprNeedsCleanups = true;
3422 Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result,
3429 ExprResult Sema::ActOnObjCBridgedCast(Scope *S,
3430 SourceLocation LParenLoc,
3431 ObjCBridgeCastKind Kind,
3432 SourceLocation BridgeKeywordLoc,
3434 SourceLocation RParenLoc,
3436 TypeSourceInfo *TSInfo = 0;
3437 QualType T = GetTypeFromParser(Type, &TSInfo);
3439 TSInfo = Context.getTrivialTypeSourceInfo(T, LParenLoc);
3440 return BuildObjCBridgedCast(LParenLoc, Kind, BridgeKeywordLoc, TSInfo,