blob: 3a05241c016b77a0334ed0102cbe8aaebf704165 [file] [log] [blame]
Chris Lattner85a932e2008-01-04 22:32:30 +00001//===--- 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 "Sema.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/DeclObjC.h"
Steve Narofff494b572008-05-29 21:12:08 +000017#include "clang/AST/ExprObjC.h"
Chris Lattner39c28bb2009-02-18 06:48:40 +000018#include "llvm/ADT/SmallString.h"
Steve Naroff61f72cb2009-03-09 21:12:44 +000019#include "clang/Lex/Preprocessor.h"
20
Chris Lattner85a932e2008-01-04 22:32:30 +000021using namespace clang;
22
Mike Stump1eb44332009-09-09 15:08:12 +000023Sema::ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
Chris Lattner39c28bb2009-02-18 06:48:40 +000024 ExprTy **strings,
Chris Lattner85a932e2008-01-04 22:32:30 +000025 unsigned NumStrings) {
Chris Lattner39c28bb2009-02-18 06:48:40 +000026 StringLiteral **Strings = reinterpret_cast<StringLiteral**>(strings);
27
Chris Lattnerf4b136f2009-02-18 06:13:04 +000028 // Most ObjC strings are formed out of a single piece. However, we *can*
29 // have strings formed out of multiple @ strings with multiple pptokens in
30 // each one, e.g. @"foo" "bar" @"baz" "qux" which need to be turned into one
31 // StringLiteral for ObjCStringLiteral to hold onto.
Chris Lattner39c28bb2009-02-18 06:48:40 +000032 StringLiteral *S = Strings[0];
Mike Stump1eb44332009-09-09 15:08:12 +000033
Chris Lattnerf4b136f2009-02-18 06:13:04 +000034 // If we have a multi-part string, merge it all together.
35 if (NumStrings != 1) {
Chris Lattner85a932e2008-01-04 22:32:30 +000036 // Concatenate objc strings.
Chris Lattner39c28bb2009-02-18 06:48:40 +000037 llvm::SmallString<128> StrBuf;
38 llvm::SmallVector<SourceLocation, 8> StrLocs;
Mike Stump1eb44332009-09-09 15:08:12 +000039
Chris Lattner726e1682009-02-18 05:49:11 +000040 for (unsigned i = 0; i != NumStrings; ++i) {
Chris Lattner39c28bb2009-02-18 06:48:40 +000041 S = Strings[i];
Mike Stump1eb44332009-09-09 15:08:12 +000042
Chris Lattner39c28bb2009-02-18 06:48:40 +000043 // ObjC strings can't be wide.
Chris Lattnerf4b136f2009-02-18 06:13:04 +000044 if (S->isWide()) {
45 Diag(S->getLocStart(), diag::err_cfstring_literal_not_string_constant)
46 << S->getSourceRange();
47 return true;
48 }
Mike Stump1eb44332009-09-09 15:08:12 +000049
Chris Lattner39c28bb2009-02-18 06:48:40 +000050 // Get the string data.
51 StrBuf.append(S->getStrData(), S->getStrData()+S->getByteLength());
Mike Stump1eb44332009-09-09 15:08:12 +000052
Chris Lattner39c28bb2009-02-18 06:48:40 +000053 // Get the locations of the string tokens.
54 StrLocs.append(S->tokloc_begin(), S->tokloc_end());
Mike Stump1eb44332009-09-09 15:08:12 +000055
Chris Lattner39c28bb2009-02-18 06:48:40 +000056 // Free the temporary string.
Ted Kremenek8189cde2009-02-07 01:47:29 +000057 S->Destroy(Context);
Chris Lattner85a932e2008-01-04 22:32:30 +000058 }
Mike Stump1eb44332009-09-09 15:08:12 +000059
Chris Lattner39c28bb2009-02-18 06:48:40 +000060 // Create the aggregate string with the appropriate content and location
61 // information.
62 S = StringLiteral::Create(Context, &StrBuf[0], StrBuf.size(), false,
Chris Lattner2085fd62009-02-18 06:40:38 +000063 Context.getPointerType(Context.CharTy),
Chris Lattner39c28bb2009-02-18 06:48:40 +000064 &StrLocs[0], StrLocs.size());
Chris Lattner85a932e2008-01-04 22:32:30 +000065 }
Mike Stump1eb44332009-09-09 15:08:12 +000066
Chris Lattner69039812009-02-18 06:01:06 +000067 // Verify that this composite string is acceptable for ObjC strings.
68 if (CheckObjCString(S))
Chris Lattner85a932e2008-01-04 22:32:30 +000069 return true;
Chris Lattnera0af1fe2009-02-18 06:06:56 +000070
71 // Initialize the constant string interface lazily. This assumes
Steve Naroffd9fd7642009-04-07 14:18:33 +000072 // the NSString interface is seen in this translation unit. Note: We
73 // don't use NSConstantString, since the runtime team considers this
74 // interface private (even though it appears in the header files).
Chris Lattnera0af1fe2009-02-18 06:06:56 +000075 QualType Ty = Context.getObjCConstantStringInterface();
76 if (!Ty.isNull()) {
Steve Naroff14108da2009-07-10 23:34:53 +000077 Ty = Context.getObjCObjectPointerType(Ty);
Chris Lattner13fd7e52008-06-21 21:44:18 +000078 } else {
Steve Naroffd9fd7642009-04-07 14:18:33 +000079 IdentifierInfo *NSIdent = &Context.Idents.get("NSString");
John McCallf36e02d2009-10-09 21:13:30 +000080 NamedDecl *IF = LookupSingleName(TUScope, NSIdent, LookupOrdinaryName);
Chris Lattnera0af1fe2009-02-18 06:06:56 +000081 if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) {
82 Context.setObjCConstantStringInterface(StrIF);
83 Ty = Context.getObjCConstantStringInterface();
Steve Naroff14108da2009-07-10 23:34:53 +000084 Ty = Context.getObjCObjectPointerType(Ty);
Chris Lattnera0af1fe2009-02-18 06:06:56 +000085 } else {
Steve Naroffd9fd7642009-04-07 14:18:33 +000086 // If there is no NSString interface defined then treat constant
Chris Lattnera0af1fe2009-02-18 06:06:56 +000087 // strings as untyped objects and let the runtime figure it out later.
88 Ty = Context.getObjCIdType();
89 }
Chris Lattner13fd7e52008-06-21 21:44:18 +000090 }
Mike Stump1eb44332009-09-09 15:08:12 +000091
Chris Lattnerf4b136f2009-02-18 06:13:04 +000092 return new (Context) ObjCStringLiteral(S, Ty, AtLocs[0]);
Chris Lattner85a932e2008-01-04 22:32:30 +000093}
94
Mike Stump1eb44332009-09-09 15:08:12 +000095Expr *Sema::BuildObjCEncodeExpression(SourceLocation AtLoc,
Anders Carlssonfc0f0212009-06-07 18:45:35 +000096 QualType EncodedType,
97 SourceLocation RParenLoc) {
98 QualType StrTy;
Mike Stump1eb44332009-09-09 15:08:12 +000099 if (EncodedType->isDependentType())
Anders Carlssonfc0f0212009-06-07 18:45:35 +0000100 StrTy = Context.DependentTy;
101 else {
102 std::string Str;
103 Context.getObjCEncodingForType(EncodedType, Str);
104
105 // The type of @encode is the same as the type of the corresponding string,
106 // which is an array type.
107 StrTy = Context.CharTy;
108 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
109 if (getLangOptions().CPlusPlus)
110 StrTy.addConst();
111 StrTy = Context.getConstantArrayType(StrTy, llvm::APInt(32, Str.size()+1),
112 ArrayType::Normal, 0);
113 }
Mike Stump1eb44332009-09-09 15:08:12 +0000114
Anders Carlssonfc0f0212009-06-07 18:45:35 +0000115 return new (Context) ObjCEncodeExpr(StrTy, EncodedType, AtLoc, RParenLoc);
116}
117
Chris Lattner85a932e2008-01-04 22:32:30 +0000118Sema::ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc,
119 SourceLocation EncodeLoc,
120 SourceLocation LParenLoc,
Chris Lattnera0af1fe2009-02-18 06:06:56 +0000121 TypeTy *ty,
Chris Lattner85a932e2008-01-04 22:32:30 +0000122 SourceLocation RParenLoc) {
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000123 // FIXME: Preserve type source info ?
124 QualType EncodedType = GetTypeFromParser(ty);
Chris Lattner85a932e2008-01-04 22:32:30 +0000125
Anders Carlssonfc0f0212009-06-07 18:45:35 +0000126 return BuildObjCEncodeExpression(AtLoc, EncodedType, RParenLoc);
Chris Lattner85a932e2008-01-04 22:32:30 +0000127}
128
129Sema::ExprResult Sema::ParseObjCSelectorExpression(Selector Sel,
130 SourceLocation AtLoc,
131 SourceLocation SelLoc,
132 SourceLocation LParenLoc,
133 SourceLocation RParenLoc) {
Mike Stump1eb44332009-09-09 15:08:12 +0000134 ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel,
Fariborz Jahanian835ed7f2009-08-22 21:13:55 +0000135 SourceRange(LParenLoc, RParenLoc), false);
Fariborz Jahanian7ff22de2009-06-16 16:25:00 +0000136 if (!Method)
137 Method = LookupFactoryMethodInGlobalPool(Sel,
138 SourceRange(LParenLoc, RParenLoc));
139 if (!Method)
140 Diag(SelLoc, diag::warn_undeclared_selector) << Sel;
141
Chris Lattnera0af1fe2009-02-18 06:06:56 +0000142 QualType Ty = Context.getObjCSelType();
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +0000143 return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc);
Chris Lattner85a932e2008-01-04 22:32:30 +0000144}
145
146Sema::ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
147 SourceLocation AtLoc,
148 SourceLocation ProtoLoc,
149 SourceLocation LParenLoc,
150 SourceLocation RParenLoc) {
Douglas Gregor6e378de2009-04-23 23:18:26 +0000151 ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId);
Chris Lattner85a932e2008-01-04 22:32:30 +0000152 if (!PDecl) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000153 Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;
Chris Lattner85a932e2008-01-04 22:32:30 +0000154 return true;
155 }
Mike Stump1eb44332009-09-09 15:08:12 +0000156
Chris Lattnera0af1fe2009-02-18 06:06:56 +0000157 QualType Ty = Context.getObjCProtoType();
158 if (Ty.isNull())
Chris Lattner85a932e2008-01-04 22:32:30 +0000159 return true;
Steve Naroff14108da2009-07-10 23:34:53 +0000160 Ty = Context.getObjCObjectPointerType(Ty);
Chris Lattnera0af1fe2009-02-18 06:06:56 +0000161 return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, RParenLoc);
Chris Lattner85a932e2008-01-04 22:32:30 +0000162}
163
Mike Stump1eb44332009-09-09 15:08:12 +0000164bool Sema::CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs,
165 Selector Sel, ObjCMethodDecl *Method,
Chris Lattner077bf5e2008-11-24 03:33:13 +0000166 bool isClassMessage,
Daniel Dunbar637cebb2008-09-11 00:01:56 +0000167 SourceLocation lbrac, SourceLocation rbrac,
Mike Stump1eb44332009-09-09 15:08:12 +0000168 QualType &ReturnType) {
Daniel Dunbar637cebb2008-09-11 00:01:56 +0000169 if (!Method) {
Daniel Dunbar6660c8a2008-09-11 00:04:36 +0000170 // Apply default argument promotion as for (C99 6.5.2.2p6).
171 for (unsigned i = 0; i != NumArgs; i++)
172 DefaultArgumentPromotion(Args[i]);
173
Chris Lattner077bf5e2008-11-24 03:33:13 +0000174 unsigned DiagID = isClassMessage ? diag::warn_class_method_not_found :
175 diag::warn_inst_method_not_found;
176 Diag(lbrac, DiagID)
177 << Sel << isClassMessage << SourceRange(lbrac, rbrac);
Daniel Dunbar637cebb2008-09-11 00:01:56 +0000178 ReturnType = Context.getObjCIdType();
179 return false;
Daniel Dunbar637cebb2008-09-11 00:01:56 +0000180 }
Mike Stump1eb44332009-09-09 15:08:12 +0000181
Chris Lattner077bf5e2008-11-24 03:33:13 +0000182 ReturnType = Method->getResultType();
Mike Stump1eb44332009-09-09 15:08:12 +0000183
Daniel Dunbar91e19b22008-09-11 00:50:25 +0000184 unsigned NumNamedArgs = Sel.getNumArgs();
185 assert(NumArgs >= NumNamedArgs && "Too few arguments for selector!");
186
Chris Lattner312531a2009-04-12 08:11:20 +0000187 bool IsError = false;
Daniel Dunbar91e19b22008-09-11 00:50:25 +0000188 for (unsigned i = 0; i < NumNamedArgs; i++) {
Chris Lattner85a932e2008-01-04 22:32:30 +0000189 Expr *argExpr = Args[i];
190 assert(argExpr && "CheckMessageArgumentTypes(): missing expression");
Mike Stump1eb44332009-09-09 15:08:12 +0000191
Chris Lattner89951a82009-02-20 18:43:26 +0000192 QualType lhsType = Method->param_begin()[i]->getType();
Chris Lattner85a932e2008-01-04 22:32:30 +0000193 QualType rhsType = argExpr->getType();
194
Mike Stump1eb44332009-09-09 15:08:12 +0000195 // If necessary, apply function/array conversion. C99 6.7.5.3p[7,8].
Chris Lattner987798a2008-04-02 17:17:33 +0000196 if (lhsType->isArrayType())
197 lhsType = Context.getArrayDecayedType(lhsType);
Chris Lattner85a932e2008-01-04 22:32:30 +0000198 else if (lhsType->isFunctionType())
199 lhsType = Context.getPointerType(lhsType);
200
Mike Stump1eb44332009-09-09 15:08:12 +0000201 AssignConvertType Result =
Chris Lattner987798a2008-04-02 17:17:33 +0000202 CheckSingleAssignmentConstraints(lhsType, argExpr);
Chris Lattner85a932e2008-01-04 22:32:30 +0000203 if (Args[i] != argExpr) // The expression was converted.
204 Args[i] = argExpr; // Make sure we store the converted expression.
Mike Stump1eb44332009-09-09 15:08:12 +0000205
206 IsError |=
Chris Lattner85a932e2008-01-04 22:32:30 +0000207 DiagnoseAssignmentResult(Result, argExpr->getLocStart(), lhsType, rhsType,
Douglas Gregor68647482009-12-16 03:45:30 +0000208 argExpr, AA_Sending);
Chris Lattner85a932e2008-01-04 22:32:30 +0000209 }
Daniel Dunbar91e19b22008-09-11 00:50:25 +0000210
211 // Promote additional arguments to variadic methods.
212 if (Method->isVariadic()) {
Anders Carlssondce5e2c2009-01-16 16:48:51 +0000213 for (unsigned i = NumNamedArgs; i < NumArgs; ++i)
Chris Lattner312531a2009-04-12 08:11:20 +0000214 IsError |= DefaultVariadicArgumentPromotion(Args[i], VariadicMethod);
Daniel Dunbar91e19b22008-09-11 00:50:25 +0000215 } else {
216 // Check for extra arguments to non-variadic methods.
217 if (NumArgs != NumNamedArgs) {
Mike Stump1eb44332009-09-09 15:08:12 +0000218 Diag(Args[NumNamedArgs]->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000219 diag::err_typecheck_call_too_many_args)
Chris Lattner2c21a072008-11-21 18:44:24 +0000220 << 2 /*method*/ << Method->getSourceRange()
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000221 << SourceRange(Args[NumNamedArgs]->getLocStart(),
222 Args[NumArgs-1]->getLocEnd());
Daniel Dunbar91e19b22008-09-11 00:50:25 +0000223 }
224 }
225
Chris Lattner312531a2009-04-12 08:11:20 +0000226 return IsError;
Chris Lattner85a932e2008-01-04 22:32:30 +0000227}
228
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000229bool Sema::isSelfExpr(Expr *RExpr) {
230 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(RExpr))
231 if (DRE->getDecl()->getIdentifier() == &Context.Idents.get("self"))
232 return true;
233 return false;
234}
235
Steve Narofff1afaf62009-02-26 15:55:06 +0000236// Helper method for ActOnClassMethod/ActOnInstanceMethod.
237// Will search "local" class/category implementations for a method decl.
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +0000238// If failed, then we search in class's root for an instance method.
Steve Narofff1afaf62009-02-26 15:55:06 +0000239// Returns 0 if no method is found.
Steve Naroff5609ec02009-03-08 18:56:13 +0000240ObjCMethodDecl *Sema::LookupPrivateClassMethod(Selector Sel,
Steve Narofff1afaf62009-02-26 15:55:06 +0000241 ObjCInterfaceDecl *ClassDecl) {
242 ObjCMethodDecl *Method = 0;
Steve Naroff5609ec02009-03-08 18:56:13 +0000243 // lookup in class and all superclasses
244 while (ClassDecl && !Method) {
Argyrios Kyrtzidis87018772009-07-21 00:06:04 +0000245 if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000246 Method = ImpDecl->getClassMethod(Sel);
Mike Stump1eb44332009-09-09 15:08:12 +0000247
Steve Naroff5609ec02009-03-08 18:56:13 +0000248 // Look through local category implementations associated with the class.
Argyrios Kyrtzidis1cb35dd2009-07-21 00:06:20 +0000249 if (!Method)
250 Method = ClassDecl->getCategoryClassMethod(Sel);
Mike Stump1eb44332009-09-09 15:08:12 +0000251
Steve Naroff5609ec02009-03-08 18:56:13 +0000252 // Before we give up, check if the selector is an instance method.
253 // But only in the root. This matches gcc's behaviour and what the
254 // runtime expects.
255 if (!Method && !ClassDecl->getSuperClass()) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000256 Method = ClassDecl->lookupInstanceMethod(Sel);
Mike Stump1eb44332009-09-09 15:08:12 +0000257 // Look through local category implementations associated
Steve Naroff5609ec02009-03-08 18:56:13 +0000258 // with the root class.
Mike Stump1eb44332009-09-09 15:08:12 +0000259 if (!Method)
Steve Naroff5609ec02009-03-08 18:56:13 +0000260 Method = LookupPrivateInstanceMethod(Sel, ClassDecl);
261 }
Mike Stump1eb44332009-09-09 15:08:12 +0000262
Steve Naroff5609ec02009-03-08 18:56:13 +0000263 ClassDecl = ClassDecl->getSuperClass();
Steve Narofff1afaf62009-02-26 15:55:06 +0000264 }
Steve Naroff5609ec02009-03-08 18:56:13 +0000265 return Method;
266}
267
268ObjCMethodDecl *Sema::LookupPrivateInstanceMethod(Selector Sel,
269 ObjCInterfaceDecl *ClassDecl) {
270 ObjCMethodDecl *Method = 0;
271 while (ClassDecl && !Method) {
272 // If we have implementations in scope, check "private" methods.
Argyrios Kyrtzidis87018772009-07-21 00:06:04 +0000273 if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000274 Method = ImpDecl->getInstanceMethod(Sel);
Mike Stump1eb44332009-09-09 15:08:12 +0000275
Steve Naroff5609ec02009-03-08 18:56:13 +0000276 // Look through local category implementations associated with the class.
Argyrios Kyrtzidis1cb35dd2009-07-21 00:06:20 +0000277 if (!Method)
278 Method = ClassDecl->getCategoryInstanceMethod(Sel);
Steve Naroff5609ec02009-03-08 18:56:13 +0000279 ClassDecl = ClassDecl->getSuperClass();
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +0000280 }
Steve Narofff1afaf62009-02-26 15:55:06 +0000281 return Method;
282}
283
Steve Naroff61f72cb2009-03-09 21:12:44 +0000284Action::OwningExprResult Sema::ActOnClassPropertyRefExpr(
285 IdentifierInfo &receiverName,
286 IdentifierInfo &propertyName,
287 SourceLocation &receiverNameLoc,
288 SourceLocation &propertyNameLoc) {
Mike Stump1eb44332009-09-09 15:08:12 +0000289
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000290 IdentifierInfo *receiverNamePtr = &receiverName;
291 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(receiverNamePtr);
Mike Stump1eb44332009-09-09 15:08:12 +0000292
Steve Naroff61f72cb2009-03-09 21:12:44 +0000293 // Search for a declared property first.
Mike Stump1eb44332009-09-09 15:08:12 +0000294
Steve Naroff61f72cb2009-03-09 21:12:44 +0000295 Selector Sel = PP.getSelectorTable().getNullarySelector(&propertyName);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000296 ObjCMethodDecl *Getter = IFace->lookupClassMethod(Sel);
Steve Naroff61f72cb2009-03-09 21:12:44 +0000297
298 // If this reference is in an @implementation, check for 'private' methods.
299 if (!Getter)
300 if (ObjCMethodDecl *CurMeth = getCurMethodDecl())
301 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
Argyrios Kyrtzidis87018772009-07-21 00:06:04 +0000302 if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000303 Getter = ImpDecl->getClassMethod(Sel);
Steve Naroff61f72cb2009-03-09 21:12:44 +0000304
305 if (Getter) {
306 // FIXME: refactor/share with ActOnMemberReference().
307 // Check if we can reference this property.
308 if (DiagnoseUseOfDecl(Getter, propertyNameLoc))
309 return ExprError();
310 }
Mike Stump1eb44332009-09-09 15:08:12 +0000311
Steve Naroff61f72cb2009-03-09 21:12:44 +0000312 // Look for the matching setter, in case it is needed.
Mike Stump1eb44332009-09-09 15:08:12 +0000313 Selector SetterSel =
314 SelectorTable::constructSetterName(PP.getIdentifierTable(),
Steve Narofffdc92b72009-03-10 17:24:38 +0000315 PP.getSelectorTable(), &propertyName);
Mike Stump1eb44332009-09-09 15:08:12 +0000316
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000317 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
Steve Naroff61f72cb2009-03-09 21:12:44 +0000318 if (!Setter) {
319 // If this reference is in an @implementation, also check for 'private'
320 // methods.
321 if (ObjCMethodDecl *CurMeth = getCurMethodDecl())
322 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
Argyrios Kyrtzidis87018772009-07-21 00:06:04 +0000323 if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000324 Setter = ImpDecl->getClassMethod(SetterSel);
Steve Naroff61f72cb2009-03-09 21:12:44 +0000325 }
326 // Look through local category implementations associated with the class.
Argyrios Kyrtzidis1cb35dd2009-07-21 00:06:20 +0000327 if (!Setter)
328 Setter = IFace->getCategoryClassMethod(SetterSel);
Steve Naroff61f72cb2009-03-09 21:12:44 +0000329
330 if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc))
331 return ExprError();
332
333 if (Getter || Setter) {
334 QualType PType;
335
336 if (Getter)
337 PType = Getter->getResultType();
338 else {
339 for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(),
340 E = Setter->param_end(); PI != E; ++PI)
341 PType = (*PI)->getType();
342 }
Fariborz Jahanian09105f52009-08-20 17:02:02 +0000343 return Owned(new (Context) ObjCImplicitSetterGetterRefExpr(
Mike Stump1eb44332009-09-09 15:08:12 +0000344 Getter, PType, Setter,
Steve Naroff61f72cb2009-03-09 21:12:44 +0000345 propertyNameLoc, IFace, receiverNameLoc));
346 }
347 return ExprError(Diag(propertyNameLoc, diag::err_property_not_found)
348 << &propertyName << Context.getObjCInterfaceType(IFace));
349}
350
351
Chris Lattner85a932e2008-01-04 22:32:30 +0000352// ActOnClassMessage - used for both unary and keyword messages.
353// ArgExprs is optional - if it is present, the number of expressions
354// is obtained from Sel.getNumArgs().
355Sema::ExprResult Sema::ActOnClassMessage(
356 Scope *S,
357 IdentifierInfo *receiverName, Selector Sel,
Anders Carlssonff975cf2009-02-14 18:21:46 +0000358 SourceLocation lbrac, SourceLocation receiverLoc,
Mike Stump1eb44332009-09-09 15:08:12 +0000359 SourceLocation selectorLoc, SourceLocation rbrac,
360 ExprTy **Args, unsigned NumArgs) {
Chris Lattner85a932e2008-01-04 22:32:30 +0000361 assert(receiverName && "missing receiver class name");
362
363 Expr **ArgExprs = reinterpret_cast<Expr **>(Args);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000364 ObjCInterfaceDecl* ClassDecl = 0;
Steve Narofffc93d522008-07-24 19:44:33 +0000365 bool isSuper = false;
Mike Stump1eb44332009-09-09 15:08:12 +0000366
Chris Lattner84692652008-11-20 05:35:30 +0000367 if (receiverName->isStr("super")) {
Steve Naroff5cb93b82008-11-19 15:54:23 +0000368 if (getCurMethodDecl()) {
369 isSuper = true;
Fariborz Jahanian4b1e2752009-01-07 21:01:41 +0000370 ObjCInterfaceDecl *OID = getCurMethodDecl()->getClassInterface();
371 if (!OID)
Mike Stump1eb44332009-09-09 15:08:12 +0000372 return Diag(lbrac, diag::error_no_super_class_message)
Fariborz Jahanian4b1e2752009-01-07 21:01:41 +0000373 << getCurMethodDecl()->getDeclName();
374 ClassDecl = OID->getSuperClass();
Steve Naroff5cb93b82008-11-19 15:54:23 +0000375 if (!ClassDecl)
Fariborz Jahanian4b1e2752009-01-07 21:01:41 +0000376 return Diag(lbrac, diag::error_no_super_class) << OID->getDeclName();
Douglas Gregorf8d49f62009-01-09 17:18:27 +0000377 if (getCurMethodDecl()->isInstanceMethod()) {
Steve Naroff5cb93b82008-11-19 15:54:23 +0000378 QualType superTy = Context.getObjCInterfaceType(ClassDecl);
Steve Naroff14108da2009-07-10 23:34:53 +0000379 superTy = Context.getObjCObjectPointerType(superTy);
Ted Kremenek8189cde2009-02-07 01:47:29 +0000380 ExprResult ReceiverExpr = new (Context) ObjCSuperExpr(SourceLocation(),
381 superTy);
Steve Naroff5cb93b82008-11-19 15:54:23 +0000382 // We are really in an instance method, redirect.
Mike Stump1eb44332009-09-09 15:08:12 +0000383 return ActOnInstanceMessage(ReceiverExpr.get(), Sel, lbrac,
Anders Carlssonff975cf2009-02-14 18:21:46 +0000384 selectorLoc, rbrac, Args, NumArgs);
Steve Naroff5cb93b82008-11-19 15:54:23 +0000385 }
386 // We are sending a message to 'super' within a class method. Do nothing,
387 // the receiver will pass through as 'super' (how convenient:-).
388 } else {
389 // 'super' has been used outside a method context. If a variable named
390 // 'super' has been declared, redirect. If not, produce a diagnostic.
John McCallf36e02d2009-10-09 21:13:30 +0000391 NamedDecl *SuperDecl
392 = LookupSingleName(S, receiverName, LookupOrdinaryName);
Steve Naroff5cb93b82008-11-19 15:54:23 +0000393 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(SuperDecl);
394 if (VD) {
Mike Stump1eb44332009-09-09 15:08:12 +0000395 ExprResult ReceiverExpr = new (Context) DeclRefExpr(VD, VD->getType(),
Ted Kremenek8189cde2009-02-07 01:47:29 +0000396 receiverLoc);
Steve Naroff5cb93b82008-11-19 15:54:23 +0000397 // We are really in an instance method, redirect.
Mike Stump1eb44332009-09-09 15:08:12 +0000398 return ActOnInstanceMessage(ReceiverExpr.get(), Sel, lbrac,
Anders Carlssonff975cf2009-02-14 18:21:46 +0000399 selectorLoc, rbrac, Args, NumArgs);
Steve Naroff5cb93b82008-11-19 15:54:23 +0000400 }
Fariborz Jahaniane4fb8282010-01-22 23:04:44 +0000401 else if (TypedefDecl *OCTD = dyn_cast_or_null<TypedefDecl>(SuperDecl)) {
402 const ObjCInterfaceType *OCIT;
403 OCIT = OCTD->getUnderlyingType()->getAs<ObjCInterfaceType>();
404 if (!OCIT) {
405 Diag(receiverLoc, diag::err_invalid_receiver_to_message);
406 return true;
407 }
408 ClassDecl = OCIT->getDecl();
409 }
410 else
411 return Diag(receiverLoc, diag::err_undeclared_var_use) << receiverName;
Mike Stump1eb44332009-09-09 15:08:12 +0000412 }
Chris Lattner85a932e2008-01-04 22:32:30 +0000413 } else
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000414 ClassDecl = getObjCInterfaceDecl(receiverName, receiverLoc);
Mike Stump1eb44332009-09-09 15:08:12 +0000415
Steve Naroff7c778f12008-07-25 19:39:00 +0000416 // The following code allows for the following GCC-ism:
Steve Naroffcb28be62008-06-04 23:08:38 +0000417 //
418 // typedef XCElementDisplayRect XCElementGraphicsRect;
419 //
420 // @implementation XCRASlice
421 // - whatever { // Note that XCElementGraphicsRect is a typedef name.
422 // _sGraphicsDelegate =[[XCElementGraphicsRect alloc] init];
423 // }
424 //
Steve Naroff7c778f12008-07-25 19:39:00 +0000425 // If necessary, the following lookup could move to getObjCInterfaceDecl().
426 if (!ClassDecl) {
John McCallf36e02d2009-10-09 21:13:30 +0000427 NamedDecl *IDecl
428 = LookupSingleName(TUScope, receiverName, LookupOrdinaryName);
Douglas Gregorc5e77d52010-02-19 15:18:45 +0000429 if (TypedefDecl *OCTD = dyn_cast_or_null<TypedefDecl>(IDecl))
430 if (const ObjCInterfaceType *OCIT
431 = OCTD->getUnderlyingType()->getAs<ObjCInterfaceType>())
432 ClassDecl = OCIT->getDecl();
433
434 if (!ClassDecl) {
435 Diag(receiverLoc, diag::err_invalid_receiver_to_message);
436 return true;
Steve Naroff7c778f12008-07-25 19:39:00 +0000437 }
438 }
439 assert(ClassDecl && "missing interface declaration");
Steve Naroffcb28be62008-06-04 23:08:38 +0000440 ObjCMethodDecl *Method = 0;
Chris Lattner85a932e2008-01-04 22:32:30 +0000441 QualType returnType;
Fariborz Jahanian89bc3142009-05-08 23:02:36 +0000442 if (ClassDecl->isForwardDecl()) {
443 // A forward class used in messaging is tread as a 'Class'
Fariborz Jahanian9f8f0262009-05-08 23:45:49 +0000444 Diag(lbrac, diag::warn_receiver_forward_class) << ClassDecl->getDeclName();
Fariborz Jahanian89bc3142009-05-08 23:02:36 +0000445 Method = LookupFactoryMethodInGlobalPool(Sel, SourceRange(lbrac,rbrac));
446 if (Method)
Mike Stump1eb44332009-09-09 15:08:12 +0000447 Diag(Method->getLocation(), diag::note_method_sent_forward_class)
Fariborz Jahanian9f8f0262009-05-08 23:45:49 +0000448 << Method->getDeclName();
Fariborz Jahanian89bc3142009-05-08 23:02:36 +0000449 }
450 if (!Method)
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000451 Method = ClassDecl->lookupClassMethod(Sel);
Mike Stump1eb44332009-09-09 15:08:12 +0000452
Steve Naroff7c778f12008-07-25 19:39:00 +0000453 // If we have an implementation in scope, check "private" methods.
Steve Narofff1afaf62009-02-26 15:55:06 +0000454 if (!Method)
Steve Naroff5609ec02009-03-08 18:56:13 +0000455 Method = LookupPrivateClassMethod(Sel, ClassDecl);
Steve Naroff7c778f12008-07-25 19:39:00 +0000456
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000457 if (Method && DiagnoseUseOfDecl(Method, receiverLoc))
458 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000459
460 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, true,
Daniel Dunbar637cebb2008-09-11 00:01:56 +0000461 lbrac, rbrac, returnType))
462 return true;
Ted Kremenek4df728e2008-06-24 15:50:53 +0000463
Anders Carlsson187ba152009-05-26 15:22:25 +0000464 returnType = returnType.getNonReferenceType();
Mike Stump1eb44332009-09-09 15:08:12 +0000465
Mike Stump390b4cc2009-05-16 07:39:55 +0000466 // If we have the ObjCInterfaceDecl* for the class that is receiving the
467 // message, use that to construct the ObjCMessageExpr. Otherwise pass on the
468 // IdentifierInfo* for the class.
469 // FIXME: need to do a better job handling 'super' usage within a class. For
470 // now, we simply pass the "super" identifier through (which isn't consistent
471 // with instance methods.
Steve Naroff7c778f12008-07-25 19:39:00 +0000472 if (isSuper)
Ted Kremenekeb3b3242010-02-11 22:41:21 +0000473 return new (Context) ObjCMessageExpr(Context, receiverName, Sel, returnType,
474 Method, lbrac, rbrac, ArgExprs,
475 NumArgs);
Ted Kremenek4df728e2008-06-24 15:50:53 +0000476 else
Ted Kremenekeb3b3242010-02-11 22:41:21 +0000477 return new (Context) ObjCMessageExpr(Context, ClassDecl, Sel, returnType,
478 Method, lbrac, rbrac, ArgExprs,
479 NumArgs);
Chris Lattner85a932e2008-01-04 22:32:30 +0000480}
481
482// ActOnInstanceMessage - used for both unary and keyword messages.
483// ArgExprs is optional - if it is present, the number of expressions
484// is obtained from Sel.getNumArgs().
Chris Lattner1565e032008-07-21 06:31:05 +0000485Sema::ExprResult Sema::ActOnInstanceMessage(ExprTy *receiver, Selector Sel,
Mike Stump1eb44332009-09-09 15:08:12 +0000486 SourceLocation lbrac,
Anders Carlssonff975cf2009-02-14 18:21:46 +0000487 SourceLocation receiverLoc,
Chris Lattnerb77792e2008-07-26 22:17:49 +0000488 SourceLocation rbrac,
489 ExprTy **Args, unsigned NumArgs) {
Chris Lattner85a932e2008-01-04 22:32:30 +0000490 assert(receiver && "missing receiver expression");
Mike Stump1eb44332009-09-09 15:08:12 +0000491
Chris Lattner85a932e2008-01-04 22:32:30 +0000492 Expr **ArgExprs = reinterpret_cast<Expr **>(Args);
493 Expr *RExpr = static_cast<Expr *>(receiver);
Mike Stump1eb44332009-09-09 15:08:12 +0000494
Chris Lattnerd0d45992009-04-29 05:48:32 +0000495 // If necessary, apply function/array conversion to the receiver.
496 // C99 6.7.5.3p[7,8].
Douglas Gregora873dfc2010-02-03 00:27:59 +0000497 DefaultFunctionArrayLvalueConversion(RExpr);
Mike Stump1eb44332009-09-09 15:08:12 +0000498
Chris Lattner85a932e2008-01-04 22:32:30 +0000499 QualType returnType;
Chris Lattnerb77792e2008-07-26 22:17:49 +0000500 QualType ReceiverCType =
501 Context.getCanonicalType(RExpr->getType()).getUnqualifiedType();
Steve Naroff87d3ef02008-11-17 22:29:32 +0000502
503 // Handle messages to 'super'.
Steve Naroff279d8962009-02-23 15:40:48 +0000504 if (isa<ObjCSuperExpr>(RExpr)) {
Steve Naroff87d3ef02008-11-17 22:29:32 +0000505 ObjCMethodDecl *Method = 0;
506 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
507 // If we have an interface in scope, check 'super' methods.
508 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
Steve Naroff5609ec02009-03-08 18:56:13 +0000509 if (ObjCInterfaceDecl *SuperDecl = ClassDecl->getSuperClass()) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000510 Method = SuperDecl->lookupInstanceMethod(Sel);
Mike Stump1eb44332009-09-09 15:08:12 +0000511
512 if (!Method)
Steve Naroff5609ec02009-03-08 18:56:13 +0000513 // If we have implementations in scope, check "private" methods.
514 Method = LookupPrivateInstanceMethod(Sel, SuperDecl);
515 }
Steve Naroff87d3ef02008-11-17 22:29:32 +0000516 }
Anders Carlssonff975cf2009-02-14 18:21:46 +0000517
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000518 if (Method && DiagnoseUseOfDecl(Method, receiverLoc))
519 return true;
Anders Carlsson59843ad2009-02-14 19:08:58 +0000520
Chris Lattner077bf5e2008-11-24 03:33:13 +0000521 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, false,
Steve Naroff87d3ef02008-11-17 22:29:32 +0000522 lbrac, rbrac, returnType))
523 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000524
Anders Carlsson187ba152009-05-26 15:22:25 +0000525 returnType = returnType.getNonReferenceType();
Ted Kremenekeb3b3242010-02-11 22:41:21 +0000526 return new (Context) ObjCMessageExpr(Context, RExpr, Sel, returnType,
527 Method, lbrac, rbrac,
528 ArgExprs, NumArgs);
Steve Naroff87d3ef02008-11-17 22:29:32 +0000529 }
530
Mike Stump1eb44332009-09-09 15:08:12 +0000531 // Handle messages to id.
Steve Naroff470301b2009-07-22 16:07:01 +0000532 if (ReceiverCType->isObjCIdType() || ReceiverCType->isBlockPointerType() ||
Fariborz Jahanian636bed12009-05-21 21:04:28 +0000533 Context.isObjCNSObjectType(RExpr->getType())) {
Steve Naroff037cda52008-09-30 14:38:43 +0000534 ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(
535 Sel, SourceRange(lbrac,rbrac));
Chris Lattner6e10a082008-02-01 06:57:39 +0000536 if (!Method)
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000537 Method = LookupFactoryMethodInGlobalPool(Sel, SourceRange(lbrac, rbrac));
Mike Stump1eb44332009-09-09 15:08:12 +0000538 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, false,
Daniel Dunbar637cebb2008-09-11 00:01:56 +0000539 lbrac, rbrac, returnType))
540 return true;
Anders Carlsson187ba152009-05-26 15:22:25 +0000541 returnType = returnType.getNonReferenceType();
Ted Kremenekeb3b3242010-02-11 22:41:21 +0000542 return new (Context) ObjCMessageExpr(Context, RExpr, Sel, returnType,
543 Method, lbrac, rbrac,
544 ArgExprs, NumArgs);
Chris Lattnerfe1a5532008-07-21 05:57:44 +0000545 }
Mike Stump1eb44332009-09-09 15:08:12 +0000546
Chris Lattnerfe1a5532008-07-21 05:57:44 +0000547 // Handle messages to Class.
Mike Stump1eb44332009-09-09 15:08:12 +0000548 if (ReceiverCType->isObjCClassType() ||
Steve Naroff470301b2009-07-22 16:07:01 +0000549 ReceiverCType->isObjCQualifiedClassType()) {
Chris Lattner2b1cc8b2008-07-21 06:12:56 +0000550 ObjCMethodDecl *Method = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000551
Chris Lattner6562fda2008-07-21 06:44:27 +0000552 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
Steve Naroffd526c2f2009-02-23 02:25:40 +0000553 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) {
554 // First check the public methods in the class interface.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000555 Method = ClassDecl->lookupClassMethod(Sel);
Mike Stump1eb44332009-09-09 15:08:12 +0000556
Steve Narofff1afaf62009-02-26 15:55:06 +0000557 if (!Method)
Steve Naroff5609ec02009-03-08 18:56:13 +0000558 Method = LookupPrivateClassMethod(Sel, ClassDecl);
Mike Stump1eb44332009-09-09 15:08:12 +0000559
560 // FIXME: if we still haven't found a method, we need to look in
Steve Naroff470301b2009-07-22 16:07:01 +0000561 // protocols (if we have qualifiers).
Steve Naroffd526c2f2009-02-23 02:25:40 +0000562 }
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000563 if (Method && DiagnoseUseOfDecl(Method, receiverLoc))
564 return true;
Steve Naroffd526c2f2009-02-23 02:25:40 +0000565 }
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000566 if (!Method) {
567 // If not messaging 'self', look for any factory method named 'Sel'.
568 if (!isSelfExpr(RExpr)) {
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000569 Method = LookupFactoryMethodInGlobalPool(Sel, SourceRange(lbrac,rbrac));
Fariborz Jahanianb1006c72009-03-04 17:50:39 +0000570 if (!Method) {
Fariborz Jahanian041f2fd2009-05-05 18:34:37 +0000571 // If no class (factory) method was found, check if an _instance_
572 // method of the same name exists in the root class only.
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000573 Method = LookupInstanceMethodInGlobalPool(
574 Sel, SourceRange(lbrac,rbrac));
Fariborz Jahanian041f2fd2009-05-05 18:34:37 +0000575 if (Method)
576 if (const ObjCInterfaceDecl *ID =
577 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
578 if (ID->getSuperClass())
579 Diag(lbrac, diag::warn_root_inst_method_not_found)
580 << Sel << SourceRange(lbrac, rbrac);
581 }
Fariborz Jahanianb1006c72009-03-04 17:50:39 +0000582 }
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000583 }
584 }
Chris Lattner077bf5e2008-11-24 03:33:13 +0000585 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, false,
Daniel Dunbar637cebb2008-09-11 00:01:56 +0000586 lbrac, rbrac, returnType))
587 return true;
Anders Carlsson187ba152009-05-26 15:22:25 +0000588 returnType = returnType.getNonReferenceType();
Ted Kremenekeb3b3242010-02-11 22:41:21 +0000589 return new (Context) ObjCMessageExpr(Context, RExpr, Sel, returnType,
590 Method, lbrac, rbrac,
591 ArgExprs, NumArgs);
Chris Lattnerfe1a5532008-07-21 05:57:44 +0000592 }
Mike Stump1eb44332009-09-09 15:08:12 +0000593
Chris Lattner2b1cc8b2008-07-21 06:12:56 +0000594 ObjCMethodDecl *Method = 0;
Chris Lattnerfe1a5532008-07-21 05:57:44 +0000595 ObjCInterfaceDecl* ClassDecl = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000596
597 // We allow sending a message to a qualified ID ("id<foo>"), which is ok as
Chris Lattner2b1cc8b2008-07-21 06:12:56 +0000598 // long as one of the protocols implements the selector (if not, warn).
Mike Stump1eb44332009-09-09 15:08:12 +0000599 if (const ObjCObjectPointerType *QIdTy =
Steve Naroffd1b3c2d2009-06-17 22:40:22 +0000600 ReceiverCType->getAsObjCQualifiedIdType()) {
Steve Narofff7f52e72009-02-21 21:17:01 +0000601 // Search protocols for instance methods.
Steve Naroffd1b3c2d2009-06-17 22:40:22 +0000602 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
Steve Naroff446ee4e2009-05-27 16:21:00 +0000603 E = QIdTy->qual_end(); I != E; ++I) {
604 ObjCProtocolDecl *PDecl = *I;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000605 if (PDecl && (Method = PDecl->lookupInstanceMethod(Sel)))
Chris Lattnerfe1a5532008-07-21 05:57:44 +0000606 break;
Steve Naroffebaa7682009-04-07 15:07:57 +0000607 // Since we aren't supporting "Class<foo>", look for a class method.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000608 if (PDecl && (Method = PDecl->lookupClassMethod(Sel)))
Steve Naroffebaa7682009-04-07 15:07:57 +0000609 break;
Chris Lattnerfe1a5532008-07-21 05:57:44 +0000610 }
Mike Stump1eb44332009-09-09 15:08:12 +0000611 } else if (const ObjCObjectPointerType *OCIType =
Steve Naroff14108da2009-07-10 23:34:53 +0000612 ReceiverCType->getAsObjCInterfacePointerType()) {
Chris Lattner2b1cc8b2008-07-21 06:12:56 +0000613 // We allow sending a message to a pointer to an interface (an object).
Mike Stump1eb44332009-09-09 15:08:12 +0000614
Steve Naroff14108da2009-07-10 23:34:53 +0000615 ClassDecl = OCIType->getInterfaceDecl();
Steve Naroff037cda52008-09-30 14:38:43 +0000616 // FIXME: consider using LookupInstanceMethodInGlobalPool, since it will be
Mike Stump390b4cc2009-05-16 07:39:55 +0000617 // faster than the following method (which can do *many* linear searches).
Steve Naroff037cda52008-09-30 14:38:43 +0000618 // The idea is to add class info to InstanceMethodPool.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000619 Method = ClassDecl->lookupInstanceMethod(Sel);
Mike Stump1eb44332009-09-09 15:08:12 +0000620
Chris Lattnerfe1a5532008-07-21 05:57:44 +0000621 if (!Method) {
622 // Search protocol qualifiers.
Steve Naroff14108da2009-07-10 23:34:53 +0000623 for (ObjCObjectPointerType::qual_iterator QI = OCIType->qual_begin(),
Steve Naroff279d8962009-02-23 15:40:48 +0000624 E = OCIType->qual_end(); QI != E; ++QI) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000625 if ((Method = (*QI)->lookupInstanceMethod(Sel)))
Chris Lattner85a932e2008-01-04 22:32:30 +0000626 break;
627 }
Chris Lattner85a932e2008-01-04 22:32:30 +0000628 }
Steve Naroff0de21fd2009-02-22 19:35:57 +0000629 if (!Method) {
Steve Naroff5609ec02009-03-08 18:56:13 +0000630 // If we have implementations in scope, check "private" methods.
631 Method = LookupPrivateInstanceMethod(Sel, ClassDecl);
Mike Stump1eb44332009-09-09 15:08:12 +0000632
Steve Naroff5609ec02009-03-08 18:56:13 +0000633 if (!Method && !isSelfExpr(RExpr)) {
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000634 // If we still haven't found a method, look in the global pool. This
635 // behavior isn't very desirable, however we need it for GCC
636 // compatibility. FIXME: should we deviate??
Steve Naroff5609ec02009-03-08 18:56:13 +0000637 if (OCIType->qual_empty()) {
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000638 Method = LookupInstanceMethodInGlobalPool(
639 Sel, SourceRange(lbrac,rbrac));
Steve Naroff14108da2009-07-10 23:34:53 +0000640 if (Method && !OCIType->getInterfaceDecl()->isForwardDecl())
Mike Stump1eb44332009-09-09 15:08:12 +0000641 Diag(lbrac, diag::warn_maynot_respond)
Steve Naroff14108da2009-07-10 23:34:53 +0000642 << OCIType->getInterfaceDecl()->getIdentifier()->getName() << Sel;
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000643 }
Fariborz Jahanian268bc8c2009-03-03 22:19:15 +0000644 }
Steve Naroff0de21fd2009-02-22 19:35:57 +0000645 }
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000646 if (Method && DiagnoseUseOfDecl(Method, receiverLoc))
647 return true;
Chris Lattner0c73f372009-03-09 21:19:16 +0000648 } else if (!Context.getObjCIdType().isNull() &&
649 (ReceiverCType->isPointerType() ||
Mike Stump1eb44332009-09-09 15:08:12 +0000650 (ReceiverCType->isIntegerType() &&
Chris Lattner0c73f372009-03-09 21:19:16 +0000651 ReceiverCType->isScalarType()))) {
652 // Implicitly convert integers and pointers to 'id' but emit a warning.
Steve Naroff8e2945a2009-03-01 17:14:31 +0000653 Diag(lbrac, diag::warn_bad_receiver_type)
Chris Lattnerd1625842008-11-24 06:25:27 +0000654 << RExpr->getType() << RExpr->getSourceRange();
Eli Friedman73c39ab2009-10-20 08:27:19 +0000655 if (ReceiverCType->isPointerType())
656 ImpCastExprToType(RExpr, Context.getObjCIdType(), CastExpr::CK_BitCast);
657 else
658 ImpCastExprToType(RExpr, Context.getObjCIdType(),
659 CastExpr::CK_IntegralToPointer);
Chris Lattner0c73f372009-03-09 21:19:16 +0000660 } else {
661 // Reject other random receiver types (e.g. structs).
662 Diag(lbrac, diag::err_bad_receiver_type)
663 << RExpr->getType() << RExpr->getSourceRange();
Chris Lattner2b1cc8b2008-07-21 06:12:56 +0000664 return true;
Chris Lattnerfe1a5532008-07-21 05:57:44 +0000665 }
Mike Stump1eb44332009-09-09 15:08:12 +0000666
Fariborz Jahanian5b530052009-05-13 18:09:35 +0000667 if (Method)
668 DiagnoseSentinelCalls(Method, receiverLoc, ArgExprs, NumArgs);
Chris Lattner077bf5e2008-11-24 03:33:13 +0000669 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, false,
Daniel Dunbar637cebb2008-09-11 00:01:56 +0000670 lbrac, rbrac, returnType))
671 return true;
Anders Carlsson187ba152009-05-26 15:22:25 +0000672 returnType = returnType.getNonReferenceType();
Ted Kremenekeb3b3242010-02-11 22:41:21 +0000673 return new (Context) ObjCMessageExpr(Context, RExpr, Sel, returnType, Method,
674 lbrac, rbrac, ArgExprs, NumArgs);
Chris Lattner85a932e2008-01-04 22:32:30 +0000675}
Chris Lattnereca7be62008-04-07 05:30:13 +0000676