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-5.0~svn296300/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-5.0~svn296300/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-5.0~svn296300/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-5.0~svn296300/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-5.0~svn296300/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-5.0~svn296300/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-5.0~svn296300/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 Selector GetterSel;
1988 Selector SetterSel;
1989 if (auto PD = IFace->FindPropertyDeclaration(
1990 &propertyName, ObjCPropertyQueryKind::OBJC_PR_query_class)) {
1991 GetterSel = PD->getGetterName();
1992 SetterSel = PD->getSetterName();
1993 } else {
1994 GetterSel = PP.getSelectorTable().getNullarySelector(&propertyName);
1995 SetterSel = SelectorTable::constructSetterSelector(
1996 PP.getIdentifierTable(), PP.getSelectorTable(), &propertyName);
1997 }
1998
1999 // Search for a declared property first.
2000 ObjCMethodDecl *Getter = IFace->lookupClassMethod(GetterSel);
2001
2002 // If this reference is in an @implementation, check for 'private' methods.
2003 if (!Getter)
2004 Getter = IFace->lookupPrivateClassMethod(GetterSel);
2005
2006 if (Getter) {
2007 // FIXME: refactor/share with ActOnMemberReference().
2008 // Check if we can reference this property.
2009 if (DiagnoseUseOfDecl(Getter, propertyNameLoc))
2010 return ExprError();
2011 }
2012
2013 // Look for the matching setter, in case it is needed.
2014 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
2015 if (!Setter) {
2016 // If this reference is in an @implementation, also check for 'private'
2017 // methods.
2018 Setter = IFace->lookupPrivateClassMethod(SetterSel);
2019 }
2020 // Look through local category implementations associated with the class.
2021 if (!Setter)
2022 Setter = IFace->getCategoryClassMethod(SetterSel);
2023
2024 if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc))
2025 return ExprError();
2026
2027 if (Getter || Setter) {
2028 if (!SuperType.isNull())
2029 return new (Context)
2030 ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue,
2031 OK_ObjCProperty, propertyNameLoc, receiverNameLoc,
2032 SuperType);
2033
2034 return new (Context) ObjCPropertyRefExpr(
2035 Getter, Setter, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty,
2036 propertyNameLoc, receiverNameLoc, IFace);
2037 }
2038 return ExprError(Diag(propertyNameLoc, diag::err_property_not_found)
2039 << &propertyName << Context.getObjCInterfaceType(IFace));
2040}
2041
2042namespace {
2043
2044class ObjCInterfaceOrSuperCCC : public CorrectionCandidateCallback {
2045 public:
2046 ObjCInterfaceOrSuperCCC(ObjCMethodDecl *Method) {
2047 // Determine whether "super" is acceptable in the current context.
2048 if (Method && Method->getClassInterface())
2049 WantObjCSuper = Method->getClassInterface()->getSuperClass();
2050 }
2051
2052 bool ValidateCandidate(const TypoCorrection &candidate) override {
2053 return candidate.getCorrectionDeclAs<ObjCInterfaceDecl>() ||
2054 candidate.isKeyword("super");
2055 }
2056};
2057
2058} // end anonymous namespace
2059
2060Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S,
2061 IdentifierInfo *Name,
2062 SourceLocation NameLoc,
2063 bool IsSuper,
2064 bool HasTrailingDot,
2065 ParsedType &ReceiverType) {
2066 ReceiverType = nullptr;
2067
2068 // If the identifier is "super" and there is no trailing dot, we're
2069 // messaging super. If the identifier is "super" and there is a
2070 // trailing dot, it's an instance message.
2071 if (IsSuper && S->isInObjcMethodScope())
2072 return HasTrailingDot? ObjCInstanceMessage : ObjCSuperMessage;
2073
2074 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
2075 LookupName(Result, S);
2076
2077 switch (Result.getResultKind()) {
2078 case LookupResult::NotFound:
2079 // Normal name lookup didn't find anything. If we're in an
2080 // Objective-C method, look for ivars. If we find one, we're done!
2081 // FIXME: This is a hack. Ivar lookup should be part of normal
2082 // lookup.
2083 if (ObjCMethodDecl *Method = getCurMethodDecl()) {
2084 if (!Method->getClassInterface()) {
2085 // Fall back: let the parser try to parse it as an instance message.
2086 return ObjCInstanceMessage;
2087 }
2088
2089 ObjCInterfaceDecl *ClassDeclared;
2090 if (Method->getClassInterface()->lookupInstanceVariable(Name,
2091 ClassDeclared))
2092 return ObjCInstanceMessage;
2093 }
2094
2095 // Break out; we'll perform typo correction below.
2096 break;
2097
2098 case LookupResult::NotFoundInCurrentInstantiation:
2099 case LookupResult::FoundOverloaded:
2100 case LookupResult::FoundUnresolvedValue:
2101 case LookupResult::Ambiguous:
2102 Result.suppressDiagnostics();
2103 return ObjCInstanceMessage;
2104
2105 case LookupResult::Found: {
2106 // If the identifier is a class or not, and there is a trailing dot,
2107 // it's an instance message.
2108 if (HasTrailingDot)
2109 return ObjCInstanceMessage;
2110 // We found something. If it's a type, then we have a class
2111 // message. Otherwise, it's an instance message.
2112 NamedDecl *ND = Result.getFoundDecl();
2113 QualType T;
2114 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(ND))
2115 T = Context.getObjCInterfaceType(Class);
2116 else if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) {
2117 T = Context.getTypeDeclType(Type);
2118 DiagnoseUseOfDecl(Type, NameLoc);
2119 }
2120 else
2121 return ObjCInstanceMessage;
2122
2123 // We have a class message, and T is the type we're
2124 // messaging. Build source-location information for it.
2125 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
2126 ReceiverType = CreateParsedType(T, TSInfo);
2127 return ObjCClassMessage;
2128 }
2129 }
2130
2131 if (TypoCorrection Corrected = CorrectTypo(
2132 Result.getLookupNameInfo(), Result.getLookupKind(), S, nullptr,
2133 llvm::make_unique<ObjCInterfaceOrSuperCCC>(getCurMethodDecl()),
2134 CTK_ErrorRecovery, nullptr, false, nullptr, false)) {
2135 if (Corrected.isKeyword()) {
2136 // If we've found the keyword "super" (the only keyword that would be
2137 // returned by CorrectTypo), this is a send to super.
2138 diagnoseTypo(Corrected,
2139 PDiag(diag::err_unknown_receiver_suggest) << Name);
2140 return ObjCSuperMessage;
2141 } else if (ObjCInterfaceDecl *Class =
2142 Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
2143 // If we found a declaration, correct when it refers to an Objective-C
2144 // class.
2145 diagnoseTypo(Corrected,
2146 PDiag(diag::err_unknown_receiver_suggest) << Name);
2147 QualType T = Context.getObjCInterfaceType(Class);
2148 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
2149 ReceiverType = CreateParsedType(T, TSInfo);
2150 return ObjCClassMessage;
2151 }
2152 }
2153
2154 // Fall back: let the parser try to parse it as an instance message.
2155 return ObjCInstanceMessage;
2156}
2157
2158ExprResult Sema::ActOnSuperMessage(Scope *S,
2159 SourceLocation SuperLoc,
2160 Selector Sel,
2161 SourceLocation LBracLoc,
2162 ArrayRef<SourceLocation> SelectorLocs,
2163 SourceLocation RBracLoc,
2164 MultiExprArg Args) {
2165 // Determine whether we are inside a method or not.
2166 ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc);
2167 if (!Method) {
2168 Diag(SuperLoc, diag::err_invalid_receiver_to_message_super);
2169 return ExprError();
2170 }
2171
2172 ObjCInterfaceDecl *Class = Method->getClassInterface();
2173 if (!Class) {
2174 Diag(SuperLoc, diag::err_no_super_class_message)
2175 << Method->getDeclName();
2176 return ExprError();
2177 }
2178
2179 QualType SuperTy(Class->getSuperClassType(), 0);
2180 if (SuperTy.isNull()) {
2181 // The current class does not have a superclass.
2182 Diag(SuperLoc, diag::err_root_class_cannot_use_super)
2183 << Class->getIdentifier();
2184 return ExprError();
2185 }
2186
2187 // We are in a method whose class has a superclass, so 'super'
2188 // is acting as a keyword.
2189 if (Method->getSelector() == Sel)
2190 getCurFunction()->ObjCShouldCallSuper = false;
2191
2192 if (Method->isInstanceMethod()) {
2193 // Since we are in an instance method, this is an instance
2194 // message to the superclass instance.
2195 SuperTy = Context.getObjCObjectPointerType(SuperTy);
2196 return BuildInstanceMessage(nullptr, SuperTy, SuperLoc,
2197 Sel, /*Method=*/nullptr,
2198 LBracLoc, SelectorLocs, RBracLoc, Args);
2199 }
2200
2201 // Since we are in a class method, this is a class message to
2202 // the superclass.
2203 return BuildClassMessage(/*ReceiverTypeInfo=*/nullptr,
2204 SuperTy,
2205 SuperLoc, Sel, /*Method=*/nullptr,
2206 LBracLoc, SelectorLocs, RBracLoc, Args);
2207}
2208
2209ExprResult Sema::BuildClassMessageImplicit(QualType ReceiverType,
2210 bool isSuperReceiver,
2211 SourceLocation Loc,
2212 Selector Sel,
2213 ObjCMethodDecl *Method,
2214 MultiExprArg Args) {
2215 TypeSourceInfo *receiverTypeInfo = nullptr;
2216 if (!ReceiverType.isNull())
2217 receiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType);
2218
2219 return BuildClassMessage(receiverTypeInfo, ReceiverType,
2220 /*SuperLoc=*/isSuperReceiver ? Loc : SourceLocation(),
2221 Sel, Method, Loc, Loc, Loc, Args,
2222 /*isImplicit=*/true);
2223}
2224
2225static void applyCocoaAPICheck(Sema &S, const ObjCMessageExpr *Msg,
2226 unsigned DiagID,
2227 bool (*refactor)(const ObjCMessageExpr *,
2228 const NSAPI &, edit::Commit &)) {
2229 SourceLocation MsgLoc = Msg->getExprLoc();
2230 if (S.Diags.isIgnored(DiagID, MsgLoc))
2231 return;
2232
2233 SourceManager &SM = S.SourceMgr;
2234 edit::Commit ECommit(SM, S.LangOpts);
2235 if (refactor(Msg,*S.NSAPIObj, ECommit)) {
2236 DiagnosticBuilder Builder = S.Diag(MsgLoc, DiagID)
2237 << Msg->getSelector() << Msg->getSourceRange();
2238 // FIXME: Don't emit diagnostic at all if fixits are non-commitable.
2239 if (!ECommit.isCommitable())
2240 return;
2241 for (edit::Commit::edit_iterator
2242 I = ECommit.edit_begin(), E = ECommit.edit_end(); I != E; ++I) {
2243 const edit::Commit::Edit &Edit = *I;
2244 switch (Edit.Kind) {
2245 case edit::Commit::Act_Insert:
2246 Builder.AddFixItHint(FixItHint::CreateInsertion(Edit.OrigLoc,
2247 Edit.Text,
2248 Edit.BeforePrev));
2249 break;
2250 case edit::Commit::Act_InsertFromRange:
2251 Builder.AddFixItHint(
2252 FixItHint::CreateInsertionFromRange(Edit.OrigLoc,
2253 Edit.getInsertFromRange(SM),
2254 Edit.BeforePrev));
2255 break;
2256 case edit::Commit::Act_Remove:
2257 Builder.AddFixItHint(FixItHint::CreateRemoval(Edit.getFileRange(SM)));
2258 break;
2259 }
2260 }
2261 }
2262}
2263
2264static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) {
2265 applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use,
2266 edit::rewriteObjCRedundantCallWithLiteral);
2267}
2268
2269/// \brief Diagnose use of %s directive in an NSString which is being passed
2270/// as formatting string to formatting method.
2271static void
2272DiagnoseCStringFormatDirectiveInObjCAPI(Sema &S,
2273 ObjCMethodDecl *Method,
2274 Selector Sel,
2275 Expr **Args, unsigned NumArgs) {
2276 unsigned Idx = 0;
2277 bool Format = false;
2278 ObjCStringFormatFamily SFFamily = Sel.getStringFormatFamily();
2279 if (SFFamily == ObjCStringFormatFamily::SFF_NSString) {
2280 Idx = 0;
2281 Format = true;
2282 }
2283 else if (Method) {
2284 for (const auto *I : Method->specific_attrs<FormatAttr>()) {
2285 if (S.GetFormatNSStringIdx(I, Idx)) {
2286 Format = true;
2287 break;
2288 }
2289 }
2290 }
2291 if (!Format || NumArgs <= Idx)
2292 return;
2293
2294 Expr *FormatExpr = Args[Idx];
2295 if (ObjCStringLiteral *OSL =
2296 dyn_cast<ObjCStringLiteral>(FormatExpr->IgnoreParenImpCasts())) {
2297 StringLiteral *FormatString = OSL->getString();
2298 if (S.FormatStringHasSArg(FormatString)) {
2299 S.Diag(FormatExpr->getExprLoc(), diag::warn_objc_cdirective_format_string)
2300 << "%s" << 0 << 0;
2301 if (Method)
2302 S.Diag(Method->getLocation(), diag::note_method_declared_at)
2303 << Method->getDeclName();
2304 }
2305 }
2306}
2307
2308/// \brief Build an Objective-C class message expression.
2309///
2310/// This routine takes care of both normal class messages and
2311/// class messages to the superclass.
2312///
2313/// \param ReceiverTypeInfo Type source information that describes the
2314/// receiver of this message. This may be NULL, in which case we are
2315/// sending to the superclass and \p SuperLoc must be a valid source
2316/// location.
2317
2318/// \param ReceiverType The type of the object receiving the
2319/// message. When \p ReceiverTypeInfo is non-NULL, this is the same
2320/// type as that refers to. For a superclass send, this is the type of
2321/// the superclass.
2322///
2323/// \param SuperLoc The location of the "super" keyword in a
2324/// superclass message.
2325///
2326/// \param Sel The selector to which the message is being sent.
2327///
2328/// \param Method The method that this class message is invoking, if
2329/// already known.
2330///
2331/// \param LBracLoc The location of the opening square bracket ']'.
2332///
2333/// \param RBracLoc The location of the closing square bracket ']'.
2334///
2335/// \param ArgsIn The message arguments.
2336ExprResult Sema::BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
2337 QualType ReceiverType,
2338 SourceLocation SuperLoc,
2339 Selector Sel,
2340 ObjCMethodDecl *Method,
2341 SourceLocation LBracLoc,
2342 ArrayRef<SourceLocation> SelectorLocs,
2343 SourceLocation RBracLoc,
2344 MultiExprArg ArgsIn,
2345 bool isImplicit) {
2346 SourceLocation Loc = SuperLoc.isValid()? SuperLoc
2347 : ReceiverTypeInfo->getTypeLoc().getSourceRange().getBegin();
2348 if (LBracLoc.isInvalid()) {
2349 Diag(Loc, diag::err_missing_open_square_message_send)
2350 << FixItHint::CreateInsertion(Loc, "[");
2351 LBracLoc = Loc;
2352 }
2353 SourceLocation SelLoc;
2354 if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
2355 SelLoc = SelectorLocs.front();
2356 else
2357 SelLoc = Loc;
2358
2359 if (ReceiverType->isDependentType()) {
2360 // If the receiver type is dependent, we can't type-check anything
2361 // at this point. Build a dependent expression.
2362 unsigned NumArgs = ArgsIn.size();
2363 Expr **Args = ArgsIn.data();
2364 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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 2364, __PRETTY_FUNCTION__))
;
2365 return ObjCMessageExpr::Create(
2366 Context, ReceiverType, VK_RValue, LBracLoc, ReceiverTypeInfo, Sel,
2367 SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs), RBracLoc,
2368 isImplicit);
2369 }
2370
2371 // Find the class to which we are sending this message.
2372 ObjCInterfaceDecl *Class = nullptr;
2373 const ObjCObjectType *ClassType = ReceiverType->getAs<ObjCObjectType>();
2374 if (!ClassType || !(Class = ClassType->getInterface())) {
2375 Diag(Loc, diag::err_invalid_receiver_class_message)
2376 << ReceiverType;
2377 return ExprError();
2378 }
2379 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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 2379, __PRETTY_FUNCTION__))
;
2380 // objc++ diagnoses during typename annotation.
2381 if (!getLangOpts().CPlusPlus)
2382 (void)DiagnoseUseOfDecl(Class, SelLoc);
2383 // Find the method we are messaging.
2384 if (!Method) {
2385 SourceRange TypeRange
2386 = SuperLoc.isValid()? SourceRange(SuperLoc)
2387 : ReceiverTypeInfo->getTypeLoc().getSourceRange();
2388 if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class),
2389 (getLangOpts().ObjCAutoRefCount
2390 ? diag::err_arc_receiver_forward_class
2391 : diag::warn_receiver_forward_class),
2392 TypeRange)) {
2393 // A forward class used in messaging is treated as a 'Class'
2394 Method = LookupFactoryMethodInGlobalPool(Sel,
2395 SourceRange(LBracLoc, RBracLoc));
2396 if (Method && !getLangOpts().ObjCAutoRefCount)
2397 Diag(Method->getLocation(), diag::note_method_sent_forward_class)
2398 << Method->getDeclName();
2399 }
2400 if (!Method)
2401 Method = Class->lookupClassMethod(Sel);
2402
2403 // If we have an implementation in scope, check "private" methods.
2404 if (!Method)
2405 Method = Class->lookupPrivateClassMethod(Sel);
2406
2407 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2408 return ExprError();
2409 }
2410
2411 // Check the argument types and determine the result type.
2412 QualType ReturnType;
2413 ExprValueKind VK = VK_RValue;
2414
2415 unsigned NumArgs = ArgsIn.size();
2416 Expr **Args = ArgsIn.data();
2417 if (CheckMessageArgumentTypes(ReceiverType, MultiExprArg(Args, NumArgs),
2418 Sel, SelectorLocs,
2419 Method, true,
2420 SuperLoc.isValid(), LBracLoc, RBracLoc,
2421 SourceRange(),
2422 ReturnType, VK))
2423 return ExprError();
2424
2425 if (Method && !Method->getReturnType()->isVoidType() &&
2426 RequireCompleteType(LBracLoc, Method->getReturnType(),
2427 diag::err_illegal_message_expr_incomplete_type))
2428 return ExprError();
2429
2430 // Warn about explicit call of +initialize on its own class. But not on 'super'.
2431 if (Method && Method->getMethodFamily() == OMF_initialize) {
2432 if (!SuperLoc.isValid()) {
2433 const ObjCInterfaceDecl *ID =
2434 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext());
2435 if (ID == Class) {
2436 Diag(Loc, diag::warn_direct_initialize_call);
2437 Diag(Method->getLocation(), diag::note_method_declared_at)
2438 << Method->getDeclName();
2439 }
2440 }
2441 else if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2442 // [super initialize] is allowed only within an +initialize implementation
2443 if (CurMeth->getMethodFamily() != OMF_initialize) {
2444 Diag(Loc, diag::warn_direct_super_initialize_call);
2445 Diag(Method->getLocation(), diag::note_method_declared_at)
2446 << Method->getDeclName();
2447 Diag(CurMeth->getLocation(), diag::note_method_declared_at)
2448 << CurMeth->getDeclName();
2449 }
2450 }
2451 }
2452
2453 DiagnoseCStringFormatDirectiveInObjCAPI(*this, Method, Sel, Args, NumArgs);
2454
2455 // Construct the appropriate ObjCMessageExpr.
2456 ObjCMessageExpr *Result;
2457 if (SuperLoc.isValid())
2458 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2459 SuperLoc, /*IsInstanceSuper=*/false,
2460 ReceiverType, Sel, SelectorLocs,
2461 Method, makeArrayRef(Args, NumArgs),
2462 RBracLoc, isImplicit);
2463 else {
2464 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2465 ReceiverTypeInfo, Sel, SelectorLocs,
2466 Method, makeArrayRef(Args, NumArgs),
2467 RBracLoc, isImplicit);
2468 if (!isImplicit)
2469 checkCocoaAPI(*this, Result);
2470 }
2471 return MaybeBindToTemporary(Result);
2472}
2473
2474// ActOnClassMessage - used for both unary and keyword messages.
2475// ArgExprs is optional - if it is present, the number of expressions
2476// is obtained from Sel.getNumArgs().
2477ExprResult Sema::ActOnClassMessage(Scope *S,
2478 ParsedType Receiver,
2479 Selector Sel,
2480 SourceLocation LBracLoc,
2481 ArrayRef<SourceLocation> SelectorLocs,
2482 SourceLocation RBracLoc,
2483 MultiExprArg Args) {
2484 TypeSourceInfo *ReceiverTypeInfo;
2485 QualType ReceiverType = GetTypeFromParser(Receiver, &ReceiverTypeInfo);
2486 if (ReceiverType.isNull())
2487 return ExprError();
2488
2489 if (!ReceiverTypeInfo)
2490 ReceiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType, LBracLoc);
2491
2492 return BuildClassMessage(ReceiverTypeInfo, ReceiverType,
2493 /*SuperLoc=*/SourceLocation(), Sel,
2494 /*Method=*/nullptr, LBracLoc, SelectorLocs, RBracLoc,
2495 Args);
2496}
2497
2498ExprResult Sema::BuildInstanceMessageImplicit(Expr *Receiver,
2499 QualType ReceiverType,
2500 SourceLocation Loc,
2501 Selector Sel,
2502 ObjCMethodDecl *Method,
2503 MultiExprArg Args) {
2504 return BuildInstanceMessage(Receiver, ReceiverType,
2505 /*SuperLoc=*/!Receiver ? Loc : SourceLocation(),
2506 Sel, Method, Loc, Loc, Loc, Args,
2507 /*isImplicit=*/true);
2508}
2509
2510/// \brief Build an Objective-C instance message expression.
2511///
2512/// This routine takes care of both normal instance messages and
2513/// instance messages to the superclass instance.
2514///
2515/// \param Receiver The expression that computes the object that will
2516/// receive this message. This may be empty, in which case we are
2517/// sending to the superclass instance and \p SuperLoc must be a valid
2518/// source location.
2519///
2520/// \param ReceiverType The (static) type of the object receiving the
2521/// message. When a \p Receiver expression is provided, this is the
2522/// same type as that expression. For a superclass instance send, this
2523/// is a pointer to the type of the superclass.
2524///
2525/// \param SuperLoc The location of the "super" keyword in a
2526/// superclass instance message.
2527///
2528/// \param Sel The selector to which the message is being sent.
2529///
2530/// \param Method The method that this instance message is invoking, if
2531/// already known.
2532///
2533/// \param LBracLoc The location of the opening square bracket ']'.
2534///
2535/// \param RBracLoc The location of the closing square bracket ']'.
2536///
2537/// \param ArgsIn The message arguments.
2538ExprResult Sema::BuildInstanceMessage(Expr *Receiver,
2539 QualType ReceiverType,
2540 SourceLocation SuperLoc,
2541 Selector Sel,
2542 ObjCMethodDecl *Method,
2543 SourceLocation LBracLoc,
2544 ArrayRef<SourceLocation> SelectorLocs,
2545 SourceLocation RBracLoc,
2546 MultiExprArg ArgsIn,
2547 bool isImplicit) {
2548 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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 2550, __PRETTY_FUNCTION__))
1
Within the expansion of the macro 'assert':
a
Assuming 'Receiver' is null
2549 "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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 2550, __PRETTY_FUNCTION__))
2550 "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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 2550, __PRETTY_FUNCTION__))
;
2551
2552 // The location of the receiver.
2553 SourceLocation Loc = SuperLoc.isValid()? SuperLoc : Receiver->getLocStart();
2
'?' condition is true
2554 SourceRange RecRange =
2555 SuperLoc.isValid()? SuperLoc : Receiver->getSourceRange();
3
'?' condition is true
2556 SourceLocation SelLoc;
2557 if (!SelectorLocs.empty() && SelectorLocs.front().isValid())
4
Assuming the condition is false
2558 SelLoc = SelectorLocs.front();
2559 else
2560 SelLoc = Loc;
2561
2562 if (LBracLoc.isInvalid()) {
5
Taking false branch
2563 Diag(Loc, diag::err_missing_open_square_message_send)
2564 << FixItHint::CreateInsertion(Loc, "[");
2565 LBracLoc = Loc;
2566 }
2567
2568 // If we have a receiver expression, perform appropriate promotions
2569 // and determine receiver type.
2570 if (Receiver) {
6
Taking false branch
2571 if (Receiver->hasPlaceholderType()) {
2572 ExprResult Result;
2573 if (Receiver->getType() == Context.UnknownAnyTy)
2574 Result = forceUnknownAnyToType(Receiver, Context.getObjCIdType());
2575 else
2576 Result = CheckPlaceholderExpr(Receiver);
2577 if (Result.isInvalid()) return ExprError();
2578 Receiver = Result.get();
2579 }
2580
2581 if (Receiver->isTypeDependent()) {
2582 // If the receiver is type-dependent, we can't type-check anything
2583 // at this point. Build a dependent expression.
2584 unsigned NumArgs = ArgsIn.size();
2585 Expr **Args = ArgsIn.data();
2586 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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 2586, __PRETTY_FUNCTION__))
;
2587 return ObjCMessageExpr::Create(
2588 Context, Context.DependentTy, VK_RValue, LBracLoc, Receiver, Sel,
2589 SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs),
2590 RBracLoc, isImplicit);
2591 }
2592
2593 // If necessary, apply function/array conversion to the receiver.
2594 // C99 6.7.5.3p[7,8].
2595 ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver);
2596 if (Result.isInvalid())
2597 return ExprError();
2598 Receiver = Result.get();
2599 ReceiverType = Receiver->getType();
2600
2601 // If the receiver is an ObjC pointer, a block pointer, or an
2602 // __attribute__((NSObject)) pointer, we don't need to do any
2603 // special conversion in order to look up a receiver.
2604 if (ReceiverType->isObjCRetainableType()) {
2605 // do nothing
2606 } else if (!getLangOpts().ObjCAutoRefCount &&
2607 !Context.getObjCIdType().isNull() &&
2608 (ReceiverType->isPointerType() ||
2609 ReceiverType->isIntegerType())) {
2610 // Implicitly convert integers and pointers to 'id' but emit a warning.
2611 // But not in ARC.
2612 Diag(Loc, diag::warn_bad_receiver_type)
2613 << ReceiverType
2614 << Receiver->getSourceRange();
2615 if (ReceiverType->isPointerType()) {
2616 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2617 CK_CPointerToObjCPointerCast).get();
2618 } else {
2619 // TODO: specialized warning on null receivers?
2620 bool IsNull = Receiver->isNullPointerConstant(Context,
2621 Expr::NPC_ValueDependentIsNull);
2622 CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer;
2623 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2624 Kind).get();
2625 }
2626 ReceiverType = Receiver->getType();
2627 } else if (getLangOpts().CPlusPlus) {
2628 // The receiver must be a complete type.
2629 if (RequireCompleteType(Loc, Receiver->getType(),
2630 diag::err_incomplete_receiver_type))
2631 return ExprError();
2632
2633 ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver);
2634 if (result.isUsable()) {
2635 Receiver = result.get();
2636 ReceiverType = Receiver->getType();
2637 }
2638 }
2639 }
2640
2641 // There's a somewhat weird interaction here where we assume that we
2642 // won't actually have a method unless we also don't need to do some
2643 // of the more detailed type-checking on the receiver.
2644
2645 if (!Method) {
7
Assuming 'Method' is non-null
8
Taking false branch
2646 // Handle messages to id and __kindof types (where we use the
2647 // global method pool).
2648 const ObjCObjectType *typeBound = nullptr;
2649 bool receiverIsIdLike = ReceiverType->isObjCIdOrObjectKindOfType(Context,
2650 typeBound);
2651 if (receiverIsIdLike || ReceiverType->isBlockPointerType() ||
2652 (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) {
2653 SmallVector<ObjCMethodDecl*, 4> Methods;
2654 // If we have a type bound, further filter the methods.
2655 CollectMultipleMethodsInGlobalPool(Sel, Methods, true/*InstanceFirst*/,
2656 true/*CheckTheOther*/, typeBound);
2657 if (!Methods.empty()) {
2658 // We choose the first method as the initial candidate, then try to
2659 // select a better one.
2660 Method = Methods[0];
2661
2662 if (ObjCMethodDecl *BestMethod =
2663 SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(), Methods))
2664 Method = BestMethod;
2665
2666 if (!AreMultipleMethodsInGlobalPool(Sel, Method,
2667 SourceRange(LBracLoc, RBracLoc),
2668 receiverIsIdLike, Methods))
2669 DiagnoseUseOfDecl(Method, SelLoc);
2670 }
2671 } else if (ReceiverType->isObjCClassOrClassKindOfType() ||
2672 ReceiverType->isObjCQualifiedClassType()) {
2673 // Handle messages to Class.
2674 // We allow sending a message to a qualified Class ("Class<foo>"), which
2675 // is ok as long as one of the protocols implements the selector (if not,
2676 // warn).
2677 if (!ReceiverType->isObjCClassOrClassKindOfType()) {
2678 const ObjCObjectPointerType *QClassTy
2679 = ReceiverType->getAsObjCQualifiedClassType();
2680 // Search protocols for class methods.
2681 Method = LookupMethodInQualifiedType(Sel, QClassTy, false);
2682 if (!Method) {
2683 Method = LookupMethodInQualifiedType(Sel, QClassTy, true);
2684 // warn if instance method found for a Class message.
2685 if (Method) {
2686 Diag(SelLoc, diag::warn_instance_method_on_class_found)
2687 << Method->getSelector() << Sel;
2688 Diag(Method->getLocation(), diag::note_method_declared_at)
2689 << Method->getDeclName();
2690 }
2691 }
2692 } else {
2693 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2694 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) {
2695 // First check the public methods in the class interface.
2696 Method = ClassDecl->lookupClassMethod(Sel);
2697
2698 if (!Method)
2699 Method = ClassDecl->lookupPrivateClassMethod(Sel);
2700 }
2701 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2702 return ExprError();
2703 }
2704 if (!Method) {
2705 // If not messaging 'self', look for any factory method named 'Sel'.
2706 if (!Receiver || !isSelfExpr(Receiver)) {
2707 // If no class (factory) method was found, check if an _instance_
2708 // method of the same name exists in the root class only.
2709 SmallVector<ObjCMethodDecl*, 4> Methods;
2710 CollectMultipleMethodsInGlobalPool(Sel, Methods,
2711 false/*InstanceFirst*/,
2712 true/*CheckTheOther*/);
2713 if (!Methods.empty()) {
2714 // We choose the first method as the initial candidate, then try
2715 // to select a better one.
2716 Method = Methods[0];
2717
2718 // If we find an instance method, emit waring.
2719 if (Method->isInstanceMethod()) {
2720 if (const ObjCInterfaceDecl *ID =
2721 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
2722 if (ID->getSuperClass())
2723 Diag(SelLoc, diag::warn_root_inst_method_not_found)
2724 << Sel << SourceRange(LBracLoc, RBracLoc);
2725 }
2726 }
2727
2728 if (ObjCMethodDecl *BestMethod =
2729 SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(),
2730 Methods))
2731 Method = BestMethod;
2732 }
2733 }
2734 }
2735 }
2736 } else {
2737 ObjCInterfaceDecl *ClassDecl = nullptr;
2738
2739 // We allow sending a message to a qualified ID ("id<foo>"), which is ok as
2740 // long as one of the protocols implements the selector (if not, warn).
2741 // And as long as message is not deprecated/unavailable (warn if it is).
2742 if (const ObjCObjectPointerType *QIdTy
2743 = ReceiverType->getAsObjCQualifiedIdType()) {
2744 // Search protocols for instance methods.
2745 Method = LookupMethodInQualifiedType(Sel, QIdTy, true);
2746 if (!Method)
2747 Method = LookupMethodInQualifiedType(Sel, QIdTy, false);
2748 if (Method && DiagnoseUseOfDecl(Method, SelLoc))
2749 return ExprError();
2750 } else if (const ObjCObjectPointerType *OCIType
2751 = ReceiverType->getAsObjCInterfacePointerType()) {
2752 // We allow sending a message to a pointer to an interface (an object).
2753 ClassDecl = OCIType->getInterfaceDecl();
2754
2755 // Try to complete the type. Under ARC, this is a hard error from which
2756 // we don't try to recover.
2757 // FIXME: In the non-ARC case, this will still be a hard error if the
2758 // definition is found in a module that's not visible.
2759 const ObjCInterfaceDecl *forwardClass = nullptr;
2760 if (RequireCompleteType(Loc, OCIType->getPointeeType(),
2761 getLangOpts().ObjCAutoRefCount
2762 ? diag::err_arc_receiver_forward_instance
2763 : diag::warn_receiver_forward_instance,
2764 Receiver? Receiver->getSourceRange()
2765 : SourceRange(SuperLoc))) {
2766 if (getLangOpts().ObjCAutoRefCount)
2767 return ExprError();
2768
2769 forwardClass = OCIType->getInterfaceDecl();
2770 Diag(Receiver ? Receiver->getLocStart()
2771 : SuperLoc, diag::note_receiver_is_id);
2772 Method = nullptr;
2773 } else {
2774 Method = ClassDecl->lookupInstanceMethod(Sel);
2775 }
2776
2777 if (!Method)
2778 // Search protocol qualifiers.
2779 Method = LookupMethodInQualifiedType(Sel, OCIType, true);
2780
2781 if (!Method) {
2782 // If we have implementations in scope, check "private" methods.
2783 Method = ClassDecl->lookupPrivateMethod(Sel);
2784
2785 if (!Method && getLangOpts().ObjCAutoRefCount) {
2786 Diag(SelLoc, diag::err_arc_may_not_respond)
2787 << OCIType->getPointeeType() << Sel << RecRange
2788 << SourceRange(SelectorLocs.front(), SelectorLocs.back());
2789 return ExprError();
2790 }
2791
2792 if (!Method && (!Receiver || !isSelfExpr(Receiver))) {
2793 // If we still haven't found a method, look in the global pool. This
2794 // behavior isn't very desirable, however we need it for GCC
2795 // compatibility. FIXME: should we deviate??
2796 if (OCIType->qual_empty()) {
2797 SmallVector<ObjCMethodDecl*, 4> Methods;
2798 CollectMultipleMethodsInGlobalPool(Sel, Methods,
2799 true/*InstanceFirst*/,
2800 false/*CheckTheOther*/);
2801 if (!Methods.empty()) {
2802 // We choose the first method as the initial candidate, then try
2803 // to select a better one.
2804 Method = Methods[0];
2805
2806 if (ObjCMethodDecl *BestMethod =
2807 SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(),
2808 Methods))
2809 Method = BestMethod;
2810
2811 AreMultipleMethodsInGlobalPool(Sel, Method,
2812 SourceRange(LBracLoc, RBracLoc),
2813 true/*receiverIdOrClass*/,
2814 Methods);
2815 }
2816 if (Method && !forwardClass)
2817 Diag(SelLoc, diag::warn_maynot_respond)
2818 << OCIType->getInterfaceDecl()->getIdentifier()
2819 << Sel << RecRange;
2820 }
2821 }
2822 }
2823 if (Method && DiagnoseUseOfDecl(Method, SelLoc, forwardClass))
2824 return ExprError();
2825 } else {
2826 // Reject other random receiver types (e.g. structs).
2827 Diag(Loc, diag::err_bad_receiver_type)
2828 << ReceiverType << Receiver->getSourceRange();
2829 return ExprError();
2830 }
2831 }
2832 }
2833
2834 FunctionScopeInfo *DIFunctionScopeInfo =
2835 (Method && Method->getMethodFamily() == OMF_init)
9
Assuming the condition is false
10
'?' condition is false
2836 ? getEnclosingFunction() : nullptr;
2837
2838 if (DIFunctionScopeInfo &&
2839 DIFunctionScopeInfo->ObjCIsDesignatedInit &&
2840 (SuperLoc.isValid() || isSelfExpr(Receiver))) {
2841 bool isDesignatedInitChain = false;
2842 if (SuperLoc.isValid()) {
2843 if (const ObjCObjectPointerType *
2844 OCIType = ReceiverType->getAsObjCInterfacePointerType()) {
2845 if (const ObjCInterfaceDecl *ID = OCIType->getInterfaceDecl()) {
2846 // Either we know this is a designated initializer or we
2847 // conservatively assume it because we don't know for sure.
2848 if (!ID->declaresOrInheritsDesignatedInitializers() ||
2849 ID->isDesignatedInitializer(Sel)) {
2850 isDesignatedInitChain = true;
2851 DIFunctionScopeInfo->ObjCWarnForNoDesignatedInitChain = false;
2852 }
2853 }
2854 }
2855 }
2856 if (!isDesignatedInitChain) {
2857 const ObjCMethodDecl *InitMethod = nullptr;
2858 bool isDesignated =
2859 getCurMethodDecl()->isDesignatedInitializerForTheInterface(&InitMethod);
2860 assert(isDesignated && InitMethod)((isDesignated && InitMethod) ? static_cast<void>
(0) : __assert_fail ("isDesignated && InitMethod", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 2860, __PRETTY_FUNCTION__))
;
2861 (void)isDesignated;
2862 Diag(SelLoc, SuperLoc.isValid() ?
2863 diag::warn_objc_designated_init_non_designated_init_call :
2864 diag::warn_objc_designated_init_non_super_designated_init_call);
2865 Diag(InitMethod->getLocation(),
2866 diag::note_objc_designated_init_marked_here);
2867 }
2868 }
2869
2870 if (DIFunctionScopeInfo &&
2871 DIFunctionScopeInfo->ObjCIsSecondaryInit &&
2872 (SuperLoc.isValid() || isSelfExpr(Receiver))) {
2873 if (SuperLoc.isValid()) {
2874 Diag(SelLoc, diag::warn_objc_secondary_init_super_init_call);
2875 } else {
2876 DIFunctionScopeInfo->ObjCWarnForNoInitDelegation = false;
2877 }
2878 }
2879
2880 // Check the message arguments.
2881 unsigned NumArgs = ArgsIn.size();
2882 Expr **Args = ArgsIn.data();
2883 QualType ReturnType;
2884 ExprValueKind VK = VK_RValue;
2885 bool ClassMessage = (ReceiverType->isObjCClassType() ||
2886 ReceiverType->isObjCQualifiedClassType());
2887 if (CheckMessageArgumentTypes(ReceiverType, MultiExprArg(Args, NumArgs),
11
Assuming the condition is false
12
Taking false branch
2888 Sel, SelectorLocs, Method,
2889 ClassMessage, SuperLoc.isValid(),
2890 LBracLoc, RBracLoc, RecRange, ReturnType, VK))
2891 return ExprError();
2892
2893 if (Method && !Method->getReturnType()->isVoidType() &&
13
Assuming the condition is false
14
Taking false branch
2894 RequireCompleteType(LBracLoc, Method->getReturnType(),
2895 diag::err_illegal_message_expr_incomplete_type))
2896 return ExprError();
2897
2898 // In ARC, forbid the user from sending messages to
2899 // retain/release/autorelease/dealloc/retainCount explicitly.
2900 if (getLangOpts().ObjCAutoRefCount) {
15
Assuming the condition is false
16
Taking false branch
2901 ObjCMethodFamily family =
2902 (Method ? Method->getMethodFamily() : Sel.getMethodFamily());
2903 switch (family) {
2904 case OMF_init:
2905 if (Method)
2906 checkInitMethod(Method, ReceiverType);
2907
2908 case OMF_None:
2909 case OMF_alloc:
2910 case OMF_copy:
2911 case OMF_finalize:
2912 case OMF_mutableCopy:
2913 case OMF_new:
2914 case OMF_self:
2915 case OMF_initialize:
2916 break;
2917
2918 case OMF_dealloc:
2919 case OMF_retain:
2920 case OMF_release:
2921 case OMF_autorelease:
2922 case OMF_retainCount:
2923 Diag(SelLoc, diag::err_arc_illegal_explicit_message)
2924 << Sel << RecRange;
2925 break;
2926
2927 case OMF_performSelector:
2928 if (Method && NumArgs >= 1) {
2929 if (const auto *SelExp =
2930 dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens())) {
2931 Selector ArgSel = SelExp->getSelector();
2932 ObjCMethodDecl *SelMethod =
2933 LookupInstanceMethodInGlobalPool(ArgSel,
2934 SelExp->getSourceRange());
2935 if (!SelMethod)
2936 SelMethod =
2937 LookupFactoryMethodInGlobalPool(ArgSel,
2938 SelExp->getSourceRange());
2939 if (SelMethod) {
2940 ObjCMethodFamily SelFamily = SelMethod->getMethodFamily();
2941 switch (SelFamily) {
2942 case OMF_alloc:
2943 case OMF_copy:
2944 case OMF_mutableCopy:
2945 case OMF_new:
2946 case OMF_self:
2947 case OMF_init:
2948 // Issue error, unless ns_returns_not_retained.
2949 if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
2950 // selector names a +1 method
2951 Diag(SelLoc,
2952 diag::err_arc_perform_selector_retains);
2953 Diag(SelMethod->getLocation(), diag::note_method_declared_at)
2954 << SelMethod->getDeclName();
2955 }
2956 break;
2957 default:
2958 // +0 call. OK. unless ns_returns_retained.
2959 if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) {
2960 // selector names a +1 method
2961 Diag(SelLoc,
2962 diag::err_arc_perform_selector_retains);
2963 Diag(SelMethod->getLocation(), diag::note_method_declared_at)
2964 << SelMethod->getDeclName();
2965 }
2966 break;
2967 }
2968 }
2969 } else {
2970 // error (may leak).
2971 Diag(SelLoc, diag::warn_arc_perform_selector_leaks);
2972 Diag(Args[0]->getExprLoc(), diag::note_used_here);
2973 }
2974 }
2975 break;
2976 }
2977 }
2978
2979 DiagnoseCStringFormatDirectiveInObjCAPI(*this, Method, Sel, Args, NumArgs);
2980
2981 // Construct the appropriate ObjCMessageExpr instance.
2982 ObjCMessageExpr *Result;
2983 if (SuperLoc.isValid())
17
Taking true branch
2984 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2985 SuperLoc, /*IsInstanceSuper=*/true,
2986 ReceiverType, Sel, SelectorLocs, Method,
2987 makeArrayRef(Args, NumArgs), RBracLoc,
2988 isImplicit);
2989 else {
2990 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2991 Receiver, Sel, SelectorLocs, Method,
2992 makeArrayRef(Args, NumArgs), RBracLoc,
2993 isImplicit);
2994 if (!isImplicit)
2995 checkCocoaAPI(*this, Result);
2996 }
2997
2998 if (getLangOpts().ObjCAutoRefCount) {
18
Assuming the condition is true
19
Taking true branch
2999 // In ARC, annotate delegate init calls.
3000 if (Result->getMethodFamily() == OMF_init &&
20
Assuming the condition is true
3001 (SuperLoc.isValid() || isSelfExpr(Receiver))) {
21
Passing null pointer value via 1st parameter 'RExpr'
22
Calling 'Sema::isSelfExpr'
3002 // Only consider init calls *directly* in init implementations,
3003 // not within blocks.
3004 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(CurContext);
3005 if (method && method->getMethodFamily() == OMF_init) {
3006 // The implicit assignment to self means we also don't want to
3007 // consume the result.
3008 Result->setDelegateInitCall(true);
3009 return Result;
3010 }
3011 }
3012
3013 // In ARC, check for message sends which are likely to introduce
3014 // retain cycles.
3015 checkRetainCycles(Result);
3016
3017 if (!isImplicit && Method) {
3018 if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {
3019 bool IsWeak =
3020 Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak;
3021 if (!IsWeak && Sel.isUnarySelector())
3022 IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak;
3023 if (IsWeak &&
3024 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, LBracLoc))
3025 getCurFunction()->recordUseOfWeak(Result, Prop);
3026 }
3027 }
3028 }
3029
3030 CheckObjCCircularContainer(Result);
3031
3032 return MaybeBindToTemporary(Result);
3033}
3034
3035static void RemoveSelectorFromWarningCache(Sema &S, Expr* Arg) {
3036 if (ObjCSelectorExpr *OSE =
3037 dyn_cast<ObjCSelectorExpr>(Arg->IgnoreParenCasts())) {
3038 Selector Sel = OSE->getSelector();
3039 SourceLocation Loc = OSE->getAtLoc();
3040 auto Pos = S.ReferencedSelectors.find(Sel);
3041 if (Pos != S.ReferencedSelectors.end() && Pos->second == Loc)
3042 S.ReferencedSelectors.erase(Pos);
3043 }
3044}
3045
3046// ActOnInstanceMessage - used for both unary and keyword messages.
3047// ArgExprs is optional - if it is present, the number of expressions
3048// is obtained from Sel.getNumArgs().
3049ExprResult Sema::ActOnInstanceMessage(Scope *S,
3050 Expr *Receiver,
3051 Selector Sel,
3052 SourceLocation LBracLoc,
3053 ArrayRef<SourceLocation> SelectorLocs,
3054 SourceLocation RBracLoc,
3055 MultiExprArg Args) {
3056 if (!Receiver)
3057 return ExprError();
3058
3059 // A ParenListExpr can show up while doing error recovery with invalid code.
3060 if (isa<ParenListExpr>(Receiver)) {
3061 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver);
3062 if (Result.isInvalid()) return ExprError();
3063 Receiver = Result.get();
3064 }
3065
3066 if (RespondsToSelectorSel.isNull()) {
3067 IdentifierInfo *SelectorId = &Context.Idents.get("respondsToSelector");
3068 RespondsToSelectorSel = Context.Selectors.getUnarySelector(SelectorId);
3069 }
3070 if (Sel == RespondsToSelectorSel)
3071 RemoveSelectorFromWarningCache(*this, Args[0]);
3072
3073 return BuildInstanceMessage(Receiver, Receiver->getType(),
3074 /*SuperLoc=*/SourceLocation(), Sel,
3075 /*Method=*/nullptr, LBracLoc, SelectorLocs,
3076 RBracLoc, Args);
3077}
3078
3079enum ARCConversionTypeClass {
3080 /// int, void, struct A
3081 ACTC_none,
3082
3083 /// id, void (^)()
3084 ACTC_retainable,
3085
3086 /// id*, id***, void (^*)(),
3087 ACTC_indirectRetainable,
3088
3089 /// void* might be a normal C type, or it might a CF type.
3090 ACTC_voidPtr,
3091
3092 /// struct A*
3093 ACTC_coreFoundation
3094};
3095
3096static bool isAnyRetainable(ARCConversionTypeClass ACTC) {
3097 return (ACTC == ACTC_retainable ||
3098 ACTC == ACTC_coreFoundation ||
3099 ACTC == ACTC_voidPtr);
3100}
3101
3102static bool isAnyCLike(ARCConversionTypeClass ACTC) {
3103 return ACTC == ACTC_none ||
3104 ACTC == ACTC_voidPtr ||
3105 ACTC == ACTC_coreFoundation;
3106}
3107
3108static ARCConversionTypeClass classifyTypeForARCConversion(QualType type) {
3109 bool isIndirect = false;
3110
3111 // Ignore an outermost reference type.
3112 if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
3113 type = ref->getPointeeType();
3114 isIndirect = true;
3115 }
3116
3117 // Drill through pointers and arrays recursively.
3118 while (true) {
3119 if (const PointerType *ptr = type->getAs<PointerType>()) {
3120 type = ptr->getPointeeType();
3121
3122 // The first level of pointer may be the innermost pointer on a CF type.
3123 if (!isIndirect) {
3124 if (type->isVoidType()) return ACTC_voidPtr;
3125 if (type->isRecordType()) return ACTC_coreFoundation;
3126 }
3127 } else if (const ArrayType *array = type->getAsArrayTypeUnsafe()) {
3128 type = QualType(array->getElementType()->getBaseElementTypeUnsafe(), 0);
3129 } else {
3130 break;
3131 }
3132 isIndirect = true;
3133 }
3134
3135 if (isIndirect) {
3136 if (type->isObjCARCBridgableType())
3137 return ACTC_indirectRetainable;
3138 return ACTC_none;
3139 }
3140
3141 if (type->isObjCARCBridgableType())
3142 return ACTC_retainable;
3143
3144 return ACTC_none;
3145}
3146
3147namespace {
3148 /// A result from the cast checker.
3149 enum ACCResult {
3150 /// Cannot be casted.
3151 ACC_invalid,
3152
3153 /// Can be safely retained or not retained.
3154 ACC_bottom,
3155
3156 /// Can be casted at +0.
3157 ACC_plusZero,
3158
3159 /// Can be casted at +1.
3160 ACC_plusOne
3161 };
3162 ACCResult merge(ACCResult left, ACCResult right) {
3163 if (left == right) return left;
3164 if (left == ACC_bottom) return right;
3165 if (right == ACC_bottom) return left;
3166 return ACC_invalid;
3167 }
3168
3169 /// A checker which white-lists certain expressions whose conversion
3170 /// to or from retainable type would otherwise be forbidden in ARC.
3171 class ARCCastChecker : public StmtVisitor<ARCCastChecker, ACCResult> {
3172 typedef StmtVisitor<ARCCastChecker, ACCResult> super;
3173
3174 ASTContext &Context;
3175 ARCConversionTypeClass SourceClass;
3176 ARCConversionTypeClass TargetClass;
3177 bool Diagnose;
3178
3179 static bool isCFType(QualType type) {
3180 // Someday this can use ns_bridged. For now, it has to do this.
3181 return type->isCARCBridgableType();
3182 }
3183
3184 public:
3185 ARCCastChecker(ASTContext &Context, ARCConversionTypeClass source,
3186 ARCConversionTypeClass target, bool diagnose)
3187 : Context(Context), SourceClass(source), TargetClass(target),
3188 Diagnose(diagnose) {}
3189
3190 using super::Visit;
3191 ACCResult Visit(Expr *e) {
3192 return super::Visit(e->IgnoreParens());
3193 }
3194
3195 ACCResult VisitStmt(Stmt *s) {
3196 return ACC_invalid;
3197 }
3198
3199 /// Null pointer constants can be casted however you please.
3200 ACCResult VisitExpr(Expr *e) {
3201 if (e->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull))
3202 return ACC_bottom;
3203 return ACC_invalid;
3204 }
3205
3206 /// Objective-C string literals can be safely casted.
3207 ACCResult VisitObjCStringLiteral(ObjCStringLiteral *e) {
3208 // If we're casting to any retainable type, go ahead. Global
3209 // strings are immune to retains, so this is bottom.
3210 if (isAnyRetainable(TargetClass)) return ACC_bottom;
3211
3212 return ACC_invalid;
3213 }
3214
3215 /// Look through certain implicit and explicit casts.
3216 ACCResult VisitCastExpr(CastExpr *e) {
3217 switch (e->getCastKind()) {
3218 case CK_NullToPointer:
3219 return ACC_bottom;
3220
3221 case CK_NoOp:
3222 case CK_LValueToRValue:
3223 case CK_BitCast:
3224 case CK_CPointerToObjCPointerCast:
3225 case CK_BlockPointerToObjCPointerCast:
3226 case CK_AnyPointerToBlockPointerCast:
3227 return Visit(e->getSubExpr());
3228
3229 default:
3230 return ACC_invalid;
3231 }
3232 }
3233
3234 /// Look through unary extension.
3235 ACCResult VisitUnaryExtension(UnaryOperator *e) {
3236 return Visit(e->getSubExpr());
3237 }
3238
3239 /// Ignore the LHS of a comma operator.
3240 ACCResult VisitBinComma(BinaryOperator *e) {
3241 return Visit(e->getRHS());
3242 }
3243
3244 /// Conditional operators are okay if both sides are okay.
3245 ACCResult VisitConditionalOperator(ConditionalOperator *e) {
3246 ACCResult left = Visit(e->getTrueExpr());
3247 if (left == ACC_invalid) return ACC_invalid;
3248 return merge(left, Visit(e->getFalseExpr()));
3249 }
3250
3251 /// Look through pseudo-objects.
3252 ACCResult VisitPseudoObjectExpr(PseudoObjectExpr *e) {
3253 // If we're getting here, we should always have a result.
3254 return Visit(e->getResultExpr());
3255 }
3256
3257 /// Statement expressions are okay if their result expression is okay.
3258 ACCResult VisitStmtExpr(StmtExpr *e) {
3259 return Visit(e->getSubStmt()->body_back());
3260 }
3261
3262 /// Some declaration references are okay.
3263 ACCResult VisitDeclRefExpr(DeclRefExpr *e) {
3264 VarDecl *var = dyn_cast<VarDecl>(e->getDecl());
3265 // References to global constants are okay.
3266 if (isAnyRetainable(TargetClass) &&
3267 isAnyRetainable(SourceClass) &&
3268 var &&
3269 var->getStorageClass() == SC_Extern &&
3270 var->getType().isConstQualified()) {
3271
3272 // In system headers, they can also be assumed to be immune to retains.
3273 // These are things like 'kCFStringTransformToLatin'.
3274 if (Context.getSourceManager().isInSystemHeader(var->getLocation()))
3275 return ACC_bottom;
3276
3277 return ACC_plusZero;
3278 }
3279
3280 // Nothing else.
3281 return ACC_invalid;
3282 }
3283
3284 /// Some calls are okay.
3285 ACCResult VisitCallExpr(CallExpr *e) {
3286 if (FunctionDecl *fn = e->getDirectCallee())
3287 if (ACCResult result = checkCallToFunction(fn))
3288 return result;
3289
3290 return super::VisitCallExpr(e);
3291 }
3292
3293 ACCResult checkCallToFunction(FunctionDecl *fn) {
3294 // Require a CF*Ref return type.
3295 if (!isCFType(fn->getReturnType()))
3296 return ACC_invalid;
3297
3298 if (!isAnyRetainable(TargetClass))
3299 return ACC_invalid;
3300
3301 // Honor an explicit 'not retained' attribute.
3302 if (fn->hasAttr<CFReturnsNotRetainedAttr>())
3303 return ACC_plusZero;
3304
3305 // Honor an explicit 'retained' attribute, except that for
3306 // now we're not going to permit implicit handling of +1 results,
3307 // because it's a bit frightening.
3308 if (fn->hasAttr<CFReturnsRetainedAttr>())
3309 return Diagnose ? ACC_plusOne
3310 : ACC_invalid; // ACC_plusOne if we start accepting this
3311
3312 // Recognize this specific builtin function, which is used by CFSTR.
3313 unsigned builtinID = fn->getBuiltinID();
3314 if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString)
3315 return ACC_bottom;
3316
3317 // Otherwise, don't do anything implicit with an unaudited function.
3318 if (!fn->hasAttr<CFAuditedTransferAttr>())
3319 return ACC_invalid;
3320
3321 // Otherwise, it's +0 unless it follows the create convention.
3322 if (ento::coreFoundation::followsCreateRule(fn))
3323 return Diagnose ? ACC_plusOne
3324 : ACC_invalid; // ACC_plusOne if we start accepting this
3325
3326 return ACC_plusZero;
3327 }
3328
3329 ACCResult VisitObjCMessageExpr(ObjCMessageExpr *e) {
3330 return checkCallToMethod(e->getMethodDecl());
3331 }
3332
3333 ACCResult VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *e) {
3334 ObjCMethodDecl *method;
3335 if (e->isExplicitProperty())
3336 method = e->getExplicitProperty()->getGetterMethodDecl();
3337 else
3338 method = e->getImplicitPropertyGetter();
3339 return checkCallToMethod(method);
3340 }
3341
3342 ACCResult checkCallToMethod(ObjCMethodDecl *method) {
3343 if (!method) return ACC_invalid;
3344
3345 // Check for message sends to functions returning CF types. We
3346 // just obey the Cocoa conventions with these, even though the
3347 // return type is CF.
3348 if (!isAnyRetainable(TargetClass) || !isCFType(method->getReturnType()))
3349 return ACC_invalid;
3350
3351 // If the method is explicitly marked not-retained, it's +0.
3352 if (method->hasAttr<CFReturnsNotRetainedAttr>())
3353 return ACC_plusZero;
3354
3355 // If the method is explicitly marked as returning retained, or its
3356 // selector follows a +1 Cocoa convention, treat it as +1.
3357 if (method->hasAttr<CFReturnsRetainedAttr>())
3358 return ACC_plusOne;
3359
3360 switch (method->getSelector().getMethodFamily()) {
3361 case OMF_alloc:
3362 case OMF_copy:
3363 case OMF_mutableCopy:
3364 case OMF_new:
3365 return ACC_plusOne;
3366
3367 default:
3368 // Otherwise, treat it as +0.
3369 return ACC_plusZero;
3370 }
3371 }
3372 };
3373} // end anonymous namespace
3374
3375bool Sema::isKnownName(StringRef name) {
3376 if (name.empty())
3377 return false;
3378 LookupResult R(*this, &Context.Idents.get(name), SourceLocation(),
3379 Sema::LookupOrdinaryName);
3380 return LookupName(R, TUScope, false);
3381}
3382
3383static void addFixitForObjCARCConversion(Sema &S,
3384 DiagnosticBuilder &DiagB,
3385 Sema::CheckedConversionKind CCK,
3386 SourceLocation afterLParen,
3387 QualType castType,
3388 Expr *castExpr,
3389 Expr *realCast,
3390 const char *bridgeKeyword,
3391 const char *CFBridgeName) {
3392 // We handle C-style and implicit casts here.
3393 switch (CCK) {
3394 case Sema::CCK_ImplicitConversion:
3395 case Sema::CCK_CStyleCast:
3396 case Sema::CCK_OtherCast:
3397 break;
3398 case Sema::CCK_FunctionalCast:
3399 return;
3400 }
3401
3402 if (CFBridgeName) {
3403 if (CCK == Sema::CCK_OtherCast) {
3404 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
3405 SourceRange range(NCE->getOperatorLoc(),
3406 NCE->getAngleBrackets().getEnd());
3407 SmallString<32> BridgeCall;
3408
3409 SourceManager &SM = S.getSourceManager();
3410 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
3411 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
3412 BridgeCall += ' ';
3413
3414 BridgeCall += CFBridgeName;
3415 DiagB.AddFixItHint(FixItHint::CreateReplacement(range, BridgeCall));
3416 }
3417 return;
3418 }
3419 Expr *castedE = castExpr;
3420 if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(castedE))
3421 castedE = CCE->getSubExpr();
3422 castedE = castedE->IgnoreImpCasts();
3423 SourceRange range = castedE->getSourceRange();
3424
3425 SmallString<32> BridgeCall;
3426
3427 SourceManager &SM = S.getSourceManager();
3428 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
3429 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
3430 BridgeCall += ' ';
3431
3432 BridgeCall += CFBridgeName;
3433
3434 if (isa<ParenExpr>(castedE)) {
3435 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3436 BridgeCall));
3437 } else {
3438 BridgeCall += '(';
3439 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3440 BridgeCall));
3441 DiagB.AddFixItHint(FixItHint::CreateInsertion(
3442 S.getLocForEndOfToken(range.getEnd()),
3443 ")"));
3444 }
3445 return;
3446 }
3447
3448 if (CCK == Sema::CCK_CStyleCast) {
3449 DiagB.AddFixItHint(FixItHint::CreateInsertion(afterLParen, bridgeKeyword));
3450 } else if (CCK == Sema::CCK_OtherCast) {
3451 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
3452 std::string castCode = "(";
3453 castCode += bridgeKeyword;
3454 castCode += castType.getAsString();
3455 castCode += ")";
3456 SourceRange Range(NCE->getOperatorLoc(),
3457 NCE->getAngleBrackets().getEnd());
3458 DiagB.AddFixItHint(FixItHint::CreateReplacement(Range, castCode));
3459 }
3460 } else {
3461 std::string castCode = "(";
3462 castCode += bridgeKeyword;
3463 castCode += castType.getAsString();
3464 castCode += ")";
3465 Expr *castedE = castExpr->IgnoreImpCasts();
3466 SourceRange range = castedE->getSourceRange();
3467 if (isa<ParenExpr>(castedE)) {
3468 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3469 castCode));
3470 } else {
3471 castCode += "(";
3472 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
3473 castCode));
3474 DiagB.AddFixItHint(FixItHint::CreateInsertion(
3475 S.getLocForEndOfToken(range.getEnd()),
3476 ")"));
3477 }
3478 }
3479}
3480
3481template <typename T>
3482static inline T *getObjCBridgeAttr(const TypedefType *TD) {
3483 TypedefNameDecl *TDNDecl = TD->getDecl();
3484 QualType QT = TDNDecl->getUnderlyingType();
3485 if (QT->isPointerType()) {
3486 QT = QT->getPointeeType();
3487 if (const RecordType *RT = QT->getAs<RecordType>())
3488 if (RecordDecl *RD = RT->getDecl()->getMostRecentDecl())
3489 return RD->getAttr<T>();
3490 }
3491 return nullptr;
3492}
3493
3494static ObjCBridgeRelatedAttr *ObjCBridgeRelatedAttrFromType(QualType T,
3495 TypedefNameDecl *&TDNDecl) {
3496 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3497 TDNDecl = TD->getDecl();
3498 if (ObjCBridgeRelatedAttr *ObjCBAttr =
3499 getObjCBridgeAttr<ObjCBridgeRelatedAttr>(TD))
3500 return ObjCBAttr;
3501 T = TDNDecl->getUnderlyingType();
3502 }
3503 return nullptr;
3504}
3505
3506static void
3507diagnoseObjCARCConversion(Sema &S, SourceRange castRange,
3508 QualType castType, ARCConversionTypeClass castACTC,
3509 Expr *castExpr, Expr *realCast,
3510 ARCConversionTypeClass exprACTC,
3511 Sema::CheckedConversionKind CCK) {
3512 SourceLocation loc =
3513 (castRange.isValid() ? castRange.getBegin() : castExpr->getExprLoc());
3514
3515 if (S.makeUnavailableInSystemHeader(loc,
3516 UnavailableAttr::IR_ARCForbiddenConversion))
3517 return;
3518
3519 QualType castExprType = castExpr->getType();
3520 // Defer emitting a diagnostic for bridge-related casts; that will be
3521 // handled by CheckObjCBridgeRelatedConversions.
3522 TypedefNameDecl *TDNDecl = nullptr;
3523 if ((castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable &&
3524 ObjCBridgeRelatedAttrFromType(castType, TDNDecl)) ||
3525 (exprACTC == ACTC_coreFoundation && castACTC == ACTC_retainable &&
3526 ObjCBridgeRelatedAttrFromType(castExprType, TDNDecl)))
3527 return;
3528
3529 unsigned srcKind = 0;
3530 switch (exprACTC) {
3531 case ACTC_none:
3532 case ACTC_coreFoundation:
3533 case ACTC_voidPtr:
3534 srcKind = (castExprType->isPointerType() ? 1 : 0);
3535 break;
3536 case ACTC_retainable:
3537 srcKind = (castExprType->isBlockPointerType() ? 2 : 3);
3538 break;
3539 case ACTC_indirectRetainable:
3540 srcKind = 4;
3541 break;
3542 }
3543
3544 // Check whether this could be fixed with a bridge cast.
3545 SourceLocation afterLParen = S.getLocForEndOfToken(castRange.getBegin());
3546 SourceLocation noteLoc = afterLParen.isValid() ? afterLParen : loc;
3547
3548 // Bridge from an ARC type to a CF type.
3549 if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {
3550
3551 S.Diag(loc, diag::err_arc_cast_requires_bridge)
3552 << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit
3553 << 2 // of C pointer type
3554 << castExprType
3555 << unsigned(castType->isBlockPointerType()) // to ObjC|block type
3556 << castType
3557 << castRange
3558 << castExpr->getSourceRange();
3559 bool br = S.isKnownName("CFBridgingRelease");
3560 ACCResult CreateRule =
3561 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3562 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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 3562, __PRETTY_FUNCTION__))
;
3563 if (CreateRule != ACC_plusOne)
3564 {
3565 DiagnosticBuilder DiagB =
3566 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3567 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3568
3569 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3570 castType, castExpr, realCast, "__bridge ",
3571 nullptr);
3572 }
3573 if (CreateRule != ACC_plusZero)
3574 {
3575 DiagnosticBuilder DiagB =
3576 (CCK == Sema::CCK_OtherCast && !br) ?
3577 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer) << castExprType :
3578 S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3579 diag::note_arc_bridge_transfer)
3580 << castExprType << br;
3581
3582 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3583 castType, castExpr, realCast, "__bridge_transfer ",
3584 br ? "CFBridgingRelease" : nullptr);
3585 }
3586
3587 return;
3588 }
3589
3590 // Bridge from a CF type to an ARC type.
3591 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {
3592 bool br = S.isKnownName("CFBridgingRetain");
3593 S.Diag(loc, diag::err_arc_cast_requires_bridge)
3594 << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit
3595 << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type
3596 << castExprType
3597 << 2 // to C pointer type
3598 << castType
3599 << castRange
3600 << castExpr->getSourceRange();
3601 ACCResult CreateRule =
3602 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3603 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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 3603, __PRETTY_FUNCTION__))
;
3604 if (CreateRule != ACC_plusOne)
3605 {
3606 DiagnosticBuilder DiagB =
3607 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3608 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3609 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3610 castType, castExpr, realCast, "__bridge ",
3611 nullptr);
3612 }
3613 if (CreateRule != ACC_plusZero)
3614 {
3615 DiagnosticBuilder DiagB =
3616 (CCK == Sema::CCK_OtherCast && !br) ?
3617 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType :
3618 S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3619 diag::note_arc_bridge_retained)
3620 << castType << br;
3621
3622 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3623 castType, castExpr, realCast, "__bridge_retained ",
3624 br ? "CFBridgingRetain" : nullptr);
3625 }
3626
3627 return;
3628 }
3629
3630 S.Diag(loc, diag::err_arc_mismatched_cast)
3631 << (CCK != Sema::CCK_ImplicitConversion)
3632 << srcKind << castExprType << castType
3633 << castRange << castExpr->getSourceRange();
3634}
3635
3636template <typename TB>
3637static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr,
3638 bool &HadTheAttribute, bool warn) {
3639 QualType T = castExpr->getType();
3640 HadTheAttribute = false;
3641 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3642 TypedefNameDecl *TDNDecl = TD->getDecl();
3643 if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {
3644 if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {
3645 HadTheAttribute = true;
3646 if (Parm->isStr("id"))
3647 return true;
3648
3649 NamedDecl *Target = nullptr;
3650 // Check for an existing type with this name.
3651 LookupResult R(S, DeclarationName(Parm), SourceLocation(),
3652 Sema::LookupOrdinaryName);
3653 if (S.LookupName(R, S.TUScope)) {
3654 Target = R.getFoundDecl();
3655 if (Target && isa<ObjCInterfaceDecl>(Target)) {
3656 ObjCInterfaceDecl *ExprClass = cast<ObjCInterfaceDecl>(Target);
3657 if (const ObjCObjectPointerType *InterfacePointerType =
3658 castType->getAsObjCInterfacePointerType()) {
3659 ObjCInterfaceDecl *CastClass
3660 = InterfacePointerType->getObjectType()->getInterface();
3661 if ((CastClass == ExprClass) ||
3662 (CastClass && CastClass->isSuperClassOf(ExprClass)))
3663 return true;
3664 if (warn)
3665 S.Diag(castExpr->getLocStart(), diag::warn_objc_invalid_bridge)
3666 << T << Target->getName() << castType->getPointeeType();
3667 return false;
3668 } else if (castType->isObjCIdType() ||
3669 (S.Context.ObjCObjectAdoptsQTypeProtocols(
3670 castType, ExprClass)))
3671 // ok to cast to 'id'.
3672 // casting to id<p-list> is ok if bridge type adopts all of
3673 // p-list protocols.
3674 return true;
3675 else {
3676 if (warn) {
3677 S.Diag(castExpr->getLocStart(), diag::warn_objc_invalid_bridge)
3678 << T << Target->getName() << castType;
3679 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3680 S.Diag(Target->getLocStart(), diag::note_declared_at);
3681 }
3682 return false;
3683 }
3684 }
3685 } else if (!castType->isObjCIdType()) {
3686 S.Diag(castExpr->getLocStart(), diag::err_objc_cf_bridged_not_interface)
3687 << castExpr->getType() << Parm;
3688 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3689 if (Target)
3690 S.Diag(Target->getLocStart(), diag::note_declared_at);
3691 }
3692 return true;
3693 }
3694 return false;
3695 }
3696 T = TDNDecl->getUnderlyingType();
3697 }
3698 return true;
3699}
3700
3701template <typename TB>
3702static bool CheckObjCBridgeCFCast(Sema &S, QualType castType, Expr *castExpr,
3703 bool &HadTheAttribute, bool warn) {
3704 QualType T = castType;
3705 HadTheAttribute = false;
3706 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) {
3707 TypedefNameDecl *TDNDecl = TD->getDecl();
3708 if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {
3709 if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {
3710 HadTheAttribute = true;
3711 if (Parm->isStr("id"))
3712 return true;
3713
3714 NamedDecl *Target = nullptr;
3715 // Check for an existing type with this name.
3716 LookupResult R(S, DeclarationName(Parm), SourceLocation(),
3717 Sema::LookupOrdinaryName);
3718 if (S.LookupName(R, S.TUScope)) {
3719 Target = R.getFoundDecl();
3720 if (Target && isa<ObjCInterfaceDecl>(Target)) {
3721 ObjCInterfaceDecl *CastClass = cast<ObjCInterfaceDecl>(Target);
3722 if (const ObjCObjectPointerType *InterfacePointerType =
3723 castExpr->getType()->getAsObjCInterfacePointerType()) {
3724 ObjCInterfaceDecl *ExprClass
3725 = InterfacePointerType->getObjectType()->getInterface();
3726 if ((CastClass == ExprClass) ||
3727 (ExprClass && CastClass->isSuperClassOf(ExprClass)))
3728 return true;
3729 if (warn) {
3730 S.Diag(castExpr->getLocStart(), diag::warn_objc_invalid_bridge_to_cf)
3731 << castExpr->getType()->getPointeeType() << T;
3732 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3733 }
3734 return false;
3735 } else if (castExpr->getType()->isObjCIdType() ||
3736 (S.Context.QIdProtocolsAdoptObjCObjectProtocols(
3737 castExpr->getType(), CastClass)))
3738 // ok to cast an 'id' expression to a CFtype.
3739 // ok to cast an 'id<plist>' expression to CFtype provided plist
3740 // adopts all of CFtype's ObjetiveC's class plist.
3741 return true;
3742 else {
3743 if (warn) {
3744 S.Diag(castExpr->getLocStart(), diag::warn_objc_invalid_bridge_to_cf)
3745 << castExpr->getType() << castType;
3746 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3747 S.Diag(Target->getLocStart(), diag::note_declared_at);
3748 }
3749 return false;
3750 }
3751 }
3752 }
3753 S.Diag(castExpr->getLocStart(), diag::err_objc_ns_bridged_invalid_cfobject)
3754 << castExpr->getType() << castType;
3755 S.Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3756 if (Target)
3757 S.Diag(Target->getLocStart(), diag::note_declared_at);
3758 return true;
3759 }
3760 return false;
3761 }
3762 T = TDNDecl->getUnderlyingType();
3763 }
3764 return true;
3765}
3766
3767void Sema::CheckTollFreeBridgeCast(QualType castType, Expr *castExpr) {
3768 if (!getLangOpts().ObjC1)
3769 return;
3770 // warn in presence of __bridge casting to or from a toll free bridge cast.
3771 ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExpr->getType());
3772 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType);
3773 if (castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) {
3774 bool HasObjCBridgeAttr;
3775 bool ObjCBridgeAttrWillNotWarn =
3776 CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3777 false);
3778 if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr)
3779 return;
3780 bool HasObjCBridgeMutableAttr;
3781 bool ObjCBridgeMutableAttrWillNotWarn =
3782 CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3783 HasObjCBridgeMutableAttr, false);
3784 if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr)
3785 return;
3786
3787 if (HasObjCBridgeAttr)
3788 CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3789 true);
3790 else if (HasObjCBridgeMutableAttr)
3791 CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3792 HasObjCBridgeMutableAttr, true);
3793 }
3794 else if (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable) {
3795 bool HasObjCBridgeAttr;
3796 bool ObjCBridgeAttrWillNotWarn =
3797 CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3798 false);
3799 if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr)
3800 return;
3801 bool HasObjCBridgeMutableAttr;
3802 bool ObjCBridgeMutableAttrWillNotWarn =
3803 CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3804 HasObjCBridgeMutableAttr, false);
3805 if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr)
3806 return;
3807
3808 if (HasObjCBridgeAttr)
3809 CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr,
3810 true);
3811 else if (HasObjCBridgeMutableAttr)
3812 CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr,
3813 HasObjCBridgeMutableAttr, true);
3814 }
3815}
3816
3817void Sema::CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr) {
3818 QualType SrcType = castExpr->getType();
3819 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(castExpr)) {
3820 if (PRE->isExplicitProperty()) {
3821 if (ObjCPropertyDecl *PDecl = PRE->getExplicitProperty())
3822 SrcType = PDecl->getType();
3823 }
3824 else if (PRE->isImplicitProperty()) {
3825 if (ObjCMethodDecl *Getter = PRE->getImplicitPropertyGetter())
3826 SrcType = Getter->getReturnType();
3827 }
3828 }
3829
3830 ARCConversionTypeClass srcExprACTC = classifyTypeForARCConversion(SrcType);
3831 ARCConversionTypeClass castExprACTC = classifyTypeForARCConversion(castType);
3832 if (srcExprACTC != ACTC_retainable || castExprACTC != ACTC_coreFoundation)
3833 return;
3834 CheckObjCBridgeRelatedConversions(castExpr->getLocStart(),
3835 castType, SrcType, castExpr);
3836}
3837
3838bool Sema::CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
3839 CastKind &Kind) {
3840 if (!getLangOpts().ObjC1)
3841 return false;
3842 ARCConversionTypeClass exprACTC =
3843 classifyTypeForARCConversion(castExpr->getType());
3844 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType);
3845 if ((castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) ||
3846 (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable)) {
3847 CheckTollFreeBridgeCast(castType, castExpr);
3848 Kind = (castACTC == ACTC_coreFoundation) ? CK_BitCast
3849 : CK_CPointerToObjCPointerCast;
3850 return true;
3851 }
3852 return false;
3853}
3854
3855bool Sema::checkObjCBridgeRelatedComponents(SourceLocation Loc,
3856 QualType DestType, QualType SrcType,
3857 ObjCInterfaceDecl *&RelatedClass,
3858 ObjCMethodDecl *&ClassMethod,
3859 ObjCMethodDecl *&InstanceMethod,
3860 TypedefNameDecl *&TDNDecl,
3861 bool CfToNs, bool Diagnose) {
3862 QualType T = CfToNs ? SrcType : DestType;
3863 ObjCBridgeRelatedAttr *ObjCBAttr = ObjCBridgeRelatedAttrFromType(T, TDNDecl);
3864 if (!ObjCBAttr)
3865 return false;
3866
3867 IdentifierInfo *RCId = ObjCBAttr->getRelatedClass();
3868 IdentifierInfo *CMId = ObjCBAttr->getClassMethod();
3869 IdentifierInfo *IMId = ObjCBAttr->getInstanceMethod();
3870 if (!RCId)
3871 return false;
3872 NamedDecl *Target = nullptr;
3873 // Check for an existing type with this name.
3874 LookupResult R(*this, DeclarationName(RCId), SourceLocation(),
3875 Sema::LookupOrdinaryName);
3876 if (!LookupName(R, TUScope)) {
3877 if (Diagnose) {
3878 Diag(Loc, diag::err_objc_bridged_related_invalid_class) << RCId
3879 << SrcType << DestType;
3880 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3881 }
3882 return false;
3883 }
3884 Target = R.getFoundDecl();
3885 if (Target && isa<ObjCInterfaceDecl>(Target))
3886 RelatedClass = cast<ObjCInterfaceDecl>(Target);
3887 else {
3888 if (Diagnose) {
3889 Diag(Loc, diag::err_objc_bridged_related_invalid_class_name) << RCId
3890 << SrcType << DestType;
3891 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3892 if (Target)
3893 Diag(Target->getLocStart(), diag::note_declared_at);
3894 }
3895 return false;
3896 }
3897
3898 // Check for an existing class method with the given selector name.
3899 if (CfToNs && CMId) {
3900 Selector Sel = Context.Selectors.getUnarySelector(CMId);
3901 ClassMethod = RelatedClass->lookupMethod(Sel, false);
3902 if (!ClassMethod) {
3903 if (Diagnose) {
3904 Diag(Loc, diag::err_objc_bridged_related_known_method)
3905 << SrcType << DestType << Sel << false;
3906 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3907 }
3908 return false;
3909 }
3910 }
3911
3912 // Check for an existing instance method with the given selector name.
3913 if (!CfToNs && IMId) {
3914 Selector Sel = Context.Selectors.getNullarySelector(IMId);
3915 InstanceMethod = RelatedClass->lookupMethod(Sel, true);
3916 if (!InstanceMethod) {
3917 if (Diagnose) {
3918 Diag(Loc, diag::err_objc_bridged_related_known_method)
3919 << SrcType << DestType << Sel << true;
3920 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3921 }
3922 return false;
3923 }
3924 }
3925 return true;
3926}
3927
3928bool
3929Sema::CheckObjCBridgeRelatedConversions(SourceLocation Loc,
3930 QualType DestType, QualType SrcType,
3931 Expr *&SrcExpr, bool Diagnose) {
3932 ARCConversionTypeClass rhsExprACTC = classifyTypeForARCConversion(SrcType);
3933 ARCConversionTypeClass lhsExprACTC = classifyTypeForARCConversion(DestType);
3934 bool CfToNs = (rhsExprACTC == ACTC_coreFoundation && lhsExprACTC == ACTC_retainable);
3935 bool NsToCf = (rhsExprACTC == ACTC_retainable && lhsExprACTC == ACTC_coreFoundation);
3936 if (!CfToNs && !NsToCf)
3937 return false;
3938
3939 ObjCInterfaceDecl *RelatedClass;
3940 ObjCMethodDecl *ClassMethod = nullptr;
3941 ObjCMethodDecl *InstanceMethod = nullptr;
3942 TypedefNameDecl *TDNDecl = nullptr;
3943 if (!checkObjCBridgeRelatedComponents(Loc, DestType, SrcType, RelatedClass,
3944 ClassMethod, InstanceMethod, TDNDecl,
3945 CfToNs, Diagnose))
3946 return false;
3947
3948 if (CfToNs) {
3949 // Implicit conversion from CF to ObjC object is needed.
3950 if (ClassMethod) {
3951 if (Diagnose) {
3952 std::string ExpressionString = "[";
3953 ExpressionString += RelatedClass->getNameAsString();
3954 ExpressionString += " ";
3955 ExpressionString += ClassMethod->getSelector().getAsString();
3956 SourceLocation SrcExprEndLoc = getLocForEndOfToken(SrcExpr->getLocEnd());
3957 // Provide a fixit: [RelatedClass ClassMethod SrcExpr]
3958 Diag(Loc, diag::err_objc_bridged_related_known_method)
3959 << SrcType << DestType << ClassMethod->getSelector() << false
3960 << FixItHint::CreateInsertion(SrcExpr->getLocStart(), ExpressionString)
3961 << FixItHint::CreateInsertion(SrcExprEndLoc, "]");
3962 Diag(RelatedClass->getLocStart(), diag::note_declared_at);
3963 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
3964
3965 QualType receiverType = Context.getObjCInterfaceType(RelatedClass);
3966 // Argument.
3967 Expr *args[] = { SrcExpr };
3968 ExprResult msg = BuildClassMessageImplicit(receiverType, false,
3969 ClassMethod->getLocation(),
3970 ClassMethod->getSelector(), ClassMethod,
3971 MultiExprArg(args, 1));
3972 SrcExpr = msg.get();
3973 }
3974 return true;
3975 }
3976 }
3977 else {
3978 // Implicit conversion from ObjC type to CF object is needed.
3979 if (InstanceMethod) {
3980 if (Diagnose) {
3981 std::string ExpressionString;
3982 SourceLocation SrcExprEndLoc =
3983 getLocForEndOfToken(SrcExpr->getLocEnd());
3984 if (InstanceMethod->isPropertyAccessor())
3985 if (const ObjCPropertyDecl *PDecl =
3986 InstanceMethod->findPropertyDecl()) {
3987 // fixit: ObjectExpr.propertyname when it is aproperty accessor.
3988 ExpressionString = ".";
3989 ExpressionString += PDecl->getNameAsString();
3990 Diag(Loc, diag::err_objc_bridged_related_known_method)
3991 << SrcType << DestType << InstanceMethod->getSelector() << true
3992 << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString);
3993 }
3994 if (ExpressionString.empty()) {
3995 // Provide a fixit: [ObjectExpr InstanceMethod]
3996 ExpressionString = " ";
3997 ExpressionString += InstanceMethod->getSelector().getAsString();
3998 ExpressionString += "]";
3999
4000 Diag(Loc, diag::err_objc_bridged_related_known_method)
4001 << SrcType << DestType << InstanceMethod->getSelector() << true
4002 << FixItHint::CreateInsertion(SrcExpr->getLocStart(), "[")
4003 << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString);
4004 }
4005 Diag(RelatedClass->getLocStart(), diag::note_declared_at);
4006 Diag(TDNDecl->getLocStart(), diag::note_declared_at);
4007
4008 ExprResult msg =
4009 BuildInstanceMessageImplicit(SrcExpr, SrcType,
4010 InstanceMethod->getLocation(),
4011 InstanceMethod->getSelector(),
4012 InstanceMethod, None);
4013 SrcExpr = msg.get();
4014 }
4015 return true;
4016 }
4017 }
4018 return false;
4019}
4020
4021Sema::ARCConversionResult
4022Sema::CheckObjCARCConversion(SourceRange castRange, QualType castType,
4023 Expr *&castExpr, CheckedConversionKind CCK,
4024 bool Diagnose,
4025 bool DiagnoseCFAudited,
4026 BinaryOperatorKind Opc) {
4027 QualType castExprType = castExpr->getType();
4028
4029 // For the purposes of the classification, we assume reference types
4030 // will bind to temporaries.
4031 QualType effCastType = castType;
4032 if (const ReferenceType *ref = castType->getAs<ReferenceType>())
4033 effCastType = ref->getPointeeType();
4034
4035 ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExprType);
4036 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(effCastType);
4037 if (exprACTC == castACTC) {
4038 // Check for viability and report error if casting an rvalue to a
4039 // life-time qualifier.
4040 if (castACTC == ACTC_retainable &&
4041 (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) &&
4042 castType != castExprType) {
4043 const Type *DT = castType.getTypePtr();
4044 QualType QDT = castType;
4045 // We desugar some types but not others. We ignore those
4046 // that cannot happen in a cast; i.e. auto, and those which
4047 // should not be de-sugared; i.e typedef.
4048 if (const ParenType *PT = dyn_cast<ParenType>(DT))
4049 QDT = PT->desugar();
4050 else if (const TypeOfType *TP = dyn_cast<TypeOfType>(DT))
4051 QDT = TP->desugar();
4052 else if (const AttributedType *AT = dyn_cast<AttributedType>(DT))
4053 QDT = AT->desugar();
4054 if (QDT != castType &&
4055 QDT.getObjCLifetime() != Qualifiers::OCL_None) {
4056 if (Diagnose) {
4057 SourceLocation loc = (castRange.isValid() ? castRange.getBegin()
4058 : castExpr->getExprLoc());
4059 Diag(loc, diag::err_arc_nolifetime_behavior);
4060 }
4061 return ACR_error;
4062 }
4063 }
4064 return ACR_okay;
4065 }
4066
4067 if (isAnyCLike(exprACTC) && isAnyCLike(castACTC)) return ACR_okay;
4068
4069 // Allow all of these types to be cast to integer types (but not
4070 // vice-versa).
4071 if (castACTC == ACTC_none && castType->isIntegralType(Context))
4072 return ACR_okay;
4073
4074 // Allow casts between pointers to lifetime types (e.g., __strong id*)
4075 // and pointers to void (e.g., cv void *). Casting from void* to lifetime*
4076 // must be explicit.
4077 if (exprACTC == ACTC_indirectRetainable && castACTC == ACTC_voidPtr)
4078 return ACR_okay;
4079 if (castACTC == ACTC_indirectRetainable && exprACTC == ACTC_voidPtr &&
4080 CCK != CCK_ImplicitConversion)
4081 return ACR_okay;
4082
4083 switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) {
4084 // For invalid casts, fall through.
4085 case ACC_invalid:
4086 break;
4087
4088 // Do nothing for both bottom and +0.
4089 case ACC_bottom:
4090 case ACC_plusZero:
4091 return ACR_okay;
4092
4093 // If the result is +1, consume it here.
4094 case ACC_plusOne:
4095 castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(),
4096 CK_ARCConsumeObject, castExpr,
4097 nullptr, VK_RValue);
4098 Cleanup.setExprNeedsCleanups(true);
4099 return ACR_okay;
4100 }
4101
4102 // If this is a non-implicit cast from id or block type to a
4103 // CoreFoundation type, delay complaining in case the cast is used
4104 // in an acceptable context.
4105 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) &&
4106 CCK != CCK_ImplicitConversion)
4107 return ACR_unbridged;
4108
4109 // Issue a diagnostic about a missing @-sign when implicit casting a cstring
4110 // to 'NSString *', instead of falling through to report a "bridge cast"
4111 // diagnostic.
4112 if (castACTC == ACTC_retainable && exprACTC == ACTC_none &&
4113 ConversionToObjCStringLiteralCheck(castType, castExpr, Diagnose))
4114 return ACR_error;
4115
4116 // Do not issue "bridge cast" diagnostic when implicit casting
4117 // a retainable object to a CF type parameter belonging to an audited
4118 // CF API function. Let caller issue a normal type mismatched diagnostic
4119 // instead.
4120 if ((!DiagnoseCFAudited || exprACTC != ACTC_retainable ||
4121 castACTC != ACTC_coreFoundation) &&
4122 !(exprACTC == ACTC_voidPtr && castACTC == ACTC_retainable &&
4123 (Opc == BO_NE || Opc == BO_EQ))) {
4124 if (Diagnose)
4125 diagnoseObjCARCConversion(*this, castRange, castType, castACTC, castExpr,
4126 castExpr, exprACTC, CCK);
4127 return ACR_error;
4128 }
4129 return ACR_okay;
4130}
4131
4132/// Given that we saw an expression with the ARCUnbridgedCastTy
4133/// placeholder type, complain bitterly.
4134void Sema::diagnoseARCUnbridgedCast(Expr *e) {
4135 // We expect the spurious ImplicitCastExpr to already have been stripped.
4136 assert(!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast))((!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)) ?
static_cast<void> (0) : __assert_fail ("!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 4136, __PRETTY_FUNCTION__))
;
4137 CastExpr *realCast = cast<CastExpr>(e->IgnoreParens());
4138
4139 SourceRange castRange;
4140 QualType castType;
4141 CheckedConversionKind CCK;
4142
4143 if (CStyleCastExpr *cast = dyn_cast<CStyleCastExpr>(realCast)) {
4144 castRange = SourceRange(cast->getLParenLoc(), cast->getRParenLoc());
4145 castType = cast->getTypeAsWritten();
4146 CCK = CCK_CStyleCast;
4147 } else if (ExplicitCastExpr *cast = dyn_cast<ExplicitCastExpr>(realCast)) {
4148 castRange = cast->getTypeInfoAsWritten()->getTypeLoc().getSourceRange();
4149 castType = cast->getTypeAsWritten();
4150 CCK = CCK_OtherCast;
4151 } else {
4152 castType = cast->getType();
4153 CCK = CCK_ImplicitConversion;
4154 }
4155
4156 ARCConversionTypeClass castACTC =
4157 classifyTypeForARCConversion(castType.getNonReferenceType());
4158
4159 Expr *castExpr = realCast->getSubExpr();
4160 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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 4160, __PRETTY_FUNCTION__))
;
4161
4162 diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
4163 castExpr, realCast, ACTC_retainable, CCK);
4164}
4165
4166/// stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast
4167/// type, remove the placeholder cast.
4168Expr *Sema::stripARCUnbridgedCast(Expr *e) {
4169 assert(e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast))((e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)) ? static_cast
<void> (0) : __assert_fail ("e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 4169, __PRETTY_FUNCTION__))
;
4170
4171 if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) {
4172 Expr *sub = stripARCUnbridgedCast(pe->getSubExpr());
4173 return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub);
4174 } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) {
4175 assert(uo->getOpcode() == UO_Extension)((uo->getOpcode() == UO_Extension) ? static_cast<void>
(0) : __assert_fail ("uo->getOpcode() == UO_Extension", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 4175, __PRETTY_FUNCTION__))
;
4176 Expr *sub = stripARCUnbridgedCast(uo->getSubExpr());
4177 return new (Context) UnaryOperator(sub, UO_Extension, sub->getType(),
4178 sub->getValueKind(), sub->getObjectKind(),
4179 uo->getOperatorLoc());
4180 } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
4181 assert(!gse->isResultDependent())((!gse->isResultDependent()) ? static_cast<void> (0)
: __assert_fail ("!gse->isResultDependent()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 4181, __PRETTY_FUNCTION__))
;
4182
4183 unsigned n = gse->getNumAssocs();
4184 SmallVector<Expr*, 4> subExprs(n);
4185 SmallVector<TypeSourceInfo*, 4> subTypes(n);
4186 for (unsigned i = 0; i != n; ++i) {
4187 subTypes[i] = gse->getAssocTypeSourceInfo(i);
4188 Expr *sub = gse->getAssocExpr(i);
4189 if (i == gse->getResultIndex())
4190 sub = stripARCUnbridgedCast(sub);
4191 subExprs[i] = sub;
4192 }
4193
4194 return new (Context) GenericSelectionExpr(Context, gse->getGenericLoc(),
4195 gse->getControllingExpr(),
4196 subTypes, subExprs,
4197 gse->getDefaultLoc(),
4198 gse->getRParenLoc(),
4199 gse->containsUnexpandedParameterPack(),
4200 gse->getResultIndex());
4201 } else {
4202 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-5.0~svn296300/tools/clang/lib/Sema/SemaExprObjC.cpp"
, 4202, __PRETTY_FUNCTION__))
;
4203 return cast<ImplicitCastExpr>(e)->getSubExpr();
4204 }
4205}
4206
4207bool Sema::CheckObjCARCUnavailableWeakConversion(QualType castType,
4208 QualType exprType) {
4209 QualType canCastType =
4210 Context.getCanonicalType(castType).getUnqualifiedType();
4211 QualType canExprType =
4212 Context.getCanonicalType(exprType).getUnqualifiedType();
4213 if (isa<ObjCObjectPointerType>(canCastType) &&
4214 castType.getObjCLifetime() == Qualifiers::OCL_Weak &&
4215 canExprType->isObjCObjectPointerType()) {
4216 if (const ObjCObjectPointerType *ObjT =
4217 canExprType->getAs<ObjCObjectPointerType>())
4218 if (const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl())
4219 return !ObjI->isArcWeakrefUnavailable();
4220 }
4221 return true;
4222}
4223
4224/// Look for an ObjCReclaimReturnedObject cast and destroy it.
4225static Expr *maybeUndoReclaimObject(Expr *e) {
4226 // For now, we just undo operands that are *immediately* reclaim
4227 // expressions, which prevents the vast majority of potential
4228 // problems here. To catch them all, we'd need to rebuild arbitrary
4229 // value-propagating subexpressions --- we can't reliably rebuild
4230 // in-place because of expression sharing.
4231 if (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
4232 if (ice->getCastKind() == CK_ARCReclaimReturnedObject)
4233 return ice->getSubExpr();
4234
4235 return e;
4236}
4237
4238ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc,
4239 ObjCBridgeCastKind Kind,
4240 SourceLocation BridgeKeywordLoc,
4241 TypeSourceInfo *TSInfo,
4242 Expr *SubExpr) {
4243 ExprResult SubResult = UsualUnaryConversions(SubExpr);
4244 if (SubResult.isInvalid()) return ExprError();
4245 SubExpr = SubResult.get();
4246
4247 QualType T = TSInfo->getType();
4248 QualType FromType = SubExpr->getType();
4249
4250 CastKind CK;
4251
4252 bool MustConsume = false;
4253 if (T->isDependentType() || SubExpr->isTypeDependent()) {
4254 // Okay: we'll build a dependent expression type.
4255 CK = CK_Dependent;
4256 } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {
4257 // Casting CF -> id
4258 CK = (T->isBlockPointerType() ? CK_AnyPointerToBlockPointerCast
4259 : CK_CPointerToObjCPointerCast);
4260 switch (Kind) {
4261 case OBC_Bridge:
4262 break;
4263
4264 case OBC_BridgeRetained: {
4265 bool br = isKnownName("CFBridgingRelease");
4266 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
4267 << 2
4268 << FromType
4269 << (T->isBlockPointerType()? 1 : 0)
4270 << T
4271 << SubExpr->getSourceRange()
4272 << Kind;
4273 Diag(BridgeKeywordLoc, diag::note_arc_bridge)
4274 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge");
4275 Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer)
4276 << FromType << br
4277 << FixItHint::CreateReplacement(BridgeKeywordLoc,
4278 br ? "CFBridgingRelease "
4279 : "__bridge_transfer ");
4280
4281 Kind = OBC_Bridge;
4282 break;
4283 }
4284
4285 case OBC_BridgeTransfer:
4286 // We must consume the Objective-C object produced by the cast.
4287 MustConsume = true;
4288 break;
4289 }
4290 } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {
4291 // Okay: id -> CF
4292 CK = CK_BitCast;
4293 switch (Kind) {
4294 case OBC_Bridge:
4295 // Reclaiming a value that's going to be __bridge-casted to CF
4296 // is very dangerous, so we don't do it.
4297 SubExpr = maybeUndoReclaimObject(SubExpr);
4298 break;
4299
4300 case OBC_BridgeRetained:
4301 // Produce the object before casting it.
4302 SubExpr = ImplicitCastExpr::Create(Context, FromType,
4303 CK_ARCProduceObject,
4304 SubExpr, nullptr, VK_RValue);
4305 break;
4306
4307 case OBC_BridgeTransfer: {
4308 bool br = isKnownName("CFBridgingRetain");
4309 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
4310 << (FromType->isBlockPointerType()? 1 : 0)
4311 << FromType
4312 << 2
4313 << T
4314 << SubExpr->getSourceRange()
4315 << Kind;
4316
4317 Diag(BridgeKeywordLoc, diag::note_arc_bridge)
4318 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge ");
4319 Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained)
4320 << T << br
4321 << FixItHint::CreateReplacement(BridgeKeywordLoc,
4322 br ? "CFBridgingRetain " : "__bridge_retained");
4323
4324 Kind = OBC_Bridge;
4325 break;
4326 }
4327 }
4328 } else {
4329 Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible)
4330 << FromType << T << Kind
4331 << SubExpr->getSourceRange()
4332 << TSInfo->getTypeLoc().getSourceRange();
4333 return ExprError();
4334 }
4335
4336 Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK,
4337 BridgeKeywordLoc,
4338 TSInfo, SubExpr);
4339
4340 if (MustConsume) {
4341 Cleanup.setExprNeedsCleanups(true);
4342 Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result,
4343 nullptr, VK_RValue);
4344 }
4345
4346 return Result;
4347}
4348
4349ExprResult Sema::ActOnObjCBridgedCast(Scope *S,
4350 SourceLocation LParenLoc,
4351 ObjCBridgeCastKind Kind,
4352 SourceLocation BridgeKeywordLoc,
4353 ParsedType Type,
4354 SourceLocation RParenLoc,
4355 Expr *SubExpr) {
4356 TypeSourceInfo *TSInfo = nullptr;
4357 QualType T = GetTypeFromParser(Type, &TSInfo);
4358 if (Kind == OBC_Bridge)
4359 CheckTollFreeBridgeCast(T, SubExpr);
4360 if (!TSInfo)
4361 TSInfo = Context.getTrivialTypeSourceInfo(T, LParenLoc);
4362 return BuildObjCBridgedCast(LParenLoc, Kind, BridgeKeywordLoc, TSInfo,
4363 SubExpr);
4364}