Bug Summary

File:tools/clang/lib/Sema/SemaExprObjC.cpp
Warning:line 1708, column 14
Called C++ object pointer is null

Annotated Source Code

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