blob: 14f2bbedbe2f222faf1d093d9fa73efa6ec2791e [file] [log] [blame]
Ted Kremenek1b0ea822008-01-07 19:49:32 +00001//===--- ParseObjC.cpp - Objective C Parsing ------------------------------===//
Chris Lattnerda59c2f2006-11-05 02:08:13 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerda59c2f2006-11-05 02:08:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Objective-C portions of the Parser interface.
11//
12//===----------------------------------------------------------------------===//
13
Chris Lattner60f36222009-01-29 05:15:15 +000014#include "clang/Parse/ParseDiagnostic.h"
John McCall8b0666c2010-08-20 18:27:03 +000015#include "clang/Parse/Parser.h"
Douglas Gregore9bba4f2010-09-15 14:51:05 +000016#include "RAIIObjectsForParser.h"
John McCall8b0666c2010-08-20 18:27:03 +000017#include "clang/Sema/DeclSpec.h"
John McCallfaf5fb42010-08-26 23:41:50 +000018#include "clang/Sema/PrettyDeclStackTrace.h"
John McCall8b0666c2010-08-20 18:27:03 +000019#include "clang/Sema/Scope.h"
Chris Lattnerda59c2f2006-11-05 02:08:13 +000020#include "llvm/ADT/SmallVector.h"
Chris Lattnerda59c2f2006-11-05 02:08:13 +000021using namespace clang;
22
23
Chris Lattner3a907162008-12-08 21:53:24 +000024/// ParseObjCAtDirectives - Handle parts of the external-declaration production:
Chris Lattnerda59c2f2006-11-05 02:08:13 +000025/// external-declaration: [C99 6.9]
26/// [OBJC] objc-class-definition
Steve Naroffe0933392007-10-29 21:39:29 +000027/// [OBJC] objc-class-declaration
28/// [OBJC] objc-alias-declaration
29/// [OBJC] objc-protocol-definition
30/// [OBJC] objc-method-definition
31/// [OBJC] '@' 'end'
John McCall48871652010-08-21 09:40:31 +000032Decl *Parser::ParseObjCAtDirectives() {
Chris Lattnerda59c2f2006-11-05 02:08:13 +000033 SourceLocation AtLoc = ConsumeToken(); // the "@"
Mike Stump11289f42009-09-09 15:08:12 +000034
Douglas Gregorf48706c2009-12-07 09:27:33 +000035 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +000036 Actions.CodeCompleteObjCAtDirective(getCurScope(), ObjCImpDecl, false);
Douglas Gregor6da3db42010-05-25 05:58:43 +000037 ConsumeCodeCompletionToken();
Douglas Gregorf48706c2009-12-07 09:27:33 +000038 }
39
Steve Naroff7c348172007-08-23 18:16:40 +000040 switch (Tok.getObjCKeywordID()) {
Chris Lattnerce90ef52008-08-23 02:02:23 +000041 case tok::objc_class:
42 return ParseObjCAtClassDeclaration(AtLoc);
John McCall53fa7142010-12-24 02:08:15 +000043 case tok::objc_interface: {
John McCall084e83d2011-03-24 11:26:52 +000044 ParsedAttributes attrs(AttrFactory);
John McCall53fa7142010-12-24 02:08:15 +000045 return ParseObjCAtInterfaceDeclaration(AtLoc, attrs);
46 }
47 case tok::objc_protocol: {
John McCall084e83d2011-03-24 11:26:52 +000048 ParsedAttributes attrs(AttrFactory);
John McCall53fa7142010-12-24 02:08:15 +000049 return ParseObjCAtProtocolDeclaration(AtLoc, attrs);
50 }
Chris Lattnerce90ef52008-08-23 02:02:23 +000051 case tok::objc_implementation:
52 return ParseObjCAtImplementationDeclaration(AtLoc);
53 case tok::objc_end:
54 return ParseObjCAtEndDeclaration(AtLoc);
55 case tok::objc_compatibility_alias:
56 return ParseObjCAtAliasDeclaration(AtLoc);
57 case tok::objc_synthesize:
58 return ParseObjCPropertySynthesize(AtLoc);
59 case tok::objc_dynamic:
60 return ParseObjCPropertyDynamic(AtLoc);
61 default:
62 Diag(AtLoc, diag::err_unexpected_at);
63 SkipUntil(tok::semi);
John McCall48871652010-08-21 09:40:31 +000064 return 0;
Chris Lattnerda59c2f2006-11-05 02:08:13 +000065 }
66}
67
68///
Mike Stump11289f42009-09-09 15:08:12 +000069/// objc-class-declaration:
Chris Lattnerda59c2f2006-11-05 02:08:13 +000070/// '@' 'class' identifier-list ';'
Mike Stump11289f42009-09-09 15:08:12 +000071///
John McCall48871652010-08-21 09:40:31 +000072Decl *Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) {
Chris Lattnerda59c2f2006-11-05 02:08:13 +000073 ConsumeToken(); // the identifier "class"
Chris Lattner23b7eb62007-06-15 23:05:46 +000074 llvm::SmallVector<IdentifierInfo *, 8> ClassNames;
Ted Kremeneka26da852009-11-17 23:12:20 +000075 llvm::SmallVector<SourceLocation, 8> ClassLocs;
76
Mike Stump11289f42009-09-09 15:08:12 +000077
Chris Lattnerda59c2f2006-11-05 02:08:13 +000078 while (1) {
Chris Lattner0ef13522007-10-09 17:51:17 +000079 if (Tok.isNot(tok::identifier)) {
Chris Lattnerbd638922006-11-10 05:19:25 +000080 Diag(Tok, diag::err_expected_ident);
Chris Lattnerda59c2f2006-11-05 02:08:13 +000081 SkipUntil(tok::semi);
John McCall48871652010-08-21 09:40:31 +000082 return 0;
Chris Lattnerda59c2f2006-11-05 02:08:13 +000083 }
Chris Lattnerda59c2f2006-11-05 02:08:13 +000084 ClassNames.push_back(Tok.getIdentifierInfo());
Ted Kremeneka26da852009-11-17 23:12:20 +000085 ClassLocs.push_back(Tok.getLocation());
Chris Lattnerda59c2f2006-11-05 02:08:13 +000086 ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +000087
Chris Lattner0ef13522007-10-09 17:51:17 +000088 if (Tok.isNot(tok::comma))
Chris Lattnerda59c2f2006-11-05 02:08:13 +000089 break;
Mike Stump11289f42009-09-09 15:08:12 +000090
Chris Lattnerda59c2f2006-11-05 02:08:13 +000091 ConsumeToken();
92 }
Mike Stump11289f42009-09-09 15:08:12 +000093
Chris Lattnerda59c2f2006-11-05 02:08:13 +000094 // Consume the ';'.
95 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@class"))
John McCall48871652010-08-21 09:40:31 +000096 return 0;
Mike Stump11289f42009-09-09 15:08:12 +000097
Ted Kremeneka26da852009-11-17 23:12:20 +000098 return Actions.ActOnForwardClassDeclaration(atLoc, ClassNames.data(),
99 ClassLocs.data(),
100 ClassNames.size());
Chris Lattnerda59c2f2006-11-05 02:08:13 +0000101}
102
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000103///
104/// objc-interface:
105/// objc-class-interface-attributes[opt] objc-class-interface
106/// objc-category-interface
107///
108/// objc-class-interface:
Mike Stump11289f42009-09-09 15:08:12 +0000109/// '@' 'interface' identifier objc-superclass[opt]
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000110/// objc-protocol-refs[opt]
Mike Stump11289f42009-09-09 15:08:12 +0000111/// objc-class-instance-variables[opt]
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000112/// objc-interface-decl-list
113/// @end
114///
115/// objc-category-interface:
Mike Stump11289f42009-09-09 15:08:12 +0000116/// '@' 'interface' identifier '(' identifier[opt] ')'
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000117/// objc-protocol-refs[opt]
118/// objc-interface-decl-list
119/// @end
120///
121/// objc-superclass:
122/// ':' identifier
123///
124/// objc-class-interface-attributes:
125/// __attribute__((visibility("default")))
126/// __attribute__((visibility("hidden")))
127/// __attribute__((deprecated))
128/// __attribute__((unavailable))
129/// __attribute__((objc_exception)) - used by NSException on 64-bit
130///
John McCall53fa7142010-12-24 02:08:15 +0000131Decl *Parser::ParseObjCAtInterfaceDeclaration(SourceLocation atLoc,
132 ParsedAttributes &attrs) {
Steve Naroff7c348172007-08-23 18:16:40 +0000133 assert(Tok.isObjCAtKeyword(tok::objc_interface) &&
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000134 "ParseObjCAtInterfaceDeclaration(): Expected @interface");
135 ConsumeToken(); // the "interface" identifier
Mike Stump11289f42009-09-09 15:08:12 +0000136
Douglas Gregor49c22a72009-11-18 16:26:39 +0000137 // Code completion after '@interface'.
138 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000139 Actions.CodeCompleteObjCInterfaceDecl(getCurScope());
Douglas Gregor6da3db42010-05-25 05:58:43 +0000140 ConsumeCodeCompletionToken();
Douglas Gregor49c22a72009-11-18 16:26:39 +0000141 }
142
Chris Lattner0ef13522007-10-09 17:51:17 +0000143 if (Tok.isNot(tok::identifier)) {
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000144 Diag(Tok, diag::err_expected_ident); // missing class or category name.
John McCall48871652010-08-21 09:40:31 +0000145 return 0;
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000146 }
Fariborz Jahanian9290ede2009-11-16 18:57:01 +0000147
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000148 // We have a class or category name - consume it.
Steve Naroff0b6a01a2007-08-22 22:17:26 +0000149 IdentifierInfo *nameId = Tok.getIdentifierInfo();
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000150 SourceLocation nameLoc = ConsumeToken();
Fariborz Jahanian65654df2010-04-26 21:18:08 +0000151 if (Tok.is(tok::l_paren) &&
152 !isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { // we have a category.
Jeffrey Yasskin8dfa5f12011-01-18 02:00:16 +0000153 // TODO(dgregor): Use the return value from the next line to provide better
154 // recovery.
155 ConsumeParen();
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000156 SourceLocation categoryLoc, rparenLoc;
157 IdentifierInfo *categoryId = 0;
Douglas Gregor5d34fd32009-11-18 19:08:43 +0000158 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000159 Actions.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId, nameLoc);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000160 ConsumeCodeCompletionToken();
Douglas Gregor5d34fd32009-11-18 19:08:43 +0000161 }
162
Steve Naroff4e1f80d2007-08-23 19:56:30 +0000163 // For ObjC2, the category name is optional (not an error).
Chris Lattner0ef13522007-10-09 17:51:17 +0000164 if (Tok.is(tok::identifier)) {
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000165 categoryId = Tok.getIdentifierInfo();
166 categoryLoc = ConsumeToken();
Fariborz Jahaniand077f712010-04-02 23:15:40 +0000167 }
Fariborz Jahaniand077f712010-04-02 23:15:40 +0000168 else if (!getLang().ObjC2) {
Steve Naroff4e1f80d2007-08-23 19:56:30 +0000169 Diag(Tok, diag::err_expected_ident); // missing category name.
John McCall48871652010-08-21 09:40:31 +0000170 return 0;
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000171 }
Chris Lattner0ef13522007-10-09 17:51:17 +0000172 if (Tok.isNot(tok::r_paren)) {
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000173 Diag(Tok, diag::err_expected_rparen);
174 SkipUntil(tok::r_paren, false); // don't stop at ';'
John McCall48871652010-08-21 09:40:31 +0000175 return 0;
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000176 }
177 rparenLoc = ConsumeParen();
Fariborz Jahanian65654df2010-04-26 21:18:08 +0000178 // Next, we need to check for any protocol references.
179 SourceLocation LAngleLoc, EndProtoLoc;
John McCall48871652010-08-21 09:40:31 +0000180 llvm::SmallVector<Decl *, 8> ProtocolRefs;
Fariborz Jahanian65654df2010-04-26 21:18:08 +0000181 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
182 if (Tok.is(tok::less) &&
183 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true,
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +0000184 LAngleLoc, EndProtoLoc))
John McCall48871652010-08-21 09:40:31 +0000185 return 0;
Mike Stump11289f42009-09-09 15:08:12 +0000186
John McCall53fa7142010-12-24 02:08:15 +0000187 if (!attrs.empty()) // categories don't support attributes.
Fariborz Jahanian65654df2010-04-26 21:18:08 +0000188 Diag(Tok, diag::err_objc_no_attributes_on_category);
Mike Stump11289f42009-09-09 15:08:12 +0000189
John McCall48871652010-08-21 09:40:31 +0000190 Decl *CategoryType =
Fariborz Jahanian65654df2010-04-26 21:18:08 +0000191 Actions.ActOnStartCategoryInterface(atLoc,
192 nameId, nameLoc,
193 categoryId, categoryLoc,
194 ProtocolRefs.data(),
195 ProtocolRefs.size(),
196 ProtocolLocs.data(),
197 EndProtoLoc);
198 if (Tok.is(tok::l_brace))
Fariborz Jahanian4c172c62010-02-22 23:04:20 +0000199 ParseObjCClassInstanceVariables(CategoryType, tok::objc_private,
200 atLoc);
201
Fariborz Jahanian65654df2010-04-26 21:18:08 +0000202 ParseObjCInterfaceDeclList(CategoryType, tok::objc_not_keyword);
203 return CategoryType;
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000204 }
205 // Parse a class interface.
206 IdentifierInfo *superClassId = 0;
207 SourceLocation superClassLoc;
Steve Naroff0b6a01a2007-08-22 22:17:26 +0000208
Chris Lattner0ef13522007-10-09 17:51:17 +0000209 if (Tok.is(tok::colon)) { // a super class is specified.
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000210 ConsumeToken();
Douglas Gregor49c22a72009-11-18 16:26:39 +0000211
212 // Code completion of superclass names.
213 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000214 Actions.CodeCompleteObjCSuperclass(getCurScope(), nameId, nameLoc);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000215 ConsumeCodeCompletionToken();
Douglas Gregor49c22a72009-11-18 16:26:39 +0000216 }
217
Chris Lattner0ef13522007-10-09 17:51:17 +0000218 if (Tok.isNot(tok::identifier)) {
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000219 Diag(Tok, diag::err_expected_ident); // missing super class name.
John McCall48871652010-08-21 09:40:31 +0000220 return 0;
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000221 }
222 superClassId = Tok.getIdentifierInfo();
223 superClassLoc = ConsumeToken();
224 }
225 // Next, we need to check for any protocol references.
John McCall48871652010-08-21 09:40:31 +0000226 llvm::SmallVector<Decl *, 8> ProtocolRefs;
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +0000227 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
228 SourceLocation LAngleLoc, EndProtoLoc;
Chris Lattnerdf59f5a2008-07-26 04:13:19 +0000229 if (Tok.is(tok::less) &&
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +0000230 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true,
231 LAngleLoc, EndProtoLoc))
John McCall48871652010-08-21 09:40:31 +0000232 return 0;
Mike Stump11289f42009-09-09 15:08:12 +0000233
John McCall48871652010-08-21 09:40:31 +0000234 Decl *ClsType =
Mike Stump11289f42009-09-09 15:08:12 +0000235 Actions.ActOnStartClassInterface(atLoc, nameId, nameLoc,
Chris Lattnerdf59f5a2008-07-26 04:13:19 +0000236 superClassId, superClassLoc,
Jay Foad7d0479f2009-05-21 09:52:38 +0000237 ProtocolRefs.data(), ProtocolRefs.size(),
Douglas Gregor002b6712010-01-16 15:02:53 +0000238 ProtocolLocs.data(),
John McCall53fa7142010-12-24 02:08:15 +0000239 EndProtoLoc, attrs.getList());
Mike Stump11289f42009-09-09 15:08:12 +0000240
Chris Lattner0ef13522007-10-09 17:51:17 +0000241 if (Tok.is(tok::l_brace))
Fariborz Jahanian4c172c62010-02-22 23:04:20 +0000242 ParseObjCClassInstanceVariables(ClsType, tok::objc_protected, atLoc);
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000243
Fariborz Jahanian39d641f2007-09-17 21:07:36 +0000244 ParseObjCInterfaceDeclList(ClsType, tok::objc_interface);
Fariborz Jahanian65654df2010-04-26 21:18:08 +0000245 return ClsType;
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000246}
247
John McCall064d77b2009-12-03 22:31:13 +0000248/// The Objective-C property callback. This should be defined where
249/// it's used, but instead it's been lifted to here to support VS2005.
250struct Parser::ObjCPropertyCallback : FieldCallback {
251 Parser &P;
John McCall48871652010-08-21 09:40:31 +0000252 Decl *IDecl;
253 llvm::SmallVectorImpl<Decl *> &Props;
John McCall064d77b2009-12-03 22:31:13 +0000254 ObjCDeclSpec &OCDS;
255 SourceLocation AtLoc;
256 tok::ObjCKeywordKind MethodImplKind;
257
John McCall48871652010-08-21 09:40:31 +0000258 ObjCPropertyCallback(Parser &P, Decl *IDecl,
259 llvm::SmallVectorImpl<Decl *> &Props,
John McCall064d77b2009-12-03 22:31:13 +0000260 ObjCDeclSpec &OCDS, SourceLocation AtLoc,
261 tok::ObjCKeywordKind MethodImplKind) :
262 P(P), IDecl(IDecl), Props(Props), OCDS(OCDS), AtLoc(AtLoc),
263 MethodImplKind(MethodImplKind) {
264 }
265
John McCall48871652010-08-21 09:40:31 +0000266 Decl *invoke(FieldDeclarator &FD) {
John McCall064d77b2009-12-03 22:31:13 +0000267 if (FD.D.getIdentifier() == 0) {
268 P.Diag(AtLoc, diag::err_objc_property_requires_field_name)
269 << FD.D.getSourceRange();
John McCall48871652010-08-21 09:40:31 +0000270 return 0;
John McCall064d77b2009-12-03 22:31:13 +0000271 }
272 if (FD.BitfieldSize) {
273 P.Diag(AtLoc, diag::err_objc_property_bitfield)
274 << FD.D.getSourceRange();
John McCall48871652010-08-21 09:40:31 +0000275 return 0;
John McCall064d77b2009-12-03 22:31:13 +0000276 }
277
278 // Install the property declarator into interfaceDecl.
279 IdentifierInfo *SelName =
280 OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier();
281
282 Selector GetterSel =
283 P.PP.getSelectorTable().getNullarySelector(SelName);
284 IdentifierInfo *SetterName = OCDS.getSetterName();
285 Selector SetterSel;
286 if (SetterName)
287 SetterSel = P.PP.getSelectorTable().getSelector(1, &SetterName);
288 else
289 SetterSel = SelectorTable::constructSetterName(P.PP.getIdentifierTable(),
290 P.PP.getSelectorTable(),
291 FD.D.getIdentifier());
292 bool isOverridingProperty = false;
John McCall48871652010-08-21 09:40:31 +0000293 Decl *Property =
Douglas Gregor0be31a22010-07-02 17:43:08 +0000294 P.Actions.ActOnProperty(P.getCurScope(), AtLoc, FD, OCDS,
John McCall064d77b2009-12-03 22:31:13 +0000295 GetterSel, SetterSel, IDecl,
296 &isOverridingProperty,
297 MethodImplKind);
298 if (!isOverridingProperty)
299 Props.push_back(Property);
300
301 return Property;
302 }
303};
304
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000305/// objc-interface-decl-list:
306/// empty
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000307/// objc-interface-decl-list objc-property-decl [OBJC2]
Steve Naroff99264b42007-08-22 16:35:03 +0000308/// objc-interface-decl-list objc-method-requirement [OBJC2]
Steve Naroff09bf8152007-09-06 21:24:23 +0000309/// objc-interface-decl-list objc-method-proto ';'
Steve Naroff1eb1ad62007-08-20 21:31:48 +0000310/// objc-interface-decl-list declaration
311/// objc-interface-decl-list ';'
312///
Steve Naroff99264b42007-08-22 16:35:03 +0000313/// objc-method-requirement: [OBJC2]
314/// @required
315/// @optional
316///
John McCall48871652010-08-21 09:40:31 +0000317void Parser::ParseObjCInterfaceDeclList(Decl *interfaceDecl,
Chris Lattner5e530bc2007-12-27 19:57:00 +0000318 tok::ObjCKeywordKind contextKey) {
John McCall48871652010-08-21 09:40:31 +0000319 llvm::SmallVector<Decl *, 32> allMethods;
320 llvm::SmallVector<Decl *, 16> allProperties;
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000321 llvm::SmallVector<DeclGroupPtrTy, 8> allTUVariables;
Fariborz Jahanian0c74e9d2007-09-18 00:25:23 +0000322 tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword;
Mike Stump11289f42009-09-09 15:08:12 +0000323
Ted Kremenekc7c64312010-01-07 01:20:12 +0000324 SourceRange AtEnd;
Chris Lattnerda9fb152008-10-20 06:10:06 +0000325
Steve Naroff99264b42007-08-22 16:35:03 +0000326 while (1) {
Chris Lattner038a3e32008-10-20 05:46:22 +0000327 // If this is a method prototype, parse it.
Chris Lattner0ef13522007-10-09 17:51:17 +0000328 if (Tok.is(tok::minus) || Tok.is(tok::plus)) {
John McCall48871652010-08-21 09:40:31 +0000329 Decl *methodPrototype =
Fariborz Jahanianc677f692011-03-12 18:54:30 +0000330 ParseObjCMethodPrototype(interfaceDecl, MethodImplKind, false);
Fariborz Jahanian39d641f2007-09-17 21:07:36 +0000331 allMethods.push_back(methodPrototype);
Steve Naroff09bf8152007-09-06 21:24:23 +0000332 // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for
333 // method definitions.
Chris Lattner8510b902009-02-15 22:24:30 +0000334 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_method_proto,
335 "", tok::semi);
Steve Naroff99264b42007-08-22 16:35:03 +0000336 continue;
337 }
Fariborz Jahaniand077f712010-04-02 23:15:40 +0000338 if (Tok.is(tok::l_paren)) {
339 Diag(Tok, diag::err_expected_minus_or_plus);
John McCall48871652010-08-21 09:40:31 +0000340 ParseObjCMethodDecl(Tok.getLocation(),
341 tok::minus,
342 interfaceDecl,
Fariborz Jahanianc677f692011-03-12 18:54:30 +0000343 MethodImplKind, false);
Fariborz Jahaniand077f712010-04-02 23:15:40 +0000344 continue;
345 }
Chris Lattner038a3e32008-10-20 05:46:22 +0000346 // Ignore excess semicolons.
347 if (Tok.is(tok::semi)) {
Steve Naroff99264b42007-08-22 16:35:03 +0000348 ConsumeToken();
Chris Lattner038a3e32008-10-20 05:46:22 +0000349 continue;
350 }
Mike Stump11289f42009-09-09 15:08:12 +0000351
Chris Lattnerda9fb152008-10-20 06:10:06 +0000352 // If we got to the end of the file, exit the loop.
Chris Lattner038a3e32008-10-20 05:46:22 +0000353 if (Tok.is(tok::eof))
Fariborz Jahanian33d03742007-09-10 20:33:04 +0000354 break;
Mike Stump11289f42009-09-09 15:08:12 +0000355
Douglas Gregorf1934162010-01-13 21:24:21 +0000356 // Code completion within an Objective-C interface.
357 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000358 Actions.CodeCompleteOrdinaryName(getCurScope(),
John McCallfaf5fb42010-08-26 23:41:50 +0000359 ObjCImpDecl? Sema::PCC_ObjCImplementation
360 : Sema::PCC_ObjCInterface);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000361 ConsumeCodeCompletionToken();
Douglas Gregorf1934162010-01-13 21:24:21 +0000362 }
363
Chris Lattner038a3e32008-10-20 05:46:22 +0000364 // If we don't have an @ directive, parse it as a function definition.
365 if (Tok.isNot(tok::at)) {
Chris Lattnerc7c9ab72009-01-09 04:34:13 +0000366 // The code below does not consume '}'s because it is afraid of eating the
367 // end of a namespace. Because of the way this code is structured, an
368 // erroneous r_brace would cause an infinite loop if not handled here.
369 if (Tok.is(tok::r_brace))
370 break;
Mike Stump11289f42009-09-09 15:08:12 +0000371
Steve Narofff1bc45b2007-08-22 18:35:33 +0000372 // FIXME: as the name implies, this rule allows function definitions.
373 // We could pass a flag or check for functions during semantic analysis.
John McCall084e83d2011-03-24 11:26:52 +0000374 ParsedAttributes attrs(AttrFactory);
John McCall53fa7142010-12-24 02:08:15 +0000375 allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs));
Chris Lattner038a3e32008-10-20 05:46:22 +0000376 continue;
377 }
Mike Stump11289f42009-09-09 15:08:12 +0000378
Chris Lattner038a3e32008-10-20 05:46:22 +0000379 // Otherwise, we have an @ directive, eat the @.
380 SourceLocation AtLoc = ConsumeToken(); // the "@"
Douglas Gregorf48706c2009-12-07 09:27:33 +0000381 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000382 Actions.CodeCompleteObjCAtDirective(getCurScope(), ObjCImpDecl, true);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000383 ConsumeCodeCompletionToken();
Douglas Gregorf48706c2009-12-07 09:27:33 +0000384 break;
385 }
386
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000387 tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID();
Mike Stump11289f42009-09-09 15:08:12 +0000388
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000389 if (DirectiveKind == tok::objc_end) { // @end -> terminate list
Ted Kremenekc7c64312010-01-07 01:20:12 +0000390 AtEnd.setBegin(AtLoc);
391 AtEnd.setEnd(Tok.getLocation());
Chris Lattner038a3e32008-10-20 05:46:22 +0000392 break;
Douglas Gregor00a0cf72010-03-16 06:04:47 +0000393 } else if (DirectiveKind == tok::objc_not_keyword) {
394 Diag(Tok, diag::err_objc_unknown_at);
395 SkipUntil(tok::semi);
396 continue;
Chris Lattnerda9fb152008-10-20 06:10:06 +0000397 }
Mike Stump11289f42009-09-09 15:08:12 +0000398
Chris Lattnerda9fb152008-10-20 06:10:06 +0000399 // Eat the identifier.
400 ConsumeToken();
401
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000402 switch (DirectiveKind) {
403 default:
Chris Lattnerda9fb152008-10-20 06:10:06 +0000404 // FIXME: If someone forgets an @end on a protocol, this loop will
405 // continue to eat up tons of stuff and spew lots of nonsense errors. It
406 // would probably be better to bail out if we saw an @class or @interface
407 // or something like that.
Chris Lattner76619232008-10-20 07:22:18 +0000408 Diag(AtLoc, diag::err_objc_illegal_interface_qual);
Chris Lattnerda9fb152008-10-20 06:10:06 +0000409 // Skip until we see an '@' or '}' or ';'.
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000410 SkipUntil(tok::r_brace, tok::at);
411 break;
Fariborz Jahaniand4c53482010-11-02 00:44:43 +0000412
413 case tok::objc_implementation:
Fariborz Jahaniandbee9862010-11-09 20:38:00 +0000414 case tok::objc_interface:
Fariborz Jahaniand4c53482010-11-02 00:44:43 +0000415 Diag(Tok, diag::err_objc_missing_end);
416 ConsumeToken();
417 break;
418
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000419 case tok::objc_required:
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000420 case tok::objc_optional:
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000421 // This is only valid on protocols.
Chris Lattnerda9fb152008-10-20 06:10:06 +0000422 // FIXME: Should this check for ObjC2 being enabled?
Chris Lattner038a3e32008-10-20 05:46:22 +0000423 if (contextKey != tok::objc_protocol)
Chris Lattnerda9fb152008-10-20 06:10:06 +0000424 Diag(AtLoc, diag::err_objc_directive_only_in_protocol);
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000425 else
Chris Lattnerda9fb152008-10-20 06:10:06 +0000426 MethodImplKind = DirectiveKind;
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000427 break;
Mike Stump11289f42009-09-09 15:08:12 +0000428
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000429 case tok::objc_property:
Chris Lattner76619232008-10-20 07:22:18 +0000430 if (!getLang().ObjC2)
Chris Lattner4da4e252010-12-17 05:40:22 +0000431 Diag(AtLoc, diag::err_objc_properties_require_objc2);
Chris Lattner76619232008-10-20 07:22:18 +0000432
Chris Lattner038a3e32008-10-20 05:46:22 +0000433 ObjCDeclSpec OCDS;
Mike Stump11289f42009-09-09 15:08:12 +0000434 // Parse property attribute list, if any.
Chris Lattnerbeca7702008-10-20 07:24:39 +0000435 if (Tok.is(tok::l_paren))
Douglas Gregor87e92752010-12-21 17:34:17 +0000436 ParseObjCPropertyAttribute(OCDS, interfaceDecl);
Mike Stump11289f42009-09-09 15:08:12 +0000437
John McCall064d77b2009-12-03 22:31:13 +0000438 ObjCPropertyCallback Callback(*this, interfaceDecl, allProperties,
439 OCDS, AtLoc, MethodImplKind);
John McCallcfefb6d2009-11-03 02:38:08 +0000440
Chris Lattner038a3e32008-10-20 05:46:22 +0000441 // Parse all the comma separated declarators.
John McCall084e83d2011-03-24 11:26:52 +0000442 DeclSpec DS(AttrFactory);
John McCallcfefb6d2009-11-03 02:38:08 +0000443 ParseStructDeclaration(DS, Callback);
Mike Stump11289f42009-09-09 15:08:12 +0000444
Chris Lattnere0d3fe92008-10-20 06:15:13 +0000445 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list, "",
446 tok::at);
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000447 break;
Steve Naroffca85d1d2007-09-05 23:30:30 +0000448 }
Steve Naroff99264b42007-08-22 16:35:03 +0000449 }
Chris Lattnerda9fb152008-10-20 06:10:06 +0000450
451 // We break out of the big loop in two cases: when we see @end or when we see
452 // EOF. In the former case, eat the @end. In the later case, emit an error.
Douglas Gregorf48706c2009-12-07 09:27:33 +0000453 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000454 Actions.CodeCompleteObjCAtDirective(getCurScope(), ObjCImpDecl, true);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000455 ConsumeCodeCompletionToken();
Douglas Gregorf48706c2009-12-07 09:27:33 +0000456 } else if (Tok.isObjCAtKeyword(tok::objc_end))
Chris Lattnerda9fb152008-10-20 06:10:06 +0000457 ConsumeToken(); // the "end" identifier
458 else
459 Diag(Tok, diag::err_objc_missing_end);
Mike Stump11289f42009-09-09 15:08:12 +0000460
Chris Lattnerbb8cc182008-10-20 05:57:40 +0000461 // Insert collected methods declarations into the @interface object.
Chris Lattnerda9fb152008-10-20 06:10:06 +0000462 // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit.
Douglas Gregor0be31a22010-07-02 17:43:08 +0000463 Actions.ActOnAtEnd(getCurScope(), AtEnd, interfaceDecl,
Mike Stump11289f42009-09-09 15:08:12 +0000464 allMethods.data(), allMethods.size(),
Jay Foad7d0479f2009-05-21 09:52:38 +0000465 allProperties.data(), allProperties.size(),
466 allTUVariables.data(), allTUVariables.size());
Steve Naroff99264b42007-08-22 16:35:03 +0000467}
468
Fariborz Jahanian9fca6df2007-08-31 16:11:31 +0000469/// Parse property attribute declarations.
470///
471/// property-attr-decl: '(' property-attrlist ')'
472/// property-attrlist:
473/// property-attribute
474/// property-attrlist ',' property-attribute
475/// property-attribute:
476/// getter '=' identifier
477/// setter '=' identifier ':'
478/// readonly
479/// readwrite
480/// assign
481/// retain
482/// copy
483/// nonatomic
484///
Douglas Gregor87e92752010-12-21 17:34:17 +0000485void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS, Decl *ClassDecl) {
Chris Lattnerbeca7702008-10-20 07:24:39 +0000486 assert(Tok.getKind() == tok::l_paren);
Chris Lattner43c76c32008-10-20 07:00:43 +0000487 SourceLocation LHSLoc = ConsumeParen(); // consume '('
Mike Stump11289f42009-09-09 15:08:12 +0000488
Chris Lattner64b1f2f2008-10-20 07:15:22 +0000489 while (1) {
Steve Naroff936354c2009-10-08 21:55:05 +0000490 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000491 Actions.CodeCompleteObjCPropertyFlags(getCurScope(), DS);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000492 ConsumeCodeCompletionToken();
Steve Naroff936354c2009-10-08 21:55:05 +0000493 }
Fariborz Jahanian9fca6df2007-08-31 16:11:31 +0000494 const IdentifierInfo *II = Tok.getIdentifierInfo();
Mike Stump11289f42009-09-09 15:08:12 +0000495
Chris Lattner76619232008-10-20 07:22:18 +0000496 // If this is not an identifier at all, bail out early.
497 if (II == 0) {
498 MatchRHSPunctuation(tok::r_paren, LHSLoc);
499 return;
500 }
Mike Stump11289f42009-09-09 15:08:12 +0000501
Chris Lattner1db33542008-10-20 07:37:22 +0000502 SourceLocation AttrName = ConsumeToken(); // consume last attribute name
Mike Stump11289f42009-09-09 15:08:12 +0000503
Chris Lattner68e48682008-11-20 04:42:34 +0000504 if (II->isStr("readonly"))
Chris Lattner825bca12008-10-20 07:39:53 +0000505 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readonly);
Chris Lattner68e48682008-11-20 04:42:34 +0000506 else if (II->isStr("assign"))
Chris Lattner825bca12008-10-20 07:39:53 +0000507 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_assign);
Chris Lattner68e48682008-11-20 04:42:34 +0000508 else if (II->isStr("readwrite"))
Chris Lattner825bca12008-10-20 07:39:53 +0000509 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readwrite);
Chris Lattner68e48682008-11-20 04:42:34 +0000510 else if (II->isStr("retain"))
Chris Lattner825bca12008-10-20 07:39:53 +0000511 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_retain);
Chris Lattner68e48682008-11-20 04:42:34 +0000512 else if (II->isStr("copy"))
Chris Lattner825bca12008-10-20 07:39:53 +0000513 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_copy);
Chris Lattner68e48682008-11-20 04:42:34 +0000514 else if (II->isStr("nonatomic"))
Chris Lattner825bca12008-10-20 07:39:53 +0000515 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nonatomic);
Fariborz Jahanian382c0402010-12-17 22:28:16 +0000516 else if (II->isStr("atomic"))
517 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_atomic);
Chris Lattner68e48682008-11-20 04:42:34 +0000518 else if (II->isStr("getter") || II->isStr("setter")) {
Anders Carlssonfe15a782010-10-02 17:45:21 +0000519 bool IsSetter = II->getNameStart()[0] == 's';
520
Chris Lattner825bca12008-10-20 07:39:53 +0000521 // getter/setter require extra treatment.
Anders Carlssonfe15a782010-10-02 17:45:21 +0000522 unsigned DiagID = IsSetter ? diag::err_objc_expected_equal_for_setter :
523 diag::err_objc_expected_equal_for_getter;
524
525 if (ExpectAndConsume(tok::equal, DiagID, "", tok::r_paren))
Chris Lattner43c76c32008-10-20 07:00:43 +0000526 return;
Mike Stump11289f42009-09-09 15:08:12 +0000527
Douglas Gregorc8537c52009-11-19 07:41:15 +0000528 if (Tok.is(tok::code_completion)) {
Anders Carlssonfe15a782010-10-02 17:45:21 +0000529 if (IsSetter)
Douglas Gregor87e92752010-12-21 17:34:17 +0000530 Actions.CodeCompleteObjCPropertySetter(getCurScope(), ClassDecl);
Douglas Gregorc8537c52009-11-19 07:41:15 +0000531 else
Douglas Gregor87e92752010-12-21 17:34:17 +0000532 Actions.CodeCompleteObjCPropertyGetter(getCurScope(), ClassDecl);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000533 ConsumeCodeCompletionToken();
Douglas Gregorc8537c52009-11-19 07:41:15 +0000534 }
535
Anders Carlssonfe15a782010-10-02 17:45:21 +0000536
537 SourceLocation SelLoc;
538 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(SelLoc);
539
540 if (!SelIdent) {
541 Diag(Tok, diag::err_objc_expected_selector_for_getter_setter)
542 << IsSetter;
Chris Lattnerbeca7702008-10-20 07:24:39 +0000543 SkipUntil(tok::r_paren);
544 return;
545 }
Mike Stump11289f42009-09-09 15:08:12 +0000546
Anders Carlssonfe15a782010-10-02 17:45:21 +0000547 if (IsSetter) {
Chris Lattnerbeca7702008-10-20 07:24:39 +0000548 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_setter);
Anders Carlssonfe15a782010-10-02 17:45:21 +0000549 DS.setSetterName(SelIdent);
Mike Stump11289f42009-09-09 15:08:12 +0000550
Fariborz Jahanian8efe0ec2010-02-15 22:20:11 +0000551 if (ExpectAndConsume(tok::colon,
552 diag::err_expected_colon_after_setter_name, "",
Chris Lattner1db33542008-10-20 07:37:22 +0000553 tok::r_paren))
Chris Lattnerbeca7702008-10-20 07:24:39 +0000554 return;
Chris Lattnerbeca7702008-10-20 07:24:39 +0000555 } else {
556 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_getter);
Anders Carlssonfe15a782010-10-02 17:45:21 +0000557 DS.setGetterName(SelIdent);
Chris Lattnerbeca7702008-10-20 07:24:39 +0000558 }
Chris Lattner825bca12008-10-20 07:39:53 +0000559 } else {
Chris Lattner406c0962008-11-19 07:49:38 +0000560 Diag(AttrName, diag::err_objc_expected_property_attr) << II;
Chris Lattner64b1f2f2008-10-20 07:15:22 +0000561 SkipUntil(tok::r_paren);
562 return;
Chris Lattner64b1f2f2008-10-20 07:15:22 +0000563 }
Mike Stump11289f42009-09-09 15:08:12 +0000564
Chris Lattner1db33542008-10-20 07:37:22 +0000565 if (Tok.isNot(tok::comma))
566 break;
Mike Stump11289f42009-09-09 15:08:12 +0000567
Chris Lattner1db33542008-10-20 07:37:22 +0000568 ConsumeToken();
Fariborz Jahanian9fca6df2007-08-31 16:11:31 +0000569 }
Mike Stump11289f42009-09-09 15:08:12 +0000570
Chris Lattner1db33542008-10-20 07:37:22 +0000571 MatchRHSPunctuation(tok::r_paren, LHSLoc);
Fariborz Jahanian9fca6df2007-08-31 16:11:31 +0000572}
573
Steve Naroff09bf8152007-09-06 21:24:23 +0000574/// objc-method-proto:
Mike Stump11289f42009-09-09 15:08:12 +0000575/// objc-instance-method objc-method-decl objc-method-attributes[opt]
Steve Naroff09bf8152007-09-06 21:24:23 +0000576/// objc-class-method objc-method-decl objc-method-attributes[opt]
Steve Naroff99264b42007-08-22 16:35:03 +0000577///
578/// objc-instance-method: '-'
579/// objc-class-method: '+'
580///
Steve Narofff1bc45b2007-08-22 18:35:33 +0000581/// objc-method-attributes: [OBJC2]
582/// __attribute__((deprecated))
583///
John McCall48871652010-08-21 09:40:31 +0000584Decl *Parser::ParseObjCMethodPrototype(Decl *IDecl,
Fariborz Jahanianc677f692011-03-12 18:54:30 +0000585 tok::ObjCKeywordKind MethodImplKind,
586 bool MethodDefinition) {
Chris Lattner0ef13522007-10-09 17:51:17 +0000587 assert((Tok.is(tok::minus) || Tok.is(tok::plus)) && "expected +/-");
Steve Naroff99264b42007-08-22 16:35:03 +0000588
Mike Stump11289f42009-09-09 15:08:12 +0000589 tok::TokenKind methodType = Tok.getKind();
Steve Naroff161a92b2007-10-26 20:53:56 +0000590 SourceLocation mLoc = ConsumeToken();
Fariborz Jahanianc677f692011-03-12 18:54:30 +0000591 Decl *MDecl = ParseObjCMethodDecl(mLoc, methodType, IDecl,MethodImplKind,
592 MethodDefinition);
Steve Naroff09bf8152007-09-06 21:24:23 +0000593 // Since this rule is used for both method declarations and definitions,
Steve Naroffacb1e742007-09-10 20:51:04 +0000594 // the caller is (optionally) responsible for consuming the ';'.
Steve Naroffca85d1d2007-09-05 23:30:30 +0000595 return MDecl;
Steve Naroff99264b42007-08-22 16:35:03 +0000596}
597
598/// objc-selector:
599/// identifier
600/// one of
601/// enum struct union if else while do for switch case default
602/// break continue return goto asm sizeof typeof __alignof
603/// unsigned long const short volatile signed restrict _Complex
604/// in out inout bycopy byref oneway int char float double void _Bool
605///
Chris Lattner4f472a32009-04-11 18:13:45 +0000606IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) {
Fariborz Jahanian0389df4a2010-09-03 01:26:16 +0000607
Chris Lattner5700fab2007-10-07 02:00:24 +0000608 switch (Tok.getKind()) {
609 default:
610 return 0;
Fariborz Jahanian9e42a952010-09-03 17:33:04 +0000611 case tok::ampamp:
612 case tok::ampequal:
613 case tok::amp:
614 case tok::pipe:
615 case tok::tilde:
616 case tok::exclaim:
617 case tok::exclaimequal:
618 case tok::pipepipe:
619 case tok::pipeequal:
620 case tok::caret:
621 case tok::caretequal: {
Fariborz Jahaniandadfc1c2010-09-03 18:01:09 +0000622 std::string ThisTok(PP.getSpelling(Tok));
Fariborz Jahanian9e42a952010-09-03 17:33:04 +0000623 if (isalpha(ThisTok[0])) {
624 IdentifierInfo *II = &PP.getIdentifierTable().get(ThisTok.data());
625 Tok.setKind(tok::identifier);
626 SelectorLoc = ConsumeToken();
627 return II;
628 }
629 return 0;
630 }
631
Chris Lattner5700fab2007-10-07 02:00:24 +0000632 case tok::identifier:
Anders Carlssonf93f56a2008-08-23 21:00:01 +0000633 case tok::kw_asm:
Chris Lattner5700fab2007-10-07 02:00:24 +0000634 case tok::kw_auto:
Chris Lattnerbb31a422007-11-15 05:25:19 +0000635 case tok::kw_bool:
Anders Carlssonf93f56a2008-08-23 21:00:01 +0000636 case tok::kw_break:
637 case tok::kw_case:
638 case tok::kw_catch:
639 case tok::kw_char:
640 case tok::kw_class:
641 case tok::kw_const:
642 case tok::kw_const_cast:
643 case tok::kw_continue:
644 case tok::kw_default:
645 case tok::kw_delete:
646 case tok::kw_do:
647 case tok::kw_double:
648 case tok::kw_dynamic_cast:
649 case tok::kw_else:
650 case tok::kw_enum:
651 case tok::kw_explicit:
652 case tok::kw_export:
653 case tok::kw_extern:
654 case tok::kw_false:
655 case tok::kw_float:
656 case tok::kw_for:
657 case tok::kw_friend:
658 case tok::kw_goto:
659 case tok::kw_if:
660 case tok::kw_inline:
661 case tok::kw_int:
662 case tok::kw_long:
663 case tok::kw_mutable:
664 case tok::kw_namespace:
665 case tok::kw_new:
666 case tok::kw_operator:
667 case tok::kw_private:
668 case tok::kw_protected:
669 case tok::kw_public:
670 case tok::kw_register:
671 case tok::kw_reinterpret_cast:
672 case tok::kw_restrict:
673 case tok::kw_return:
674 case tok::kw_short:
675 case tok::kw_signed:
676 case tok::kw_sizeof:
677 case tok::kw_static:
678 case tok::kw_static_cast:
679 case tok::kw_struct:
680 case tok::kw_switch:
681 case tok::kw_template:
682 case tok::kw_this:
683 case tok::kw_throw:
684 case tok::kw_true:
685 case tok::kw_try:
686 case tok::kw_typedef:
687 case tok::kw_typeid:
688 case tok::kw_typename:
689 case tok::kw_typeof:
690 case tok::kw_union:
691 case tok::kw_unsigned:
692 case tok::kw_using:
693 case tok::kw_virtual:
694 case tok::kw_void:
695 case tok::kw_volatile:
696 case tok::kw_wchar_t:
697 case tok::kw_while:
Chris Lattner5700fab2007-10-07 02:00:24 +0000698 case tok::kw__Bool:
699 case tok::kw__Complex:
Anders Carlssonf93f56a2008-08-23 21:00:01 +0000700 case tok::kw___alignof:
Chris Lattner5700fab2007-10-07 02:00:24 +0000701 IdentifierInfo *II = Tok.getIdentifierInfo();
Fariborz Jahanian70e8f102007-10-11 00:55:41 +0000702 SelectorLoc = ConsumeToken();
Chris Lattner5700fab2007-10-07 02:00:24 +0000703 return II;
Fariborz Jahanianfa80e802007-09-27 19:52:15 +0000704 }
Steve Naroff99264b42007-08-22 16:35:03 +0000705}
706
Fariborz Jahanian83615522008-01-02 22:54:34 +0000707/// objc-for-collection-in: 'in'
708///
Fariborz Jahanian3622e592008-01-04 23:04:08 +0000709bool Parser::isTokIdentifier_in() const {
Fariborz Jahanian732b8c22008-01-03 17:55:25 +0000710 // FIXME: May have to do additional look-ahead to only allow for
711 // valid tokens following an 'in'; such as an identifier, unary operators,
712 // '[' etc.
Mike Stump11289f42009-09-09 15:08:12 +0000713 return (getLang().ObjC2 && Tok.is(tok::identifier) &&
Chris Lattnerce90ef52008-08-23 02:02:23 +0000714 Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]);
Fariborz Jahanian83615522008-01-02 22:54:34 +0000715}
716
Ted Kremenek1b0ea822008-01-07 19:49:32 +0000717/// ParseObjCTypeQualifierList - This routine parses the objective-c's type
Chris Lattner61511e12007-12-12 06:56:32 +0000718/// qualifier list and builds their bitmask representation in the input
719/// argument.
Steve Naroff99264b42007-08-22 16:35:03 +0000720///
721/// objc-type-qualifiers:
722/// objc-type-qualifier
723/// objc-type-qualifiers objc-type-qualifier
724///
Douglas Gregor95d3e372011-03-08 19:17:54 +0000725void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS,
726 ObjCTypeNameContext Context) {
Chris Lattner61511e12007-12-12 06:56:32 +0000727 while (1) {
Douglas Gregor99fa2642010-08-24 01:06:58 +0000728 if (Tok.is(tok::code_completion)) {
Douglas Gregor95d3e372011-03-08 19:17:54 +0000729 Actions.CodeCompleteObjCPassingType(getCurScope(), DS,
730 Context == OTN_ParameterType);
Douglas Gregor99fa2642010-08-24 01:06:58 +0000731 ConsumeCodeCompletionToken();
732 }
733
Chris Lattner5e530bc2007-12-27 19:57:00 +0000734 if (Tok.isNot(tok::identifier))
Chris Lattner61511e12007-12-12 06:56:32 +0000735 return;
Mike Stump11289f42009-09-09 15:08:12 +0000736
Chris Lattner61511e12007-12-12 06:56:32 +0000737 const IdentifierInfo *II = Tok.getIdentifierInfo();
738 for (unsigned i = 0; i != objc_NumQuals; ++i) {
Ted Kremenek1b0ea822008-01-07 19:49:32 +0000739 if (II != ObjCTypeQuals[i])
Chris Lattner61511e12007-12-12 06:56:32 +0000740 continue;
Mike Stump11289f42009-09-09 15:08:12 +0000741
Ted Kremenek1b0ea822008-01-07 19:49:32 +0000742 ObjCDeclSpec::ObjCDeclQualifier Qual;
Chris Lattner61511e12007-12-12 06:56:32 +0000743 switch (i) {
744 default: assert(0 && "Unknown decl qualifier");
Ted Kremenek1b0ea822008-01-07 19:49:32 +0000745 case objc_in: Qual = ObjCDeclSpec::DQ_In; break;
746 case objc_out: Qual = ObjCDeclSpec::DQ_Out; break;
747 case objc_inout: Qual = ObjCDeclSpec::DQ_Inout; break;
748 case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break;
749 case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break;
750 case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break;
Chris Lattner61511e12007-12-12 06:56:32 +0000751 }
Ted Kremenek1b0ea822008-01-07 19:49:32 +0000752 DS.setObjCDeclQualifier(Qual);
Chris Lattner61511e12007-12-12 06:56:32 +0000753 ConsumeToken();
754 II = 0;
755 break;
756 }
Mike Stump11289f42009-09-09 15:08:12 +0000757
Chris Lattner61511e12007-12-12 06:56:32 +0000758 // If this wasn't a recognized qualifier, bail out.
759 if (II) return;
760 }
761}
762
763/// objc-type-name:
764/// '(' objc-type-qualifiers[opt] type-name ')'
765/// '(' objc-type-qualifiers[opt] ')'
766///
Douglas Gregor95d3e372011-03-08 19:17:54 +0000767ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS,
768 ObjCTypeNameContext Context) {
Chris Lattner0ef13522007-10-09 17:51:17 +0000769 assert(Tok.is(tok::l_paren) && "expected (");
Mike Stump11289f42009-09-09 15:08:12 +0000770
Chris Lattnerb7954432008-10-22 03:52:06 +0000771 SourceLocation LParenLoc = ConsumeParen();
Chris Lattner2ebb1782008-08-23 01:48:03 +0000772 SourceLocation TypeStartLoc = Tok.getLocation();
Mike Stump11289f42009-09-09 15:08:12 +0000773
Fariborz Jahaniand822d682007-10-31 21:59:43 +0000774 // Parse type qualifiers, in, inout, etc.
Douglas Gregor95d3e372011-03-08 19:17:54 +0000775 ParseObjCTypeQualifierList(DS, Context);
Steve Naroff7e901fd2007-08-22 23:18:22 +0000776
John McCallba7bf592010-08-24 05:47:05 +0000777 ParsedType Ty;
Douglas Gregor220cac52009-02-18 17:45:20 +0000778 if (isTypeSpecifierQualifier()) {
John McCallc23308c2011-03-23 23:43:04 +0000779 TypeResult TypeSpec = ParseTypeName(0, Declarator::ObjCPrototypeContext);
Douglas Gregor220cac52009-02-18 17:45:20 +0000780 if (!TypeSpec.isInvalid())
781 Ty = TypeSpec.get();
782 }
Mike Stump11289f42009-09-09 15:08:12 +0000783
Steve Naroff90255b42008-10-21 14:15:04 +0000784 if (Tok.is(tok::r_paren))
Chris Lattnerb7954432008-10-22 03:52:06 +0000785 ConsumeParen();
786 else if (Tok.getLocation() == TypeStartLoc) {
787 // If we didn't eat any tokens, then this isn't a type.
Chris Lattner6d29c102008-11-18 07:48:38 +0000788 Diag(Tok, diag::err_expected_type);
Chris Lattnerb7954432008-10-22 03:52:06 +0000789 SkipUntil(tok::r_paren);
790 } else {
791 // Otherwise, we found *something*, but didn't get a ')' in the right
792 // place. Emit an error then return what we have as the type.
793 MatchRHSPunctuation(tok::r_paren, LParenLoc);
794 }
Steve Naroffca85d1d2007-09-05 23:30:30 +0000795 return Ty;
Steve Naroff99264b42007-08-22 16:35:03 +0000796}
797
798/// objc-method-decl:
799/// objc-selector
Steve Narofff1bc45b2007-08-22 18:35:33 +0000800/// objc-keyword-selector objc-parmlist[opt]
Steve Naroff99264b42007-08-22 16:35:03 +0000801/// objc-type-name objc-selector
Steve Narofff1bc45b2007-08-22 18:35:33 +0000802/// objc-type-name objc-keyword-selector objc-parmlist[opt]
Steve Naroff99264b42007-08-22 16:35:03 +0000803///
804/// objc-keyword-selector:
Mike Stump11289f42009-09-09 15:08:12 +0000805/// objc-keyword-decl
Steve Naroff99264b42007-08-22 16:35:03 +0000806/// objc-keyword-selector objc-keyword-decl
807///
808/// objc-keyword-decl:
Steve Naroff0b6a01a2007-08-22 22:17:26 +0000809/// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier
810/// objc-selector ':' objc-keyword-attributes[opt] identifier
811/// ':' objc-type-name objc-keyword-attributes[opt] identifier
812/// ':' objc-keyword-attributes[opt] identifier
Steve Naroff99264b42007-08-22 16:35:03 +0000813///
Steve Narofff1bc45b2007-08-22 18:35:33 +0000814/// objc-parmlist:
815/// objc-parms objc-ellipsis[opt]
Steve Naroff99264b42007-08-22 16:35:03 +0000816///
Steve Narofff1bc45b2007-08-22 18:35:33 +0000817/// objc-parms:
818/// objc-parms , parameter-declaration
Steve Naroff99264b42007-08-22 16:35:03 +0000819///
Steve Narofff1bc45b2007-08-22 18:35:33 +0000820/// objc-ellipsis:
Steve Naroff99264b42007-08-22 16:35:03 +0000821/// , ...
822///
Steve Naroff0b6a01a2007-08-22 22:17:26 +0000823/// objc-keyword-attributes: [OBJC2]
824/// __attribute__((unused))
825///
John McCall48871652010-08-21 09:40:31 +0000826Decl *Parser::ParseObjCMethodDecl(SourceLocation mLoc,
Douglas Gregorc49f5b22010-08-23 18:23:48 +0000827 tok::TokenKind mType,
828 Decl *IDecl,
Fariborz Jahanianc677f692011-03-12 18:54:30 +0000829 tok::ObjCKeywordKind MethodImplKind,
830 bool MethodDefinition) {
John McCall28a6aea2009-11-04 02:18:39 +0000831 ParsingDeclRAIIObject PD(*this);
832
Douglas Gregor636a61e2010-04-07 00:21:17 +0000833 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000834 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
John McCallba7bf592010-08-24 05:47:05 +0000835 /*ReturnType=*/ ParsedType(), IDecl);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000836 ConsumeCodeCompletionToken();
Douglas Gregor636a61e2010-04-07 00:21:17 +0000837 }
838
Chris Lattner2ebb1782008-08-23 01:48:03 +0000839 // Parse the return type if present.
John McCallba7bf592010-08-24 05:47:05 +0000840 ParsedType ReturnType;
Ted Kremenek1b0ea822008-01-07 19:49:32 +0000841 ObjCDeclSpec DSRet;
Chris Lattner0ef13522007-10-09 17:51:17 +0000842 if (Tok.is(tok::l_paren))
Douglas Gregor95d3e372011-03-08 19:17:54 +0000843 ReturnType = ParseObjCTypeName(DSRet, OTN_ResultType);
Mike Stump11289f42009-09-09 15:08:12 +0000844
Ted Kremenek66f2d6b2010-02-18 23:05:16 +0000845 // If attributes exist before the method, parse them.
John McCall084e83d2011-03-24 11:26:52 +0000846 ParsedAttributes methodAttrs(AttrFactory);
John McCall53fa7142010-12-24 02:08:15 +0000847 if (getLang().ObjC2)
John McCall084e83d2011-03-24 11:26:52 +0000848 MaybeParseGNUAttributes(methodAttrs);
Ted Kremenek66f2d6b2010-02-18 23:05:16 +0000849
Douglas Gregor636a61e2010-04-07 00:21:17 +0000850 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000851 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
Douglas Gregor636a61e2010-04-07 00:21:17 +0000852 ReturnType, IDecl);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000853 ConsumeCodeCompletionToken();
Douglas Gregor636a61e2010-04-07 00:21:17 +0000854 }
855
Ted Kremenek66f2d6b2010-02-18 23:05:16 +0000856 // Now parse the selector.
Steve Naroff161a92b2007-10-26 20:53:56 +0000857 SourceLocation selLoc;
Chris Lattner4f472a32009-04-11 18:13:45 +0000858 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(selLoc);
Chris Lattner2ebb1782008-08-23 01:48:03 +0000859
Steve Naroff7a54c0d2009-02-11 20:43:13 +0000860 // An unnamed colon is valid.
861 if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name.
Chris Lattner6d29c102008-11-18 07:48:38 +0000862 Diag(Tok, diag::err_expected_selector_for_method)
863 << SourceRange(mLoc, Tok.getLocation());
Chris Lattner2ebb1782008-08-23 01:48:03 +0000864 // Skip until we get a ; or {}.
865 SkipUntil(tok::r_brace);
John McCall48871652010-08-21 09:40:31 +0000866 return 0;
Chris Lattner2ebb1782008-08-23 01:48:03 +0000867 }
Mike Stump11289f42009-09-09 15:08:12 +0000868
Fariborz Jahanian60462092010-04-08 00:30:06 +0000869 llvm::SmallVector<DeclaratorChunk::ParamInfo, 8> CParamInfo;
Chris Lattner0ef13522007-10-09 17:51:17 +0000870 if (Tok.isNot(tok::colon)) {
Chris Lattner5700fab2007-10-07 02:00:24 +0000871 // If attributes exist after the method, parse them.
John McCall53fa7142010-12-24 02:08:15 +0000872 if (getLang().ObjC2)
John McCall084e83d2011-03-24 11:26:52 +0000873 MaybeParseGNUAttributes(methodAttrs);
Mike Stump11289f42009-09-09 15:08:12 +0000874
Chris Lattner5700fab2007-10-07 02:00:24 +0000875 Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent);
John McCall48871652010-08-21 09:40:31 +0000876 Decl *Result
Fariborz Jahanianca3566f2011-02-09 22:20:01 +0000877 = Actions.ActOnMethodDeclaration(getCurScope(), mLoc, Tok.getLocation(),
Fariborz Jahanianb5605172007-11-09 19:52:12 +0000878 mType, IDecl, DSRet, ReturnType, Sel,
Fariborz Jahanian60462092010-04-08 00:30:06 +0000879 0,
880 CParamInfo.data(), CParamInfo.size(),
John McCall084e83d2011-03-24 11:26:52 +0000881 methodAttrs.getList(), MethodImplKind,
882 false, MethodDefinition);
John McCall28a6aea2009-11-04 02:18:39 +0000883 PD.complete(Result);
884 return Result;
Chris Lattner5700fab2007-10-07 02:00:24 +0000885 }
Steve Naroffca85d1d2007-09-05 23:30:30 +0000886
Steve Narofff73590d2007-09-27 14:38:14 +0000887 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
John McCallfaf5fb42010-08-26 23:41:50 +0000888 llvm::SmallVector<Sema::ObjCArgInfo, 12> ArgInfos;
Fariborz Jahanianca3566f2011-02-09 22:20:01 +0000889 ParseScope PrototypeScope(this,
890 Scope::FunctionPrototypeScope|Scope::DeclScope);
John McCall084e83d2011-03-24 11:26:52 +0000891
892 AttributePool allParamAttrs(AttrFactory);
Fariborz Jahanianca3566f2011-02-09 22:20:01 +0000893
Chris Lattner5700fab2007-10-07 02:00:24 +0000894 while (1) {
John McCall084e83d2011-03-24 11:26:52 +0000895 ParsedAttributes paramAttrs(AttrFactory);
John McCallfaf5fb42010-08-26 23:41:50 +0000896 Sema::ObjCArgInfo ArgInfo;
Mike Stump11289f42009-09-09 15:08:12 +0000897
Chris Lattner5700fab2007-10-07 02:00:24 +0000898 // Each iteration parses a single keyword argument.
Chris Lattner0ef13522007-10-09 17:51:17 +0000899 if (Tok.isNot(tok::colon)) {
Chris Lattner5700fab2007-10-07 02:00:24 +0000900 Diag(Tok, diag::err_expected_colon);
901 break;
902 }
903 ConsumeToken(); // Eat the ':'.
Mike Stump11289f42009-09-09 15:08:12 +0000904
John McCallba7bf592010-08-24 05:47:05 +0000905 ArgInfo.Type = ParsedType();
Chris Lattnerd8626fd2009-04-11 18:57:04 +0000906 if (Tok.is(tok::l_paren)) // Parse the argument type if present.
Douglas Gregor95d3e372011-03-08 19:17:54 +0000907 ArgInfo.Type = ParseObjCTypeName(ArgInfo.DeclSpec, OTN_ParameterType);
Chris Lattnerd8626fd2009-04-11 18:57:04 +0000908
Chris Lattner5700fab2007-10-07 02:00:24 +0000909 // If attributes exist before the argument name, parse them.
Chris Lattnerd8626fd2009-04-11 18:57:04 +0000910 ArgInfo.ArgAttrs = 0;
John McCall53fa7142010-12-24 02:08:15 +0000911 if (getLang().ObjC2) {
John McCall084e83d2011-03-24 11:26:52 +0000912 MaybeParseGNUAttributes(paramAttrs);
913 ArgInfo.ArgAttrs = paramAttrs.getList();
John McCall53fa7142010-12-24 02:08:15 +0000914 }
Steve Naroff0b6a01a2007-08-22 22:17:26 +0000915
Douglas Gregor45879692010-07-08 23:37:41 +0000916 // Code completion for the next piece of the selector.
917 if (Tok.is(tok::code_completion)) {
918 ConsumeCodeCompletionToken();
919 KeyIdents.push_back(SelIdent);
920 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
921 mType == tok::minus,
922 /*AtParameterName=*/true,
923 ReturnType,
924 KeyIdents.data(),
925 KeyIdents.size());
926 KeyIdents.pop_back();
927 break;
928 }
929
Chris Lattner0ef13522007-10-09 17:51:17 +0000930 if (Tok.isNot(tok::identifier)) {
Chris Lattner5700fab2007-10-07 02:00:24 +0000931 Diag(Tok, diag::err_expected_ident); // missing argument name.
932 break;
Steve Narofff1bc45b2007-08-22 18:35:33 +0000933 }
Mike Stump11289f42009-09-09 15:08:12 +0000934
Chris Lattnerd8626fd2009-04-11 18:57:04 +0000935 ArgInfo.Name = Tok.getIdentifierInfo();
936 ArgInfo.NameLoc = Tok.getLocation();
Chris Lattner5700fab2007-10-07 02:00:24 +0000937 ConsumeToken(); // Eat the identifier.
Mike Stump11289f42009-09-09 15:08:12 +0000938
Chris Lattnerd8626fd2009-04-11 18:57:04 +0000939 ArgInfos.push_back(ArgInfo);
940 KeyIdents.push_back(SelIdent);
941
John McCall084e83d2011-03-24 11:26:52 +0000942 // Make sure the attributes persist.
943 allParamAttrs.takeAllFrom(paramAttrs.getPool());
944
Douglas Gregor95887f92010-07-08 23:20:03 +0000945 // Code completion for the next piece of the selector.
946 if (Tok.is(tok::code_completion)) {
947 ConsumeCodeCompletionToken();
948 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
949 mType == tok::minus,
Douglas Gregor45879692010-07-08 23:37:41 +0000950 /*AtParameterName=*/false,
Douglas Gregor95887f92010-07-08 23:20:03 +0000951 ReturnType,
952 KeyIdents.data(),
953 KeyIdents.size());
954 break;
955 }
956
Chris Lattner5700fab2007-10-07 02:00:24 +0000957 // Check for another keyword selector.
Fariborz Jahanian70e8f102007-10-11 00:55:41 +0000958 SourceLocation Loc;
Chris Lattner4f472a32009-04-11 18:13:45 +0000959 SelIdent = ParseObjCSelectorPiece(Loc);
Chris Lattner0ef13522007-10-09 17:51:17 +0000960 if (!SelIdent && Tok.isNot(tok::colon))
Chris Lattner5700fab2007-10-07 02:00:24 +0000961 break;
962 // We have a selector or a colon, continue parsing.
Steve Narofff1bc45b2007-08-22 18:35:33 +0000963 }
Mike Stump11289f42009-09-09 15:08:12 +0000964
Steve Naroffd8ea1ac2007-11-15 12:35:21 +0000965 bool isVariadic = false;
Mike Stump11289f42009-09-09 15:08:12 +0000966
Chris Lattner5700fab2007-10-07 02:00:24 +0000967 // Parse the (optional) parameter list.
Chris Lattner0ef13522007-10-09 17:51:17 +0000968 while (Tok.is(tok::comma)) {
Chris Lattner5700fab2007-10-07 02:00:24 +0000969 ConsumeToken();
Chris Lattner0ef13522007-10-09 17:51:17 +0000970 if (Tok.is(tok::ellipsis)) {
Steve Naroffd8ea1ac2007-11-15 12:35:21 +0000971 isVariadic = true;
Chris Lattner5700fab2007-10-07 02:00:24 +0000972 ConsumeToken();
973 break;
974 }
John McCall084e83d2011-03-24 11:26:52 +0000975 DeclSpec DS(AttrFactory);
Chris Lattner5700fab2007-10-07 02:00:24 +0000976 ParseDeclarationSpecifiers(DS);
Mike Stump11289f42009-09-09 15:08:12 +0000977 // Parse the declarator.
Chris Lattner5700fab2007-10-07 02:00:24 +0000978 Declarator ParmDecl(DS, Declarator::PrototypeContext);
979 ParseDeclarator(ParmDecl);
Fariborz Jahanian60462092010-04-08 00:30:06 +0000980 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
John McCall48871652010-08-21 09:40:31 +0000981 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
Fariborz Jahanian60462092010-04-08 00:30:06 +0000982 CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
983 ParmDecl.getIdentifierLoc(),
984 Param,
985 0));
986
Chris Lattner5700fab2007-10-07 02:00:24 +0000987 }
Mike Stump11289f42009-09-09 15:08:12 +0000988
Cameron Esfahanif6c73c42010-10-12 00:21:25 +0000989 // FIXME: Add support for optional parameter list...
Fariborz Jahanian33d03742007-09-10 20:33:04 +0000990 // If attributes exist after the method, parse them.
John McCall53fa7142010-12-24 02:08:15 +0000991 if (getLang().ObjC2)
John McCall084e83d2011-03-24 11:26:52 +0000992 MaybeParseGNUAttributes(methodAttrs);
Fariborz Jahanianca3566f2011-02-09 22:20:01 +0000993
994 if (KeyIdents.size() == 0) {
995 // Leave prototype scope.
996 PrototypeScope.Exit();
John McCall48871652010-08-21 09:40:31 +0000997 return 0;
Fariborz Jahanianca3566f2011-02-09 22:20:01 +0000998 }
999
Chris Lattner5700fab2007-10-07 02:00:24 +00001000 Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(),
1001 &KeyIdents[0]);
John McCall48871652010-08-21 09:40:31 +00001002 Decl *Result
Fariborz Jahanianca3566f2011-02-09 22:20:01 +00001003 = Actions.ActOnMethodDeclaration(getCurScope(), mLoc, Tok.getLocation(),
Fariborz Jahanian6e9e4f32009-06-24 17:00:18 +00001004 mType, IDecl, DSRet, ReturnType, Sel,
Fariborz Jahanian60462092010-04-08 00:30:06 +00001005 &ArgInfos[0],
1006 CParamInfo.data(), CParamInfo.size(),
John McCall084e83d2011-03-24 11:26:52 +00001007 methodAttrs.getList(),
Fariborz Jahanianc677f692011-03-12 18:54:30 +00001008 MethodImplKind, isVariadic, MethodDefinition);
Fariborz Jahanianca3566f2011-02-09 22:20:01 +00001009 // Leave prototype scope.
1010 PrototypeScope.Exit();
1011
John McCall28a6aea2009-11-04 02:18:39 +00001012 PD.complete(Result);
1013 return Result;
Steve Naroff99264b42007-08-22 16:35:03 +00001014}
1015
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001016/// objc-protocol-refs:
1017/// '<' identifier-list '>'
1018///
Chris Lattnerd7352d62008-07-21 22:17:28 +00001019bool Parser::
John McCall48871652010-08-21 09:40:31 +00001020ParseObjCProtocolReferences(llvm::SmallVectorImpl<Decl *> &Protocols,
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001021 llvm::SmallVectorImpl<SourceLocation> &ProtocolLocs,
1022 bool WarnOnDeclarations,
1023 SourceLocation &LAngleLoc, SourceLocation &EndLoc) {
Chris Lattner3bbae002008-07-26 04:03:38 +00001024 assert(Tok.is(tok::less) && "expected <");
Mike Stump11289f42009-09-09 15:08:12 +00001025
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001026 LAngleLoc = ConsumeToken(); // the "<"
Mike Stump11289f42009-09-09 15:08:12 +00001027
Chris Lattner3bbae002008-07-26 04:03:38 +00001028 llvm::SmallVector<IdentifierLocPair, 8> ProtocolIdents;
Mike Stump11289f42009-09-09 15:08:12 +00001029
Chris Lattner3bbae002008-07-26 04:03:38 +00001030 while (1) {
Douglas Gregorbaf69612009-11-18 04:19:12 +00001031 if (Tok.is(tok::code_completion)) {
1032 Actions.CodeCompleteObjCProtocolReferences(ProtocolIdents.data(),
1033 ProtocolIdents.size());
Douglas Gregor6da3db42010-05-25 05:58:43 +00001034 ConsumeCodeCompletionToken();
Douglas Gregorbaf69612009-11-18 04:19:12 +00001035 }
1036
Chris Lattner3bbae002008-07-26 04:03:38 +00001037 if (Tok.isNot(tok::identifier)) {
1038 Diag(Tok, diag::err_expected_ident);
1039 SkipUntil(tok::greater);
1040 return true;
1041 }
1042 ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(),
1043 Tok.getLocation()));
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001044 ProtocolLocs.push_back(Tok.getLocation());
Chris Lattner3bbae002008-07-26 04:03:38 +00001045 ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00001046
Chris Lattner3bbae002008-07-26 04:03:38 +00001047 if (Tok.isNot(tok::comma))
1048 break;
1049 ConsumeToken();
1050 }
Mike Stump11289f42009-09-09 15:08:12 +00001051
Chris Lattner3bbae002008-07-26 04:03:38 +00001052 // Consume the '>'.
1053 if (Tok.isNot(tok::greater)) {
1054 Diag(Tok, diag::err_expected_greater);
1055 return true;
1056 }
Mike Stump11289f42009-09-09 15:08:12 +00001057
Chris Lattner3bbae002008-07-26 04:03:38 +00001058 EndLoc = ConsumeAnyToken();
Mike Stump11289f42009-09-09 15:08:12 +00001059
Chris Lattner3bbae002008-07-26 04:03:38 +00001060 // Convert the list of protocols identifiers into a list of protocol decls.
1061 Actions.FindProtocolDeclaration(WarnOnDeclarations,
1062 &ProtocolIdents[0], ProtocolIdents.size(),
1063 Protocols);
1064 return false;
1065}
1066
Douglas Gregor06e41ae2010-10-21 23:17:00 +00001067/// \brief Parse the Objective-C protocol qualifiers that follow a typename
1068/// in a decl-specifier-seq, starting at the '<'.
Douglas Gregor3a001f42010-11-19 17:10:50 +00001069bool Parser::ParseObjCProtocolQualifiers(DeclSpec &DS) {
Douglas Gregor06e41ae2010-10-21 23:17:00 +00001070 assert(Tok.is(tok::less) && "Protocol qualifiers start with '<'");
1071 assert(getLang().ObjC1 && "Protocol qualifiers only exist in Objective-C");
1072 SourceLocation LAngleLoc, EndProtoLoc;
1073 llvm::SmallVector<Decl *, 8> ProtocolDecl;
1074 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
Douglas Gregor3a001f42010-11-19 17:10:50 +00001075 bool Result = ParseObjCProtocolReferences(ProtocolDecl, ProtocolLocs, false,
1076 LAngleLoc, EndProtoLoc);
Douglas Gregor06e41ae2010-10-21 23:17:00 +00001077 DS.setProtocolQualifiers(ProtocolDecl.data(), ProtocolDecl.size(),
1078 ProtocolLocs.data(), LAngleLoc);
1079 if (EndProtoLoc.isValid())
1080 DS.SetRangeEnd(EndProtoLoc);
Douglas Gregor3a001f42010-11-19 17:10:50 +00001081 return Result;
Douglas Gregor06e41ae2010-10-21 23:17:00 +00001082}
1083
1084
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001085/// objc-class-instance-variables:
1086/// '{' objc-instance-variable-decl-list[opt] '}'
1087///
1088/// objc-instance-variable-decl-list:
1089/// objc-visibility-spec
1090/// objc-instance-variable-decl ';'
1091/// ';'
1092/// objc-instance-variable-decl-list objc-visibility-spec
1093/// objc-instance-variable-decl-list objc-instance-variable-decl ';'
1094/// objc-instance-variable-decl-list ';'
1095///
1096/// objc-visibility-spec:
1097/// @private
1098/// @protected
1099/// @public
Steve Naroff00433d32007-08-21 21:17:12 +00001100/// @package [OBJC2]
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001101///
1102/// objc-instance-variable-decl:
Mike Stump11289f42009-09-09 15:08:12 +00001103/// struct-declaration
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001104///
John McCall48871652010-08-21 09:40:31 +00001105void Parser::ParseObjCClassInstanceVariables(Decl *interfaceDecl,
Fariborz Jahanian4c172c62010-02-22 23:04:20 +00001106 tok::ObjCKeywordKind visibility,
Steve Naroff33a1e802007-10-29 21:38:07 +00001107 SourceLocation atLoc) {
Chris Lattner0ef13522007-10-09 17:51:17 +00001108 assert(Tok.is(tok::l_brace) && "expected {");
John McCall48871652010-08-21 09:40:31 +00001109 llvm::SmallVector<Decl *, 32> AllIvarDecls;
Chris Lattnera12405b2008-04-10 06:46:29 +00001110
Douglas Gregor45a33ec2009-01-12 18:45:55 +00001111 ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope);
Douglas Gregor82ac25e2009-01-08 20:45:30 +00001112
Steve Naroff00433d32007-08-21 21:17:12 +00001113 SourceLocation LBraceLoc = ConsumeBrace(); // the "{"
Mike Stump11289f42009-09-09 15:08:12 +00001114
Steve Naroff00433d32007-08-21 21:17:12 +00001115 // While we still have something to read, read the instance variables.
Chris Lattner0ef13522007-10-09 17:51:17 +00001116 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
Steve Naroff00433d32007-08-21 21:17:12 +00001117 // Each iteration of this loop reads one objc-instance-variable-decl.
Mike Stump11289f42009-09-09 15:08:12 +00001118
Steve Naroff00433d32007-08-21 21:17:12 +00001119 // Check for extraneous top-level semicolon.
Chris Lattner0ef13522007-10-09 17:51:17 +00001120 if (Tok.is(tok::semi)) {
Douglas Gregor13d05682010-06-16 23:08:59 +00001121 Diag(Tok, diag::ext_extra_ivar_semi)
Douglas Gregora771f462010-03-31 17:46:05 +00001122 << FixItHint::CreateRemoval(Tok.getLocation());
Steve Naroff00433d32007-08-21 21:17:12 +00001123 ConsumeToken();
1124 continue;
1125 }
Mike Stump11289f42009-09-09 15:08:12 +00001126
Steve Naroff00433d32007-08-21 21:17:12 +00001127 // Set the default visibility to private.
Chris Lattner0ef13522007-10-09 17:51:17 +00001128 if (Tok.is(tok::at)) { // parse objc-visibility-spec
Steve Naroff00433d32007-08-21 21:17:12 +00001129 ConsumeToken(); // eat the @ sign
Douglas Gregor48d46252010-01-13 21:54:15 +00001130
1131 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001132 Actions.CodeCompleteObjCAtVisibility(getCurScope());
Douglas Gregor6da3db42010-05-25 05:58:43 +00001133 ConsumeCodeCompletionToken();
Douglas Gregor48d46252010-01-13 21:54:15 +00001134 }
1135
Steve Naroff7c348172007-08-23 18:16:40 +00001136 switch (Tok.getObjCKeywordID()) {
Steve Naroff00433d32007-08-21 21:17:12 +00001137 case tok::objc_private:
1138 case tok::objc_public:
1139 case tok::objc_protected:
1140 case tok::objc_package:
Steve Naroff7c348172007-08-23 18:16:40 +00001141 visibility = Tok.getObjCKeywordID();
Steve Naroff00433d32007-08-21 21:17:12 +00001142 ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00001143 continue;
Steve Naroff00433d32007-08-21 21:17:12 +00001144 default:
1145 Diag(Tok, diag::err_objc_illegal_visibility_spec);
Steve Naroff00433d32007-08-21 21:17:12 +00001146 continue;
1147 }
1148 }
Mike Stump11289f42009-09-09 15:08:12 +00001149
Douglas Gregor48d46252010-01-13 21:54:15 +00001150 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001151 Actions.CodeCompleteOrdinaryName(getCurScope(),
John McCallfaf5fb42010-08-26 23:41:50 +00001152 Sema::PCC_ObjCInstanceVariableList);
Douglas Gregor6da3db42010-05-25 05:58:43 +00001153 ConsumeCodeCompletionToken();
Douglas Gregor48d46252010-01-13 21:54:15 +00001154 }
1155
John McCallcfefb6d2009-11-03 02:38:08 +00001156 struct ObjCIvarCallback : FieldCallback {
1157 Parser &P;
John McCall48871652010-08-21 09:40:31 +00001158 Decl *IDecl;
John McCallcfefb6d2009-11-03 02:38:08 +00001159 tok::ObjCKeywordKind visibility;
John McCall48871652010-08-21 09:40:31 +00001160 llvm::SmallVectorImpl<Decl *> &AllIvarDecls;
John McCallcfefb6d2009-11-03 02:38:08 +00001161
John McCall48871652010-08-21 09:40:31 +00001162 ObjCIvarCallback(Parser &P, Decl *IDecl, tok::ObjCKeywordKind V,
1163 llvm::SmallVectorImpl<Decl *> &AllIvarDecls) :
John McCallcfefb6d2009-11-03 02:38:08 +00001164 P(P), IDecl(IDecl), visibility(V), AllIvarDecls(AllIvarDecls) {
1165 }
1166
John McCall48871652010-08-21 09:40:31 +00001167 Decl *invoke(FieldDeclarator &FD) {
John McCallcfefb6d2009-11-03 02:38:08 +00001168 // Install the declarator into the interface decl.
John McCall48871652010-08-21 09:40:31 +00001169 Decl *Field
Douglas Gregor0be31a22010-07-02 17:43:08 +00001170 = P.Actions.ActOnIvar(P.getCurScope(),
John McCallcfefb6d2009-11-03 02:38:08 +00001171 FD.D.getDeclSpec().getSourceRange().getBegin(),
1172 IDecl, FD.D, FD.BitfieldSize, visibility);
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +00001173 if (Field)
1174 AllIvarDecls.push_back(Field);
John McCallcfefb6d2009-11-03 02:38:08 +00001175 return Field;
1176 }
1177 } Callback(*this, interfaceDecl, visibility, AllIvarDecls);
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00001178
Chris Lattnera12405b2008-04-10 06:46:29 +00001179 // Parse all the comma separated declarators.
John McCall084e83d2011-03-24 11:26:52 +00001180 DeclSpec DS(AttrFactory);
John McCallcfefb6d2009-11-03 02:38:08 +00001181 ParseStructDeclaration(DS, Callback);
Mike Stump11289f42009-09-09 15:08:12 +00001182
Chris Lattner0ef13522007-10-09 17:51:17 +00001183 if (Tok.is(tok::semi)) {
Steve Naroff00433d32007-08-21 21:17:12 +00001184 ConsumeToken();
Steve Naroff00433d32007-08-21 21:17:12 +00001185 } else {
1186 Diag(Tok, diag::err_expected_semi_decl_list);
1187 // Skip to end of block or statement
1188 SkipUntil(tok::r_brace, true, true);
1189 }
1190 }
Steve Naroff33a1e802007-10-29 21:38:07 +00001191 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc);
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00001192 Actions.ActOnLastBitfield(RBraceLoc, interfaceDecl, AllIvarDecls);
Steve Naroff9c4fddd2007-10-31 22:11:35 +00001193 // Call ActOnFields() even if we don't have any decls. This is useful
1194 // for code rewriting tools that need to be aware of the empty list.
Douglas Gregor0be31a22010-07-02 17:43:08 +00001195 Actions.ActOnFields(getCurScope(), atLoc, interfaceDecl,
Jay Foad7d0479f2009-05-21 09:52:38 +00001196 AllIvarDecls.data(), AllIvarDecls.size(),
Daniel Dunbar15619c72008-10-03 02:03:53 +00001197 LBraceLoc, RBraceLoc, 0);
Steve Naroff00433d32007-08-21 21:17:12 +00001198 return;
Chris Lattnerda59c2f2006-11-05 02:08:13 +00001199}
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001200
1201/// objc-protocol-declaration:
1202/// objc-protocol-definition
1203/// objc-protocol-forward-reference
1204///
1205/// objc-protocol-definition:
Mike Stump11289f42009-09-09 15:08:12 +00001206/// @protocol identifier
1207/// objc-protocol-refs[opt]
1208/// objc-interface-decl-list
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001209/// @end
1210///
1211/// objc-protocol-forward-reference:
1212/// @protocol identifier-list ';'
1213///
1214/// "@protocol identifier ;" should be resolved as "@protocol
Steve Naroff09bf8152007-09-06 21:24:23 +00001215/// identifier-list ;": objc-interface-decl-list may not start with a
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001216/// semicolon in the first alternative if objc-protocol-refs are omitted.
John McCall48871652010-08-21 09:40:31 +00001217Decl *Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc,
John McCall53fa7142010-12-24 02:08:15 +00001218 ParsedAttributes &attrs) {
Steve Naroff7c348172007-08-23 18:16:40 +00001219 assert(Tok.isObjCAtKeyword(tok::objc_protocol) &&
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001220 "ParseObjCAtProtocolDeclaration(): Expected @protocol");
1221 ConsumeToken(); // the "protocol" identifier
Mike Stump11289f42009-09-09 15:08:12 +00001222
Douglas Gregor5b4671c2009-11-18 04:49:41 +00001223 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001224 Actions.CodeCompleteObjCProtocolDecl(getCurScope());
Douglas Gregor6da3db42010-05-25 05:58:43 +00001225 ConsumeCodeCompletionToken();
Douglas Gregor5b4671c2009-11-18 04:49:41 +00001226 }
1227
Chris Lattner0ef13522007-10-09 17:51:17 +00001228 if (Tok.isNot(tok::identifier)) {
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001229 Diag(Tok, diag::err_expected_ident); // missing protocol name.
John McCall48871652010-08-21 09:40:31 +00001230 return 0;
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001231 }
1232 // Save the protocol name, then consume it.
1233 IdentifierInfo *protocolName = Tok.getIdentifierInfo();
1234 SourceLocation nameLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00001235
Chris Lattner0ef13522007-10-09 17:51:17 +00001236 if (Tok.is(tok::semi)) { // forward declaration of one protocol.
Chris Lattnerd7352d62008-07-21 22:17:28 +00001237 IdentifierLocPair ProtoInfo(protocolName, nameLoc);
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001238 ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00001239 return Actions.ActOnForwardProtocolDeclaration(AtLoc, &ProtoInfo, 1,
John McCall53fa7142010-12-24 02:08:15 +00001240 attrs.getList());
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001241 }
Mike Stump11289f42009-09-09 15:08:12 +00001242
Chris Lattner0ef13522007-10-09 17:51:17 +00001243 if (Tok.is(tok::comma)) { // list of forward declarations.
Chris Lattnerd7352d62008-07-21 22:17:28 +00001244 llvm::SmallVector<IdentifierLocPair, 8> ProtocolRefs;
1245 ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc));
1246
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001247 // Parse the list of forward declarations.
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001248 while (1) {
1249 ConsumeToken(); // the ','
Chris Lattner0ef13522007-10-09 17:51:17 +00001250 if (Tok.isNot(tok::identifier)) {
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001251 Diag(Tok, diag::err_expected_ident);
1252 SkipUntil(tok::semi);
John McCall48871652010-08-21 09:40:31 +00001253 return 0;
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001254 }
Chris Lattnerd7352d62008-07-21 22:17:28 +00001255 ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(),
1256 Tok.getLocation()));
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001257 ConsumeToken(); // the identifier
Mike Stump11289f42009-09-09 15:08:12 +00001258
Chris Lattner0ef13522007-10-09 17:51:17 +00001259 if (Tok.isNot(tok::comma))
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001260 break;
1261 }
1262 // Consume the ';'.
1263 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@protocol"))
John McCall48871652010-08-21 09:40:31 +00001264 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00001265
Steve Naroff93eb5f12007-10-10 17:32:04 +00001266 return Actions.ActOnForwardProtocolDeclaration(AtLoc,
Mike Stump11289f42009-09-09 15:08:12 +00001267 &ProtocolRefs[0],
Fariborz Jahanian1470e932008-12-17 01:07:27 +00001268 ProtocolRefs.size(),
John McCall53fa7142010-12-24 02:08:15 +00001269 attrs.getList());
Chris Lattnerd7352d62008-07-21 22:17:28 +00001270 }
Mike Stump11289f42009-09-09 15:08:12 +00001271
Steve Naroff0b6a01a2007-08-22 22:17:26 +00001272 // Last, and definitely not least, parse a protocol declaration.
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001273 SourceLocation LAngleLoc, EndProtoLoc;
Chris Lattnerd7352d62008-07-21 22:17:28 +00001274
John McCall48871652010-08-21 09:40:31 +00001275 llvm::SmallVector<Decl *, 8> ProtocolRefs;
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001276 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
Chris Lattnerd7352d62008-07-21 22:17:28 +00001277 if (Tok.is(tok::less) &&
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001278 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, false,
1279 LAngleLoc, EndProtoLoc))
John McCall48871652010-08-21 09:40:31 +00001280 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00001281
John McCall48871652010-08-21 09:40:31 +00001282 Decl *ProtoType =
Chris Lattner3bbae002008-07-26 04:03:38 +00001283 Actions.ActOnStartProtocolInterface(AtLoc, protocolName, nameLoc,
Jay Foad7d0479f2009-05-21 09:52:38 +00001284 ProtocolRefs.data(),
1285 ProtocolRefs.size(),
Douglas Gregor002b6712010-01-16 15:02:53 +00001286 ProtocolLocs.data(),
John McCall53fa7142010-12-24 02:08:15 +00001287 EndProtoLoc, attrs.getList());
Fariborz Jahanian39d641f2007-09-17 21:07:36 +00001288 ParseObjCInterfaceDeclList(ProtoType, tok::objc_protocol);
Chris Lattnerda9fb152008-10-20 06:10:06 +00001289 return ProtoType;
Chris Lattnerda59c2f2006-11-05 02:08:13 +00001290}
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001291
1292/// objc-implementation:
1293/// objc-class-implementation-prologue
1294/// objc-category-implementation-prologue
1295///
1296/// objc-class-implementation-prologue:
1297/// @implementation identifier objc-superclass[opt]
1298/// objc-class-instance-variables[opt]
1299///
1300/// objc-category-implementation-prologue:
1301/// @implementation identifier ( identifier )
John McCall48871652010-08-21 09:40:31 +00001302Decl *Parser::ParseObjCAtImplementationDeclaration(
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001303 SourceLocation atLoc) {
1304 assert(Tok.isObjCAtKeyword(tok::objc_implementation) &&
1305 "ParseObjCAtImplementationDeclaration(): Expected @implementation");
1306 ConsumeToken(); // the "implementation" identifier
Mike Stump11289f42009-09-09 15:08:12 +00001307
Douglas Gregor49c22a72009-11-18 16:26:39 +00001308 // Code completion after '@implementation'.
1309 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001310 Actions.CodeCompleteObjCImplementationDecl(getCurScope());
Douglas Gregor6da3db42010-05-25 05:58:43 +00001311 ConsumeCodeCompletionToken();
Douglas Gregor49c22a72009-11-18 16:26:39 +00001312 }
1313
Chris Lattner0ef13522007-10-09 17:51:17 +00001314 if (Tok.isNot(tok::identifier)) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001315 Diag(Tok, diag::err_expected_ident); // missing class or category name.
John McCall48871652010-08-21 09:40:31 +00001316 return 0;
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001317 }
1318 // We have a class or category name - consume it.
Fariborz Jahanianbfe13c52007-09-25 18:38:09 +00001319 IdentifierInfo *nameId = Tok.getIdentifierInfo();
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001320 SourceLocation nameLoc = ConsumeToken(); // consume class or category name
Mike Stump11289f42009-09-09 15:08:12 +00001321
1322 if (Tok.is(tok::l_paren)) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001323 // we have a category implementation.
Jeffrey Yasskin8dfa5f12011-01-18 02:00:16 +00001324 ConsumeParen();
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001325 SourceLocation categoryLoc, rparenLoc;
1326 IdentifierInfo *categoryId = 0;
Mike Stump11289f42009-09-09 15:08:12 +00001327
Douglas Gregor5d34fd32009-11-18 19:08:43 +00001328 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001329 Actions.CodeCompleteObjCImplementationCategory(getCurScope(), nameId, nameLoc);
Douglas Gregor6da3db42010-05-25 05:58:43 +00001330 ConsumeCodeCompletionToken();
Douglas Gregor5d34fd32009-11-18 19:08:43 +00001331 }
1332
Chris Lattner0ef13522007-10-09 17:51:17 +00001333 if (Tok.is(tok::identifier)) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001334 categoryId = Tok.getIdentifierInfo();
1335 categoryLoc = ConsumeToken();
1336 } else {
1337 Diag(Tok, diag::err_expected_ident); // missing category name.
John McCall48871652010-08-21 09:40:31 +00001338 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00001339 }
Chris Lattner0ef13522007-10-09 17:51:17 +00001340 if (Tok.isNot(tok::r_paren)) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001341 Diag(Tok, diag::err_expected_rparen);
1342 SkipUntil(tok::r_paren, false); // don't stop at ';'
John McCall48871652010-08-21 09:40:31 +00001343 return 0;
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001344 }
1345 rparenLoc = ConsumeParen();
John McCall48871652010-08-21 09:40:31 +00001346 Decl *ImplCatType = Actions.ActOnStartCategoryImplementation(
Mike Stump11289f42009-09-09 15:08:12 +00001347 atLoc, nameId, nameLoc, categoryId,
Fariborz Jahanian89b8ef92007-10-02 16:38:50 +00001348 categoryLoc);
Ted Kremenek1b0ea822008-01-07 19:49:32 +00001349 ObjCImpDecl = ImplCatType;
Fariborz Jahanian9290ede2009-11-16 18:57:01 +00001350 PendingObjCImpDecl.push_back(ObjCImpDecl);
John McCall48871652010-08-21 09:40:31 +00001351 return 0;
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001352 }
1353 // We have a class implementation
Fariborz Jahanianbfe13c52007-09-25 18:38:09 +00001354 SourceLocation superClassLoc;
1355 IdentifierInfo *superClassId = 0;
Chris Lattner0ef13522007-10-09 17:51:17 +00001356 if (Tok.is(tok::colon)) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001357 // We have a super class
1358 ConsumeToken();
Chris Lattner0ef13522007-10-09 17:51:17 +00001359 if (Tok.isNot(tok::identifier)) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001360 Diag(Tok, diag::err_expected_ident); // missing super class name.
John McCall48871652010-08-21 09:40:31 +00001361 return 0;
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001362 }
Fariborz Jahanianbfe13c52007-09-25 18:38:09 +00001363 superClassId = Tok.getIdentifierInfo();
1364 superClassLoc = ConsumeToken(); // Consume super class name
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001365 }
John McCall48871652010-08-21 09:40:31 +00001366 Decl *ImplClsType = Actions.ActOnStartClassImplementation(
Chris Lattner5e530bc2007-12-27 19:57:00 +00001367 atLoc, nameId, nameLoc,
Fariborz Jahanianbfe13c52007-09-25 18:38:09 +00001368 superClassId, superClassLoc);
Mike Stump11289f42009-09-09 15:08:12 +00001369
Steve Naroff33a1e802007-10-29 21:38:07 +00001370 if (Tok.is(tok::l_brace)) // we have ivars
Fariborz Jahanian4c172c62010-02-22 23:04:20 +00001371 ParseObjCClassInstanceVariables(ImplClsType/*FIXME*/,
Fariborz Jahaniana9effb52010-03-22 19:04:14 +00001372 tok::objc_private, atLoc);
Ted Kremenek1b0ea822008-01-07 19:49:32 +00001373 ObjCImpDecl = ImplClsType;
Fariborz Jahanian9290ede2009-11-16 18:57:01 +00001374 PendingObjCImpDecl.push_back(ObjCImpDecl);
1375
John McCall48871652010-08-21 09:40:31 +00001376 return 0;
Chris Lattnerda59c2f2006-11-05 02:08:13 +00001377}
Steve Naroff33a1e802007-10-29 21:38:07 +00001378
John McCall48871652010-08-21 09:40:31 +00001379Decl *Parser::ParseObjCAtEndDeclaration(SourceRange atEnd) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001380 assert(Tok.isObjCAtKeyword(tok::objc_end) &&
1381 "ParseObjCAtEndDeclaration(): Expected @end");
John McCall48871652010-08-21 09:40:31 +00001382 Decl *Result = ObjCImpDecl;
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001383 ConsumeToken(); // the "end" identifier
Fariborz Jahanianb8d091c2009-03-04 22:30:12 +00001384 if (ObjCImpDecl) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001385 Actions.ActOnAtEnd(getCurScope(), atEnd, ObjCImpDecl);
John McCall48871652010-08-21 09:40:31 +00001386 ObjCImpDecl = 0;
Fariborz Jahanian9290ede2009-11-16 18:57:01 +00001387 PendingObjCImpDecl.pop_back();
Fariborz Jahanianb8d091c2009-03-04 22:30:12 +00001388 }
Ted Kremenekc7c64312010-01-07 01:20:12 +00001389 else {
1390 // missing @implementation
1391 Diag(atEnd.getBegin(), diag::warn_expected_implementation);
1392 }
Fariborz Jahanianb8d091c2009-03-04 22:30:12 +00001393 return Result;
Steve Naroff1eb1ad62007-08-20 21:31:48 +00001394}
Fariborz Jahaniand8e12d32007-09-04 19:26:51 +00001395
Fariborz Jahanian6e7e8cc2010-07-22 18:24:20 +00001396Parser::DeclGroupPtrTy Parser::FinishPendingObjCActions() {
1397 Actions.DiagnoseUseOfUnimplementedSelectors();
Fariborz Jahanian9290ede2009-11-16 18:57:01 +00001398 if (PendingObjCImpDecl.empty())
John McCall48871652010-08-21 09:40:31 +00001399 return Actions.ConvertDeclToDeclGroup(0);
1400 Decl *ImpDecl = PendingObjCImpDecl.pop_back_val();
Douglas Gregor0be31a22010-07-02 17:43:08 +00001401 Actions.ActOnAtEnd(getCurScope(), SourceRange(), ImpDecl);
Fariborz Jahanian9290ede2009-11-16 18:57:01 +00001402 return Actions.ConvertDeclToDeclGroup(ImpDecl);
1403}
1404
Fariborz Jahaniand8e12d32007-09-04 19:26:51 +00001405/// compatibility-alias-decl:
1406/// @compatibility_alias alias-name class-name ';'
1407///
John McCall48871652010-08-21 09:40:31 +00001408Decl *Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc) {
Fariborz Jahaniand8e12d32007-09-04 19:26:51 +00001409 assert(Tok.isObjCAtKeyword(tok::objc_compatibility_alias) &&
1410 "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias");
1411 ConsumeToken(); // consume compatibility_alias
Chris Lattner0ef13522007-10-09 17:51:17 +00001412 if (Tok.isNot(tok::identifier)) {
Fariborz Jahaniand8e12d32007-09-04 19:26:51 +00001413 Diag(Tok, diag::err_expected_ident);
John McCall48871652010-08-21 09:40:31 +00001414 return 0;
Fariborz Jahaniand8e12d32007-09-04 19:26:51 +00001415 }
Fariborz Jahanian49c64252007-10-11 23:42:27 +00001416 IdentifierInfo *aliasId = Tok.getIdentifierInfo();
1417 SourceLocation aliasLoc = ConsumeToken(); // consume alias-name
Chris Lattner0ef13522007-10-09 17:51:17 +00001418 if (Tok.isNot(tok::identifier)) {
Fariborz Jahaniand8e12d32007-09-04 19:26:51 +00001419 Diag(Tok, diag::err_expected_ident);
John McCall48871652010-08-21 09:40:31 +00001420 return 0;
Fariborz Jahaniand8e12d32007-09-04 19:26:51 +00001421 }
Fariborz Jahanian49c64252007-10-11 23:42:27 +00001422 IdentifierInfo *classId = Tok.getIdentifierInfo();
1423 SourceLocation classLoc = ConsumeToken(); // consume class-name;
Douglas Gregor78edf992011-01-05 01:10:06 +00001424 ExpectAndConsume(tok::semi, diag::err_expected_semi_after,
1425 "@compatibility_alias");
Chris Lattner83f095c2009-03-28 19:18:32 +00001426 return Actions.ActOnCompatiblityAlias(atLoc, aliasId, aliasLoc,
1427 classId, classLoc);
Chris Lattnerda59c2f2006-11-05 02:08:13 +00001428}
1429
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001430/// property-synthesis:
1431/// @synthesize property-ivar-list ';'
1432///
1433/// property-ivar-list:
1434/// property-ivar
1435/// property-ivar-list ',' property-ivar
1436///
1437/// property-ivar:
1438/// identifier
1439/// identifier '=' identifier
1440///
John McCall48871652010-08-21 09:40:31 +00001441Decl *Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001442 assert(Tok.isObjCAtKeyword(tok::objc_synthesize) &&
1443 "ParseObjCPropertyDynamic(): Expected '@synthesize'");
Jeffrey Yasskin8dfa5f12011-01-18 02:00:16 +00001444 ConsumeToken(); // consume synthesize
Mike Stump11289f42009-09-09 15:08:12 +00001445
Douglas Gregor88e72a02009-11-18 19:45:45 +00001446 while (true) {
Douglas Gregor5d649882009-11-18 22:32:06 +00001447 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001448 Actions.CodeCompleteObjCPropertyDefinition(getCurScope(), ObjCImpDecl);
Douglas Gregor6da3db42010-05-25 05:58:43 +00001449 ConsumeCodeCompletionToken();
Douglas Gregor5d649882009-11-18 22:32:06 +00001450 }
1451
Douglas Gregor88e72a02009-11-18 19:45:45 +00001452 if (Tok.isNot(tok::identifier)) {
1453 Diag(Tok, diag::err_synthesized_property_name);
1454 SkipUntil(tok::semi);
John McCall48871652010-08-21 09:40:31 +00001455 return 0;
Douglas Gregor88e72a02009-11-18 19:45:45 +00001456 }
1457
Fariborz Jahanianffe97a32008-04-18 00:19:30 +00001458 IdentifierInfo *propertyIvar = 0;
1459 IdentifierInfo *propertyId = Tok.getIdentifierInfo();
1460 SourceLocation propertyLoc = ConsumeToken(); // consume property name
Douglas Gregorb1b71e52010-11-17 01:03:52 +00001461 SourceLocation propertyIvarLoc;
Chris Lattner0ef13522007-10-09 17:51:17 +00001462 if (Tok.is(tok::equal)) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001463 // property '=' ivar-name
1464 ConsumeToken(); // consume '='
Douglas Gregor5d649882009-11-18 22:32:06 +00001465
1466 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001467 Actions.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId,
Douglas Gregor5d649882009-11-18 22:32:06 +00001468 ObjCImpDecl);
Douglas Gregor6da3db42010-05-25 05:58:43 +00001469 ConsumeCodeCompletionToken();
Douglas Gregor5d649882009-11-18 22:32:06 +00001470 }
1471
Chris Lattner0ef13522007-10-09 17:51:17 +00001472 if (Tok.isNot(tok::identifier)) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001473 Diag(Tok, diag::err_expected_ident);
1474 break;
1475 }
Fariborz Jahanianffe97a32008-04-18 00:19:30 +00001476 propertyIvar = Tok.getIdentifierInfo();
Douglas Gregorb1b71e52010-11-17 01:03:52 +00001477 propertyIvarLoc = ConsumeToken(); // consume ivar-name
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001478 }
Douglas Gregor0be31a22010-07-02 17:43:08 +00001479 Actions.ActOnPropertyImplDecl(getCurScope(), atLoc, propertyLoc, true, ObjCImpDecl,
Douglas Gregorb1b71e52010-11-17 01:03:52 +00001480 propertyId, propertyIvar, propertyIvarLoc);
Chris Lattner0ef13522007-10-09 17:51:17 +00001481 if (Tok.isNot(tok::comma))
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001482 break;
1483 ConsumeToken(); // consume ','
1484 }
Douglas Gregor78edf992011-01-05 01:10:06 +00001485 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@synthesize");
John McCall48871652010-08-21 09:40:31 +00001486 return 0;
Chris Lattnerda59c2f2006-11-05 02:08:13 +00001487}
1488
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001489/// property-dynamic:
1490/// @dynamic property-list
1491///
1492/// property-list:
1493/// identifier
1494/// property-list ',' identifier
1495///
John McCall48871652010-08-21 09:40:31 +00001496Decl *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) {
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001497 assert(Tok.isObjCAtKeyword(tok::objc_dynamic) &&
1498 "ParseObjCPropertyDynamic(): Expected '@dynamic'");
Jeffrey Yasskin8dfa5f12011-01-18 02:00:16 +00001499 ConsumeToken(); // consume dynamic
Douglas Gregor52e78bd2009-11-18 22:56:13 +00001500 while (true) {
1501 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001502 Actions.CodeCompleteObjCPropertyDefinition(getCurScope(), ObjCImpDecl);
Douglas Gregor6da3db42010-05-25 05:58:43 +00001503 ConsumeCodeCompletionToken();
Douglas Gregor52e78bd2009-11-18 22:56:13 +00001504 }
1505
1506 if (Tok.isNot(tok::identifier)) {
1507 Diag(Tok, diag::err_expected_ident);
1508 SkipUntil(tok::semi);
John McCall48871652010-08-21 09:40:31 +00001509 return 0;
Douglas Gregor52e78bd2009-11-18 22:56:13 +00001510 }
1511
Fariborz Jahanianf2a7d7c2008-04-21 21:05:54 +00001512 IdentifierInfo *propertyId = Tok.getIdentifierInfo();
1513 SourceLocation propertyLoc = ConsumeToken(); // consume property name
Douglas Gregor0be31a22010-07-02 17:43:08 +00001514 Actions.ActOnPropertyImplDecl(getCurScope(), atLoc, propertyLoc, false, ObjCImpDecl,
Douglas Gregorb1b71e52010-11-17 01:03:52 +00001515 propertyId, 0, SourceLocation());
Fariborz Jahanianf2a7d7c2008-04-21 21:05:54 +00001516
Chris Lattner0ef13522007-10-09 17:51:17 +00001517 if (Tok.isNot(tok::comma))
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001518 break;
1519 ConsumeToken(); // consume ','
1520 }
Douglas Gregor78edf992011-01-05 01:10:06 +00001521 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@dynamic");
John McCall48871652010-08-21 09:40:31 +00001522 return 0;
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001523}
Mike Stump11289f42009-09-09 15:08:12 +00001524
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001525/// objc-throw-statement:
1526/// throw expression[opt];
1527///
John McCalldadc5752010-08-24 06:29:42 +00001528StmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) {
1529 ExprResult Res;
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001530 ConsumeToken(); // consume throw
Chris Lattner0ef13522007-10-09 17:51:17 +00001531 if (Tok.isNot(tok::semi)) {
Fariborz Jahanianadfbbc32007-11-07 02:00:49 +00001532 Res = ParseExpression();
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001533 if (Res.isInvalid()) {
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001534 SkipUntil(tok::semi);
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001535 return StmtError();
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001536 }
1537 }
Ted Kremenek15a81e52010-04-20 21:21:51 +00001538 // consume ';'
1539 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@throw");
John McCallb268a282010-08-23 23:25:46 +00001540 return Actions.ActOnObjCAtThrowStmt(atLoc, Res.take(), getCurScope());
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001541}
1542
Fariborz Jahanianf89ca382008-01-29 18:21:32 +00001543/// objc-synchronized-statement:
Fariborz Jahanian049fa582008-01-30 17:38:29 +00001544/// @synchronized '(' expression ')' compound-statement
Fariborz Jahanianf89ca382008-01-29 18:21:32 +00001545///
John McCalldadc5752010-08-24 06:29:42 +00001546StmtResult
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001547Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) {
Fariborz Jahanian48085b82008-01-29 19:14:59 +00001548 ConsumeToken(); // consume synchronized
1549 if (Tok.isNot(tok::l_paren)) {
Chris Lattner6d29c102008-11-18 07:48:38 +00001550 Diag(Tok, diag::err_expected_lparen_after) << "@synchronized";
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001551 return StmtError();
Fariborz Jahanian48085b82008-01-29 19:14:59 +00001552 }
1553 ConsumeParen(); // '('
John McCalldadc5752010-08-24 06:29:42 +00001554 ExprResult Res(ParseExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001555 if (Res.isInvalid()) {
Fariborz Jahanian48085b82008-01-29 19:14:59 +00001556 SkipUntil(tok::semi);
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001557 return StmtError();
Fariborz Jahanian48085b82008-01-29 19:14:59 +00001558 }
1559 if (Tok.isNot(tok::r_paren)) {
Chris Lattner6d29c102008-11-18 07:48:38 +00001560 Diag(Tok, diag::err_expected_lbrace);
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001561 return StmtError();
Fariborz Jahanian48085b82008-01-29 19:14:59 +00001562 }
1563 ConsumeParen(); // ')'
Fariborz Jahanian049fa582008-01-30 17:38:29 +00001564 if (Tok.isNot(tok::l_brace)) {
Chris Lattner6d29c102008-11-18 07:48:38 +00001565 Diag(Tok, diag::err_expected_lbrace);
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001566 return StmtError();
Fariborz Jahanian049fa582008-01-30 17:38:29 +00001567 }
Steve Naroffd9c26072008-06-04 20:36:13 +00001568 // Enter a scope to hold everything within the compound stmt. Compound
1569 // statements can always hold declarations.
Douglas Gregor7307d6c2008-12-10 06:34:36 +00001570 ParseScope BodyScope(this, Scope::DeclScope);
Steve Naroffd9c26072008-06-04 20:36:13 +00001571
John McCalldadc5752010-08-24 06:29:42 +00001572 StmtResult SynchBody(ParseCompoundStatementBody());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001573
Douglas Gregor7307d6c2008-12-10 06:34:36 +00001574 BodyScope.Exit();
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001575 if (SynchBody.isInvalid())
Fariborz Jahanian48085b82008-01-29 19:14:59 +00001576 SynchBody = Actions.ActOnNullStmt(Tok.getLocation());
John McCallb268a282010-08-23 23:25:46 +00001577 return Actions.ActOnObjCAtSynchronizedStmt(atLoc, Res.take(), SynchBody.take());
Fariborz Jahanianf89ca382008-01-29 18:21:32 +00001578}
1579
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001580/// objc-try-catch-statement:
1581/// @try compound-statement objc-catch-list[opt]
1582/// @try compound-statement objc-catch-list[opt] @finally compound-statement
1583///
1584/// objc-catch-list:
1585/// @catch ( parameter-declaration ) compound-statement
1586/// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement
1587/// catch-parameter-declaration:
1588/// parameter-declaration
1589/// '...' [OBJC2]
1590///
John McCalldadc5752010-08-24 06:29:42 +00001591StmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) {
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001592 bool catch_or_finally_seen = false;
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001593
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001594 ConsumeToken(); // consume try
Chris Lattner0ef13522007-10-09 17:51:17 +00001595 if (Tok.isNot(tok::l_brace)) {
Chris Lattner6d29c102008-11-18 07:48:38 +00001596 Diag(Tok, diag::err_expected_lbrace);
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001597 return StmtError();
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001598 }
Douglas Gregor96c79492010-04-23 22:50:49 +00001599 StmtVector CatchStmts(Actions);
John McCalldadc5752010-08-24 06:29:42 +00001600 StmtResult FinallyStmt;
Douglas Gregor7307d6c2008-12-10 06:34:36 +00001601 ParseScope TryScope(this, Scope::DeclScope);
John McCalldadc5752010-08-24 06:29:42 +00001602 StmtResult TryBody(ParseCompoundStatementBody());
Douglas Gregor7307d6c2008-12-10 06:34:36 +00001603 TryScope.Exit();
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001604 if (TryBody.isInvalid())
Fariborz Jahanianf859ef22007-11-02 15:39:31 +00001605 TryBody = Actions.ActOnNullStmt(Tok.getLocation());
Sebastian Redl511ed552008-11-25 22:21:31 +00001606
Chris Lattner0ef13522007-10-09 17:51:17 +00001607 while (Tok.is(tok::at)) {
Chris Lattner3e468322008-03-10 06:06:04 +00001608 // At this point, we need to lookahead to determine if this @ is the start
1609 // of an @catch or @finally. We don't want to consume the @ token if this
1610 // is an @try or @encode or something else.
1611 Token AfterAt = GetLookAheadToken(1);
1612 if (!AfterAt.isObjCAtKeyword(tok::objc_catch) &&
1613 !AfterAt.isObjCAtKeyword(tok::objc_finally))
1614 break;
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001615
Fariborz Jahanian71234d82007-11-02 00:18:53 +00001616 SourceLocation AtCatchFinallyLoc = ConsumeToken();
Chris Lattner5e530bc2007-12-27 19:57:00 +00001617 if (Tok.isObjCAtKeyword(tok::objc_catch)) {
John McCall48871652010-08-21 09:40:31 +00001618 Decl *FirstPart = 0;
Fariborz Jahanian9e63b982007-11-01 23:59:59 +00001619 ConsumeToken(); // consume catch
Chris Lattner0ef13522007-10-09 17:51:17 +00001620 if (Tok.is(tok::l_paren)) {
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001621 ConsumeParen();
Steve Naroff5ee2c022009-02-11 20:05:44 +00001622 ParseScope CatchScope(this, Scope::DeclScope|Scope::AtCatchScope);
Chris Lattner0ef13522007-10-09 17:51:17 +00001623 if (Tok.isNot(tok::ellipsis)) {
John McCall084e83d2011-03-24 11:26:52 +00001624 DeclSpec DS(AttrFactory);
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001625 ParseDeclarationSpecifiers(DS);
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001626 // For some odd reason, the name of the exception variable is
Mike Stump11289f42009-09-09 15:08:12 +00001627 // optional. As a result, we need to use "PrototypeContext", because
Steve Naroff371b8fb2009-03-03 19:52:17 +00001628 // we must accept either 'declarator' or 'abstract-declarator' here.
1629 Declarator ParmDecl(DS, Declarator::PrototypeContext);
1630 ParseDeclarator(ParmDecl);
1631
Douglas Gregore11ee112010-04-23 23:01:43 +00001632 // Inform the actions module about the declarator, so it
Steve Naroff371b8fb2009-03-03 19:52:17 +00001633 // gets added to the current scope.
Douglas Gregor0be31a22010-07-02 17:43:08 +00001634 FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl);
Steve Naroffe6016792008-02-05 21:27:35 +00001635 } else
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001636 ConsumeToken(); // consume '...'
Mike Stump11289f42009-09-09 15:08:12 +00001637
Steve Naroff65a00892009-04-07 22:56:58 +00001638 SourceLocation RParenLoc;
Mike Stump11289f42009-09-09 15:08:12 +00001639
Steve Naroff65a00892009-04-07 22:56:58 +00001640 if (Tok.is(tok::r_paren))
1641 RParenLoc = ConsumeParen();
1642 else // Skip over garbage, until we get to ')'. Eat the ')'.
1643 SkipUntil(tok::r_paren, true, false);
1644
John McCalldadc5752010-08-24 06:29:42 +00001645 StmtResult CatchBody(true);
Chris Lattner99a59b62008-02-14 19:27:54 +00001646 if (Tok.is(tok::l_brace))
1647 CatchBody = ParseCompoundStatementBody();
1648 else
1649 Diag(Tok, diag::err_expected_lbrace);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001650 if (CatchBody.isInvalid())
Fariborz Jahanian9e63b982007-11-01 23:59:59 +00001651 CatchBody = Actions.ActOnNullStmt(Tok.getLocation());
Douglas Gregor96c79492010-04-23 22:50:49 +00001652
John McCalldadc5752010-08-24 06:29:42 +00001653 StmtResult Catch = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc,
Douglas Gregor96c79492010-04-23 22:50:49 +00001654 RParenLoc,
1655 FirstPart,
John McCallb268a282010-08-23 23:25:46 +00001656 CatchBody.take());
Douglas Gregor96c79492010-04-23 22:50:49 +00001657 if (!Catch.isInvalid())
1658 CatchStmts.push_back(Catch.release());
1659
Steve Naroffe6016792008-02-05 21:27:35 +00001660 } else {
Chris Lattner6d29c102008-11-18 07:48:38 +00001661 Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after)
1662 << "@catch clause";
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001663 return StmtError();
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001664 }
1665 catch_or_finally_seen = true;
Chris Lattner3e468322008-03-10 06:06:04 +00001666 } else {
1667 assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?");
Steve Naroffe6016792008-02-05 21:27:35 +00001668 ConsumeToken(); // consume finally
Douglas Gregor7307d6c2008-12-10 06:34:36 +00001669 ParseScope FinallyScope(this, Scope::DeclScope);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001670
John McCalldadc5752010-08-24 06:29:42 +00001671 StmtResult FinallyBody(true);
Chris Lattner99a59b62008-02-14 19:27:54 +00001672 if (Tok.is(tok::l_brace))
1673 FinallyBody = ParseCompoundStatementBody();
1674 else
1675 Diag(Tok, diag::err_expected_lbrace);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001676 if (FinallyBody.isInvalid())
Fariborz Jahanian71234d82007-11-02 00:18:53 +00001677 FinallyBody = Actions.ActOnNullStmt(Tok.getLocation());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001678 FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc,
John McCallb268a282010-08-23 23:25:46 +00001679 FinallyBody.take());
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001680 catch_or_finally_seen = true;
1681 break;
1682 }
1683 }
Fariborz Jahanianf859ef22007-11-02 15:39:31 +00001684 if (!catch_or_finally_seen) {
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001685 Diag(atLoc, diag::err_missing_catch_finally);
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001686 return StmtError();
Fariborz Jahanianf859ef22007-11-02 15:39:31 +00001687 }
Douglas Gregor96c79492010-04-23 22:50:49 +00001688
John McCallb268a282010-08-23 23:25:46 +00001689 return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.take(),
Douglas Gregor96c79492010-04-23 22:50:49 +00001690 move_arg(CatchStmts),
John McCallb268a282010-08-23 23:25:46 +00001691 FinallyStmt.take());
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +00001692}
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001693
Steve Naroff09bf8152007-09-06 21:24:23 +00001694/// objc-method-def: objc-method-proto ';'[opt] '{' body '}'
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001695///
John McCall48871652010-08-21 09:40:31 +00001696Decl *Parser::ParseObjCMethodDefinition() {
1697 Decl *MDecl = ParseObjCMethodPrototype(ObjCImpDecl);
Mike Stump11289f42009-09-09 15:08:12 +00001698
John McCallfaf5fb42010-08-26 23:41:50 +00001699 PrettyDeclStackTraceEntry CrashInfo(Actions, MDecl, Tok.getLocation(),
1700 "parsing Objective-C method");
Mike Stump11289f42009-09-09 15:08:12 +00001701
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001702 // parse optional ';'
Fariborz Jahanian040d75d2009-10-20 16:39:13 +00001703 if (Tok.is(tok::semi)) {
Ted Kremenek0b61a802009-11-10 22:55:49 +00001704 if (ObjCImpDecl) {
1705 Diag(Tok, diag::warn_semicolon_before_method_body)
Douglas Gregora771f462010-03-31 17:46:05 +00001706 << FixItHint::CreateRemoval(Tok.getLocation());
Ted Kremenek0b61a802009-11-10 22:55:49 +00001707 }
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001708 ConsumeToken();
Fariborz Jahanian040d75d2009-10-20 16:39:13 +00001709 }
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001710
Steve Naroffbb875722007-11-11 19:54:21 +00001711 // We should have an opening brace now.
Chris Lattner0ef13522007-10-09 17:51:17 +00001712 if (Tok.isNot(tok::l_brace)) {
Steve Naroff83777fe2008-02-29 21:48:07 +00001713 Diag(Tok, diag::err_expected_method_body);
Mike Stump11289f42009-09-09 15:08:12 +00001714
Steve Naroffbb875722007-11-11 19:54:21 +00001715 // Skip over garbage, until we get to '{'. Don't eat the '{'.
1716 SkipUntil(tok::l_brace, true, true);
Mike Stump11289f42009-09-09 15:08:12 +00001717
Steve Naroffbb875722007-11-11 19:54:21 +00001718 // If we didn't find the '{', bail out.
1719 if (Tok.isNot(tok::l_brace))
John McCall48871652010-08-21 09:40:31 +00001720 return 0;
Fariborz Jahanian53cacae2007-09-01 00:26:16 +00001721 }
Steve Naroffbb875722007-11-11 19:54:21 +00001722 SourceLocation BraceLoc = Tok.getLocation();
Mike Stump11289f42009-09-09 15:08:12 +00001723
Steve Naroffbb875722007-11-11 19:54:21 +00001724 // Enter a scope for the method body.
Chris Lattnerc2ebb032010-04-12 05:38:43 +00001725 ParseScope BodyScope(this,
1726 Scope::ObjCMethodScope|Scope::FnScope|Scope::DeclScope);
Mike Stump11289f42009-09-09 15:08:12 +00001727
Steve Naroffbb875722007-11-11 19:54:21 +00001728 // Tell the actions module that we have entered a method definition with the
Steve Naroff542cd5d2008-07-25 17:57:26 +00001729 // specified Declarator for the method.
Douglas Gregor0be31a22010-07-02 17:43:08 +00001730 Actions.ActOnStartOfObjCMethodDef(getCurScope(), MDecl);
Sebastian Redl042ad952008-12-11 19:30:53 +00001731
Douglas Gregora0ff0c32011-03-16 17:05:57 +00001732 if (PP.isCodeCompletionEnabled()) {
1733 if (trySkippingFunctionBodyForCodeCompletion()) {
1734 BodyScope.Exit();
Argyrios Kyrtzidisbd9dfb22011-01-04 00:27:27 +00001735 return Actions.ActOnFinishFunctionBody(MDecl, 0);
Douglas Gregora0ff0c32011-03-16 17:05:57 +00001736 }
1737 }
Argyrios Kyrtzidisd5756a62011-01-03 22:33:06 +00001738
John McCalldadc5752010-08-24 06:29:42 +00001739 StmtResult FnBody(ParseCompoundStatementBody());
Sebastian Redl042ad952008-12-11 19:30:53 +00001740
Steve Naroffbb875722007-11-11 19:54:21 +00001741 // If the function body could not be parsed, make a bogus compoundstmt.
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001742 if (FnBody.isInvalid())
Sebastian Redl52f03ba2008-12-21 12:04:03 +00001743 FnBody = Actions.ActOnCompoundStmt(BraceLoc, BraceLoc,
1744 MultiStmtArg(Actions), false);
Sebastian Redlc675bab2008-12-13 16:23:55 +00001745
Steve Naroffbb875722007-11-11 19:54:21 +00001746 // Leave the function body scope.
Douglas Gregor7307d6c2008-12-10 06:34:36 +00001747 BodyScope.Exit();
Douglas Gregora0ff0c32011-03-16 17:05:57 +00001748
1749 // TODO: Pass argument information.
1750 Actions.ActOnFinishFunctionBody(MDecl, FnBody.take());
Steve Naroff7b8fa472007-11-13 23:01:27 +00001751 return MDecl;
Chris Lattnerda59c2f2006-11-05 02:08:13 +00001752}
Anders Carlsson76f4a902007-08-21 17:43:55 +00001753
John McCalldadc5752010-08-24 06:29:42 +00001754StmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc) {
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00001755 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001756 Actions.CodeCompleteObjCAtStatement(getCurScope());
Douglas Gregor6da3db42010-05-25 05:58:43 +00001757 ConsumeCodeCompletionToken();
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00001758 return StmtError();
Chris Lattner3ababf52009-12-07 16:33:19 +00001759 }
1760
1761 if (Tok.isObjCAtKeyword(tok::objc_try))
Chris Lattner3e468322008-03-10 06:06:04 +00001762 return ParseObjCTryStmt(AtLoc);
Chris Lattner3ababf52009-12-07 16:33:19 +00001763
1764 if (Tok.isObjCAtKeyword(tok::objc_throw))
Steve Naroffe6016792008-02-05 21:27:35 +00001765 return ParseObjCThrowStmt(AtLoc);
Chris Lattner3ababf52009-12-07 16:33:19 +00001766
1767 if (Tok.isObjCAtKeyword(tok::objc_synchronized))
Steve Naroffe6016792008-02-05 21:27:35 +00001768 return ParseObjCSynchronizedStmt(AtLoc);
Chris Lattner3ababf52009-12-07 16:33:19 +00001769
John McCalldadc5752010-08-24 06:29:42 +00001770 ExprResult Res(ParseExpressionWithLeadingAt(AtLoc));
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001771 if (Res.isInvalid()) {
Steve Naroffe6016792008-02-05 21:27:35 +00001772 // If the expression is invalid, skip ahead to the next semicolon. Not
1773 // doing this opens us up to the possibility of infinite loops if
1774 // ParseExpression does not consume any tokens.
1775 SkipUntil(tok::semi);
Sebastian Redlbab9a4b2008-12-11 20:12:42 +00001776 return StmtError();
Steve Naroffe6016792008-02-05 21:27:35 +00001777 }
Chris Lattner3ababf52009-12-07 16:33:19 +00001778
Steve Naroffe6016792008-02-05 21:27:35 +00001779 // Otherwise, eat the semicolon.
Douglas Gregor45d6bdf2010-09-07 15:23:11 +00001780 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
John McCallb268a282010-08-23 23:25:46 +00001781 return Actions.ActOnExprStmt(Actions.MakeFullExpr(Res.take()));
Steve Naroffe6016792008-02-05 21:27:35 +00001782}
1783
John McCalldadc5752010-08-24 06:29:42 +00001784ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {
Anders Carlsson76f4a902007-08-21 17:43:55 +00001785 switch (Tok.getKind()) {
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00001786 case tok::code_completion:
Douglas Gregor0be31a22010-07-02 17:43:08 +00001787 Actions.CodeCompleteObjCAtExpression(getCurScope());
Douglas Gregor6da3db42010-05-25 05:58:43 +00001788 ConsumeCodeCompletionToken();
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00001789 return ExprError();
1790
Chris Lattnere002fbe2007-12-12 01:04:12 +00001791 case tok::string_literal: // primary-expression: string-literal
1792 case tok::wide_string_literal:
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00001793 return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc));
Chris Lattnere002fbe2007-12-12 01:04:12 +00001794 default:
Chris Lattner197a3012008-08-05 06:19:09 +00001795 if (Tok.getIdentifierInfo() == 0)
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00001796 return ExprError(Diag(AtLoc, diag::err_unexpected_at));
Sebastian Redl59b5e512008-12-11 21:36:32 +00001797
Chris Lattner197a3012008-08-05 06:19:09 +00001798 switch (Tok.getIdentifierInfo()->getObjCKeywordID()) {
1799 case tok::objc_encode:
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00001800 return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc));
Chris Lattner197a3012008-08-05 06:19:09 +00001801 case tok::objc_protocol:
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00001802 return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc));
Chris Lattner197a3012008-08-05 06:19:09 +00001803 case tok::objc_selector:
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00001804 return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc));
Chris Lattner197a3012008-08-05 06:19:09 +00001805 default:
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00001806 return ExprError(Diag(AtLoc, diag::err_unexpected_at));
Chris Lattner197a3012008-08-05 06:19:09 +00001807 }
Anders Carlsson76f4a902007-08-21 17:43:55 +00001808 }
Anders Carlsson76f4a902007-08-21 17:43:55 +00001809}
1810
Douglas Gregor8d4de672010-04-21 22:36:40 +00001811/// \brirg Parse the receiver of an Objective-C++ message send.
1812///
1813/// This routine parses the receiver of a message send in
1814/// Objective-C++ either as a type or as an expression. Note that this
1815/// routine must not be called to parse a send to 'super', since it
1816/// has no way to return such a result.
1817///
1818/// \param IsExpr Whether the receiver was parsed as an expression.
1819///
1820/// \param TypeOrExpr If the receiver was parsed as an expression (\c
1821/// IsExpr is true), the parsed expression. If the receiver was parsed
1822/// as a type (\c IsExpr is false), the parsed type.
1823///
1824/// \returns True if an error occurred during parsing or semantic
1825/// analysis, in which case the arguments do not have valid
1826/// values. Otherwise, returns false for a successful parse.
1827///
1828/// objc-receiver: [C++]
1829/// 'super' [not parsed here]
1830/// expression
1831/// simple-type-specifier
1832/// typename-specifier
Douglas Gregor8d4de672010-04-21 22:36:40 +00001833bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr) {
Douglas Gregore9bba4f2010-09-15 14:51:05 +00001834 InMessageExpressionRAIIObject InMessage(*this, true);
1835
Douglas Gregor8d4de672010-04-21 22:36:40 +00001836 if (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) ||
1837 Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope))
1838 TryAnnotateTypeOrScopeToken();
1839
1840 if (!isCXXSimpleTypeSpecifier()) {
1841 // objc-receiver:
1842 // expression
John McCalldadc5752010-08-24 06:29:42 +00001843 ExprResult Receiver = ParseExpression();
Douglas Gregor8d4de672010-04-21 22:36:40 +00001844 if (Receiver.isInvalid())
1845 return true;
1846
1847 IsExpr = true;
1848 TypeOrExpr = Receiver.take();
1849 return false;
1850 }
1851
1852 // objc-receiver:
1853 // typename-specifier
1854 // simple-type-specifier
1855 // expression (that starts with one of the above)
John McCall084e83d2011-03-24 11:26:52 +00001856 DeclSpec DS(AttrFactory);
Douglas Gregor8d4de672010-04-21 22:36:40 +00001857 ParseCXXSimpleTypeSpecifier(DS);
1858
1859 if (Tok.is(tok::l_paren)) {
1860 // If we see an opening parentheses at this point, we are
1861 // actually parsing an expression that starts with a
1862 // function-style cast, e.g.,
1863 //
1864 // postfix-expression:
1865 // simple-type-specifier ( expression-list [opt] )
1866 // typename-specifier ( expression-list [opt] )
1867 //
1868 // Parse the remainder of this case, then the (optional)
1869 // postfix-expression suffix, followed by the (optional)
1870 // right-hand side of the binary expression. We have an
1871 // instance method.
John McCalldadc5752010-08-24 06:29:42 +00001872 ExprResult Receiver = ParseCXXTypeConstructExpression(DS);
Douglas Gregor8d4de672010-04-21 22:36:40 +00001873 if (!Receiver.isInvalid())
John McCallb268a282010-08-23 23:25:46 +00001874 Receiver = ParsePostfixExpressionSuffix(Receiver.take());
Douglas Gregor8d4de672010-04-21 22:36:40 +00001875 if (!Receiver.isInvalid())
John McCallb268a282010-08-23 23:25:46 +00001876 Receiver = ParseRHSOfBinaryExpression(Receiver.take(), prec::Comma);
Douglas Gregor8d4de672010-04-21 22:36:40 +00001877 if (Receiver.isInvalid())
1878 return true;
1879
1880 IsExpr = true;
1881 TypeOrExpr = Receiver.take();
1882 return false;
1883 }
1884
1885 // We have a class message. Turn the simple-type-specifier or
1886 // typename-specifier we parsed into a type and parse the
1887 // remainder of the class message.
1888 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
Douglas Gregor0be31a22010-07-02 17:43:08 +00001889 TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
Douglas Gregor8d4de672010-04-21 22:36:40 +00001890 if (Type.isInvalid())
1891 return true;
1892
1893 IsExpr = false;
John McCallba7bf592010-08-24 05:47:05 +00001894 TypeOrExpr = Type.get().getAsOpaquePtr();
Douglas Gregor8d4de672010-04-21 22:36:40 +00001895 return false;
1896}
1897
Douglas Gregor990ccac2010-05-31 14:40:22 +00001898/// \brief Determine whether the parser is currently referring to a an
1899/// Objective-C message send, using a simplified heuristic to avoid overhead.
1900///
1901/// This routine will only return true for a subset of valid message-send
1902/// expressions.
1903bool Parser::isSimpleObjCMessageExpression() {
Chris Lattner47054fb2010-05-31 18:18:22 +00001904 assert(Tok.is(tok::l_square) && getLang().ObjC1 &&
Douglas Gregor990ccac2010-05-31 14:40:22 +00001905 "Incorrect start for isSimpleObjCMessageExpression");
Douglas Gregor990ccac2010-05-31 14:40:22 +00001906 return GetLookAheadToken(1).is(tok::identifier) &&
1907 GetLookAheadToken(2).is(tok::identifier);
1908}
1909
Douglas Gregorabf4a3e2010-09-16 01:51:54 +00001910bool Parser::isStartOfObjCClassMessageMissingOpenBracket() {
1911 if (!getLang().ObjC1 || !NextToken().is(tok::identifier) ||
1912 InMessageExpression)
1913 return false;
1914
1915
1916 ParsedType Type;
1917
1918 if (Tok.is(tok::annot_typename))
1919 Type = getTypeAnnotation(Tok);
1920 else if (Tok.is(tok::identifier))
1921 Type = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(),
1922 getCurScope());
1923 else
1924 return false;
1925
1926 if (!Type.get().isNull() && Type.get()->isObjCObjectOrInterfaceType()) {
1927 const Token &AfterNext = GetLookAheadToken(2);
1928 if (AfterNext.is(tok::colon) || AfterNext.is(tok::r_square)) {
1929 if (Tok.is(tok::identifier))
1930 TryAnnotateTypeOrScopeToken();
1931
1932 return Tok.is(tok::annot_typename);
1933 }
1934 }
1935
1936 return false;
1937}
1938
Mike Stump11289f42009-09-09 15:08:12 +00001939/// objc-message-expr:
Fariborz Jahanian7db004d2007-09-05 19:52:07 +00001940/// '[' objc-receiver objc-message-args ']'
1941///
Douglas Gregor0c78ad92010-04-21 19:57:20 +00001942/// objc-receiver: [C]
Chris Lattnera36ec422010-04-11 08:28:14 +00001943/// 'super'
Fariborz Jahanian7db004d2007-09-05 19:52:07 +00001944/// expression
1945/// class-name
1946/// type-name
Douglas Gregor8d4de672010-04-21 22:36:40 +00001947///
John McCalldadc5752010-08-24 06:29:42 +00001948ExprResult Parser::ParseObjCMessageExpression() {
Chris Lattner8f697062008-01-25 18:59:06 +00001949 assert(Tok.is(tok::l_square) && "'[' expected");
1950 SourceLocation LBracLoc = ConsumeBracket(); // consume '['
1951
Douglas Gregora817a192010-05-27 23:06:34 +00001952 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001953 Actions.CodeCompleteObjCMessageReceiver(getCurScope());
Douglas Gregora817a192010-05-27 23:06:34 +00001954 ConsumeCodeCompletionToken();
1955 SkipUntil(tok::r_square);
1956 return ExprError();
1957 }
1958
Douglas Gregore9bba4f2010-09-15 14:51:05 +00001959 InMessageExpressionRAIIObject InMessage(*this, true);
1960
Douglas Gregor8d4de672010-04-21 22:36:40 +00001961 if (getLang().CPlusPlus) {
1962 // We completely separate the C and C++ cases because C++ requires
1963 // more complicated (read: slower) parsing.
1964
1965 // Handle send to super.
1966 // FIXME: This doesn't benefit from the same typo-correction we
1967 // get in Objective-C.
1968 if (Tok.is(tok::identifier) && Tok.getIdentifierInfo() == Ident_super &&
Douglas Gregor0be31a22010-07-02 17:43:08 +00001969 NextToken().isNot(tok::period) && getCurScope()->isInObjcMethodScope())
John McCallba7bf592010-08-24 05:47:05 +00001970 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(),
1971 ParsedType(), 0);
Douglas Gregor8d4de672010-04-21 22:36:40 +00001972
1973 // Parse the receiver, which is either a type or an expression.
1974 bool IsExpr;
Nick Lewycky970aed92010-09-15 18:35:19 +00001975 void *TypeOrExpr = NULL;
Douglas Gregor8d4de672010-04-21 22:36:40 +00001976 if (ParseObjCXXMessageReceiver(IsExpr, TypeOrExpr)) {
1977 SkipUntil(tok::r_square);
1978 return ExprError();
1979 }
1980
1981 if (IsExpr)
John McCallba7bf592010-08-24 05:47:05 +00001982 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
1983 ParsedType(),
John McCallb268a282010-08-23 23:25:46 +00001984 static_cast<Expr*>(TypeOrExpr));
Douglas Gregor8d4de672010-04-21 22:36:40 +00001985
1986 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
John McCallba7bf592010-08-24 05:47:05 +00001987 ParsedType::getFromOpaquePtr(TypeOrExpr),
1988 0);
Chris Lattner47054fb2010-05-31 18:18:22 +00001989 }
1990
1991 if (Tok.is(tok::identifier)) {
Douglas Gregora148a1d2010-04-14 02:22:16 +00001992 IdentifierInfo *Name = Tok.getIdentifierInfo();
1993 SourceLocation NameLoc = Tok.getLocation();
John McCallba7bf592010-08-24 05:47:05 +00001994 ParsedType ReceiverType;
Douglas Gregor0be31a22010-07-02 17:43:08 +00001995 switch (Actions.getObjCMessageKind(getCurScope(), Name, NameLoc,
Douglas Gregora148a1d2010-04-14 02:22:16 +00001996 Name == Ident_super,
Douglas Gregore5798dc2010-04-21 20:38:13 +00001997 NextToken().is(tok::period),
1998 ReceiverType)) {
John McCallfaf5fb42010-08-26 23:41:50 +00001999 case Sema::ObjCSuperMessage:
John McCallba7bf592010-08-24 05:47:05 +00002000 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(),
2001 ParsedType(), 0);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002002
John McCallfaf5fb42010-08-26 23:41:50 +00002003 case Sema::ObjCClassMessage:
Douglas Gregore5798dc2010-04-21 20:38:13 +00002004 if (!ReceiverType) {
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002005 SkipUntil(tok::r_square);
2006 return ExprError();
2007 }
2008
Douglas Gregore5798dc2010-04-21 20:38:13 +00002009 ConsumeToken(); // the type name
2010
2011 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
John McCallb268a282010-08-23 23:25:46 +00002012 ReceiverType, 0);
Douglas Gregora148a1d2010-04-14 02:22:16 +00002013
John McCallfaf5fb42010-08-26 23:41:50 +00002014 case Sema::ObjCInstanceMessage:
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002015 // Fall through to parse an expression.
Douglas Gregora148a1d2010-04-14 02:22:16 +00002016 break;
Fariborz Jahanianfc58ca42009-04-08 19:50:10 +00002017 }
Chris Lattner8f697062008-01-25 18:59:06 +00002018 }
Chris Lattnera36ec422010-04-11 08:28:14 +00002019
2020 // Otherwise, an arbitrary expression can be the receiver of a send.
John McCalldadc5752010-08-24 06:29:42 +00002021 ExprResult Res(ParseExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002022 if (Res.isInvalid()) {
Chris Lattner77927cc2008-01-25 19:43:26 +00002023 SkipUntil(tok::r_square);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002024 return move(Res);
Chris Lattner8f697062008-01-25 18:59:06 +00002025 }
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002026
John McCallba7bf592010-08-24 05:47:05 +00002027 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
2028 ParsedType(), Res.take());
Chris Lattner8f697062008-01-25 18:59:06 +00002029}
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002030
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002031/// \brief Parse the remainder of an Objective-C message following the
2032/// '[' objc-receiver.
2033///
2034/// This routine handles sends to super, class messages (sent to a
2035/// class name), and instance messages (sent to an object), and the
2036/// target is represented by \p SuperLoc, \p ReceiverType, or \p
2037/// ReceiverExpr, respectively. Only one of these parameters may have
2038/// a valid value.
2039///
2040/// \param LBracLoc The location of the opening '['.
2041///
2042/// \param SuperLoc If this is a send to 'super', the location of the
2043/// 'super' keyword that indicates a send to the superclass.
2044///
2045/// \param ReceiverType If this is a class message, the type of the
2046/// class we are sending a message to.
2047///
2048/// \param ReceiverExpr If this is an instance message, the expression
2049/// used to compute the receiver object.
Mike Stump11289f42009-09-09 15:08:12 +00002050///
Fariborz Jahanian7db004d2007-09-05 19:52:07 +00002051/// objc-message-args:
2052/// objc-selector
2053/// objc-keywordarg-list
2054///
2055/// objc-keywordarg-list:
2056/// objc-keywordarg
2057/// objc-keywordarg-list objc-keywordarg
2058///
Mike Stump11289f42009-09-09 15:08:12 +00002059/// objc-keywordarg:
Fariborz Jahanian7db004d2007-09-05 19:52:07 +00002060/// selector-name[opt] ':' objc-keywordexpr
2061///
2062/// objc-keywordexpr:
2063/// nonempty-expr-list
2064///
2065/// nonempty-expr-list:
2066/// assignment-expression
2067/// nonempty-expr-list , assignment-expression
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002068///
John McCalldadc5752010-08-24 06:29:42 +00002069ExprResult
Chris Lattner8f697062008-01-25 18:59:06 +00002070Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc,
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002071 SourceLocation SuperLoc,
John McCallba7bf592010-08-24 05:47:05 +00002072 ParsedType ReceiverType,
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002073 ExprArg ReceiverExpr) {
Douglas Gregore9bba4f2010-09-15 14:51:05 +00002074 InMessageExpressionRAIIObject InMessage(*this, true);
2075
Steve Naroffeae65032009-11-07 02:08:14 +00002076 if (Tok.is(tok::code_completion)) {
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002077 if (SuperLoc.isValid())
Douglas Gregorf86e4da2010-09-20 23:34:21 +00002078 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 0, 0,
2079 false);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002080 else if (ReceiverType)
Douglas Gregorf86e4da2010-09-20 23:34:21 +00002081 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 0, 0,
2082 false);
Steve Naroffeae65032009-11-07 02:08:14 +00002083 else
John McCallb268a282010-08-23 23:25:46 +00002084 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00002085 0, 0, false);
Douglas Gregor6da3db42010-05-25 05:58:43 +00002086 ConsumeCodeCompletionToken();
Steve Naroffeae65032009-11-07 02:08:14 +00002087 }
Douglas Gregor1b605f72009-11-19 01:08:35 +00002088
Fariborz Jahanianbd25f7d2007-09-05 23:08:20 +00002089 // Parse objc-selector
Fariborz Jahanian70e8f102007-10-11 00:55:41 +00002090 SourceLocation Loc;
Chris Lattner4f472a32009-04-11 18:13:45 +00002091 IdentifierInfo *selIdent = ParseObjCSelectorPiece(Loc);
Steve Narofff73590d2007-09-27 14:38:14 +00002092
Anders Carlsson978f08d2009-02-14 18:21:46 +00002093 SourceLocation SelectorLoc = Loc;
Mike Stump11289f42009-09-09 15:08:12 +00002094
Steve Narofff73590d2007-09-27 14:38:14 +00002095 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
Sebastian Redl511ed552008-11-25 22:21:31 +00002096 ExprVector KeyExprs(Actions);
Steve Narofff73590d2007-09-27 14:38:14 +00002097
Chris Lattner0ef13522007-10-09 17:51:17 +00002098 if (Tok.is(tok::colon)) {
Fariborz Jahanianbd25f7d2007-09-05 23:08:20 +00002099 while (1) {
2100 // Each iteration parses a single keyword argument.
Steve Narofff73590d2007-09-27 14:38:14 +00002101 KeyIdents.push_back(selIdent);
Steve Naroff486760a2007-09-17 20:25:27 +00002102
Chris Lattner0ef13522007-10-09 17:51:17 +00002103 if (Tok.isNot(tok::colon)) {
Fariborz Jahanianbd25f7d2007-09-05 23:08:20 +00002104 Diag(Tok, diag::err_expected_colon);
Chris Lattner197a3012008-08-05 06:19:09 +00002105 // We must manually skip to a ']', otherwise the expression skipper will
2106 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2107 // the enclosing expression.
2108 SkipUntil(tok::r_square);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002109 return ExprError();
Fariborz Jahanianbd25f7d2007-09-05 23:08:20 +00002110 }
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002111
Steve Narofff73590d2007-09-27 14:38:14 +00002112 ConsumeToken(); // Eat the ':'.
Mike Stump11289f42009-09-09 15:08:12 +00002113 /// Parse the expression after ':'
Douglas Gregorf86e4da2010-09-20 23:34:21 +00002114
2115 if (Tok.is(tok::code_completion)) {
2116 if (SuperLoc.isValid())
2117 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
2118 KeyIdents.data(),
2119 KeyIdents.size(),
2120 /*AtArgumentEpression=*/true);
2121 else if (ReceiverType)
2122 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType,
2123 KeyIdents.data(),
2124 KeyIdents.size(),
2125 /*AtArgumentEpression=*/true);
2126 else
2127 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
2128 KeyIdents.data(),
2129 KeyIdents.size(),
2130 /*AtArgumentEpression=*/true);
2131
2132 ConsumeCodeCompletionToken();
2133 SkipUntil(tok::r_square);
2134 return ExprError();
2135 }
2136
John McCalldadc5752010-08-24 06:29:42 +00002137 ExprResult Res(ParseAssignmentExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002138 if (Res.isInvalid()) {
Chris Lattner197a3012008-08-05 06:19:09 +00002139 // We must manually skip to a ']', otherwise the expression skipper will
2140 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2141 // the enclosing expression.
2142 SkipUntil(tok::r_square);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002143 return move(Res);
Steve Naroff486760a2007-09-17 20:25:27 +00002144 }
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002145
Steve Naroff486760a2007-09-17 20:25:27 +00002146 // We have a valid expression.
Sebastian Redld9f7b1c2008-12-10 00:02:53 +00002147 KeyExprs.push_back(Res.release());
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002148
Douglas Gregor1b605f72009-11-19 01:08:35 +00002149 // Code completion after each argument.
2150 if (Tok.is(tok::code_completion)) {
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002151 if (SuperLoc.isValid())
Douglas Gregor0be31a22010-07-02 17:43:08 +00002152 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002153 KeyIdents.data(),
Douglas Gregorf86e4da2010-09-20 23:34:21 +00002154 KeyIdents.size(),
2155 /*AtArgumentEpression=*/false);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002156 else if (ReceiverType)
Douglas Gregor0be31a22010-07-02 17:43:08 +00002157 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType,
Douglas Gregor1b605f72009-11-19 01:08:35 +00002158 KeyIdents.data(),
Douglas Gregorf86e4da2010-09-20 23:34:21 +00002159 KeyIdents.size(),
2160 /*AtArgumentEpression=*/false);
Douglas Gregor1b605f72009-11-19 01:08:35 +00002161 else
John McCallb268a282010-08-23 23:25:46 +00002162 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
Douglas Gregor1b605f72009-11-19 01:08:35 +00002163 KeyIdents.data(),
Douglas Gregorf86e4da2010-09-20 23:34:21 +00002164 KeyIdents.size(),
2165 /*AtArgumentEpression=*/false);
Douglas Gregor6da3db42010-05-25 05:58:43 +00002166 ConsumeCodeCompletionToken();
Douglas Gregorf86e4da2010-09-20 23:34:21 +00002167 SkipUntil(tok::r_square);
2168 return ExprError();
Douglas Gregor1b605f72009-11-19 01:08:35 +00002169 }
2170
Steve Naroff486760a2007-09-17 20:25:27 +00002171 // Check for another keyword selector.
Chris Lattner4f472a32009-04-11 18:13:45 +00002172 selIdent = ParseObjCSelectorPiece(Loc);
Chris Lattner0ef13522007-10-09 17:51:17 +00002173 if (!selIdent && Tok.isNot(tok::colon))
Fariborz Jahanianbd25f7d2007-09-05 23:08:20 +00002174 break;
2175 // We have a selector or a colon, continue parsing.
2176 }
2177 // Parse the, optional, argument list, comma separated.
Chris Lattner0ef13522007-10-09 17:51:17 +00002178 while (Tok.is(tok::comma)) {
Steve Naroffe3ffc2f2007-11-15 13:05:42 +00002179 ConsumeToken(); // Eat the ','.
Mike Stump11289f42009-09-09 15:08:12 +00002180 /// Parse the expression after ','
John McCalldadc5752010-08-24 06:29:42 +00002181 ExprResult Res(ParseAssignmentExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002182 if (Res.isInvalid()) {
Chris Lattner197a3012008-08-05 06:19:09 +00002183 // We must manually skip to a ']', otherwise the expression skipper will
2184 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2185 // the enclosing expression.
2186 SkipUntil(tok::r_square);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002187 return move(Res);
Steve Naroffe3ffc2f2007-11-15 13:05:42 +00002188 }
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002189
Steve Naroffe3ffc2f2007-11-15 13:05:42 +00002190 // We have a valid expression.
Sebastian Redld9f7b1c2008-12-10 00:02:53 +00002191 KeyExprs.push_back(Res.release());
Fariborz Jahanianbd25f7d2007-09-05 23:08:20 +00002192 }
2193 } else if (!selIdent) {
2194 Diag(Tok, diag::err_expected_ident); // missing selector name.
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002195
Chris Lattner197a3012008-08-05 06:19:09 +00002196 // We must manually skip to a ']', otherwise the expression skipper will
2197 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2198 // the enclosing expression.
2199 SkipUntil(tok::r_square);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002200 return ExprError();
Fariborz Jahanianbd25f7d2007-09-05 23:08:20 +00002201 }
Fariborz Jahanian083712f2010-03-31 20:22:35 +00002202
Chris Lattner0ef13522007-10-09 17:51:17 +00002203 if (Tok.isNot(tok::r_square)) {
Fariborz Jahanian083712f2010-03-31 20:22:35 +00002204 if (Tok.is(tok::identifier))
2205 Diag(Tok, diag::err_expected_colon);
2206 else
2207 Diag(Tok, diag::err_expected_rsquare);
Chris Lattner197a3012008-08-05 06:19:09 +00002208 // We must manually skip to a ']', otherwise the expression skipper will
2209 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2210 // the enclosing expression.
2211 SkipUntil(tok::r_square);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002212 return ExprError();
Fariborz Jahanianbd25f7d2007-09-05 23:08:20 +00002213 }
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002214
Chris Lattner8f697062008-01-25 18:59:06 +00002215 SourceLocation RBracLoc = ConsumeBracket(); // consume ']'
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002216
Steve Naroffe61bfa82007-10-05 18:42:47 +00002217 unsigned nKeys = KeyIdents.size();
Chris Lattner5700fab2007-10-07 02:00:24 +00002218 if (nKeys == 0)
2219 KeyIdents.push_back(selIdent);
2220 Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002221
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002222 if (SuperLoc.isValid())
Douglas Gregor0be31a22010-07-02 17:43:08 +00002223 return Actions.ActOnSuperMessage(getCurScope(), SuperLoc, Sel,
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002224 LBracLoc, SelectorLoc, RBracLoc,
John McCallfaf5fb42010-08-26 23:41:50 +00002225 MultiExprArg(Actions,
2226 KeyExprs.take(),
2227 KeyExprs.size()));
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002228 else if (ReceiverType)
Douglas Gregor0be31a22010-07-02 17:43:08 +00002229 return Actions.ActOnClassMessage(getCurScope(), ReceiverType, Sel,
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002230 LBracLoc, SelectorLoc, RBracLoc,
John McCallfaf5fb42010-08-26 23:41:50 +00002231 MultiExprArg(Actions,
2232 KeyExprs.take(),
2233 KeyExprs.size()));
John McCallb268a282010-08-23 23:25:46 +00002234 return Actions.ActOnInstanceMessage(getCurScope(), ReceiverExpr, Sel,
Douglas Gregor0c78ad92010-04-21 19:57:20 +00002235 LBracLoc, SelectorLoc, RBracLoc,
John McCallfaf5fb42010-08-26 23:41:50 +00002236 MultiExprArg(Actions,
2237 KeyExprs.take(),
2238 KeyExprs.size()));
Fariborz Jahanian7db004d2007-09-05 19:52:07 +00002239}
2240
John McCalldadc5752010-08-24 06:29:42 +00002241ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) {
2242 ExprResult Res(ParseStringLiteralExpression());
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002243 if (Res.isInvalid()) return move(Res);
2244
Chris Lattnere002fbe2007-12-12 01:04:12 +00002245 // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string
2246 // expressions. At this point, we know that the only valid thing that starts
2247 // with '@' is an @"".
2248 llvm::SmallVector<SourceLocation, 4> AtLocs;
Sebastian Redl511ed552008-11-25 22:21:31 +00002249 ExprVector AtStrings(Actions);
Chris Lattnere002fbe2007-12-12 01:04:12 +00002250 AtLocs.push_back(AtLoc);
Sebastian Redld9f7b1c2008-12-10 00:02:53 +00002251 AtStrings.push_back(Res.release());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002252
Chris Lattnere002fbe2007-12-12 01:04:12 +00002253 while (Tok.is(tok::at)) {
2254 AtLocs.push_back(ConsumeToken()); // eat the @.
Anders Carlsson76f4a902007-08-21 17:43:55 +00002255
Sebastian Redlc13f2682008-12-09 20:22:58 +00002256 // Invalid unless there is a string literal.
Chris Lattnerd3b5d5d2009-02-18 05:56:09 +00002257 if (!isTokenStringLiteral())
2258 return ExprError(Diag(Tok, diag::err_objc_concat_string));
Chris Lattnere002fbe2007-12-12 01:04:12 +00002259
John McCalldadc5752010-08-24 06:29:42 +00002260 ExprResult Lit(ParseStringLiteralExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002261 if (Lit.isInvalid())
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002262 return move(Lit);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002263
Sebastian Redld9f7b1c2008-12-10 00:02:53 +00002264 AtStrings.push_back(Lit.release());
Chris Lattnere002fbe2007-12-12 01:04:12 +00002265 }
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002266
2267 return Owned(Actions.ParseObjCStringLiteral(&AtLocs[0], AtStrings.take(),
2268 AtStrings.size()));
Anders Carlsson76f4a902007-08-21 17:43:55 +00002269}
Anders Carlssonc5a81eb2007-08-22 15:14:15 +00002270
2271/// objc-encode-expression:
2272/// @encode ( type-name )
John McCalldadc5752010-08-24 06:29:42 +00002273ExprResult
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002274Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) {
Steve Naroff7c348172007-08-23 18:16:40 +00002275 assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!");
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002276
Anders Carlssonc5a81eb2007-08-22 15:14:15 +00002277 SourceLocation EncLoc = ConsumeToken();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002278
Chris Lattner197a3012008-08-05 06:19:09 +00002279 if (Tok.isNot(tok::l_paren))
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002280 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode");
2281
Anders Carlssonc5a81eb2007-08-22 15:14:15 +00002282 SourceLocation LParenLoc = ConsumeParen();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002283
Douglas Gregor220cac52009-02-18 17:45:20 +00002284 TypeResult Ty = ParseTypeName();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002285
Anders Carlssoncb8f8322007-08-23 15:31:37 +00002286 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002287
Douglas Gregor220cac52009-02-18 17:45:20 +00002288 if (Ty.isInvalid())
2289 return ExprError();
2290
Mike Stump11289f42009-09-09 15:08:12 +00002291 return Owned(Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, LParenLoc,
Douglas Gregor220cac52009-02-18 17:45:20 +00002292 Ty.get(), RParenLoc));
Anders Carlssonc5a81eb2007-08-22 15:14:15 +00002293}
Anders Carlssone01493d2007-08-23 15:25:28 +00002294
2295/// objc-protocol-expression
2296/// @protocol ( protocol-name )
John McCalldadc5752010-08-24 06:29:42 +00002297ExprResult
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002298Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) {
Anders Carlssone01493d2007-08-23 15:25:28 +00002299 SourceLocation ProtoLoc = ConsumeToken();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002300
Chris Lattner197a3012008-08-05 06:19:09 +00002301 if (Tok.isNot(tok::l_paren))
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002302 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol");
2303
Anders Carlssone01493d2007-08-23 15:25:28 +00002304 SourceLocation LParenLoc = ConsumeParen();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002305
Chris Lattner197a3012008-08-05 06:19:09 +00002306 if (Tok.isNot(tok::identifier))
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002307 return ExprError(Diag(Tok, diag::err_expected_ident));
2308
Fariborz Jahaniana32aaef2007-10-17 16:58:11 +00002309 IdentifierInfo *protocolId = Tok.getIdentifierInfo();
Anders Carlssone01493d2007-08-23 15:25:28 +00002310 ConsumeToken();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002311
Anders Carlssoncb8f8322007-08-23 15:31:37 +00002312 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
Anders Carlssone01493d2007-08-23 15:25:28 +00002313
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002314 return Owned(Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc,
2315 LParenLoc, RParenLoc));
Anders Carlssone01493d2007-08-23 15:25:28 +00002316}
Fariborz Jahanian76a94272007-10-15 23:39:13 +00002317
2318/// objc-selector-expression
2319/// @selector '(' objc-keyword-selector ')'
John McCalldadc5752010-08-24 06:29:42 +00002320ExprResult Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) {
Fariborz Jahanian76a94272007-10-15 23:39:13 +00002321 SourceLocation SelectorLoc = ConsumeToken();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002322
Chris Lattner197a3012008-08-05 06:19:09 +00002323 if (Tok.isNot(tok::l_paren))
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002324 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector");
2325
Fariborz Jahanian4bef4622007-10-16 20:40:23 +00002326 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
Fariborz Jahanian76a94272007-10-15 23:39:13 +00002327 SourceLocation LParenLoc = ConsumeParen();
2328 SourceLocation sLoc;
Douglas Gregor67c692c2010-08-26 15:07:07 +00002329
2330 if (Tok.is(tok::code_completion)) {
2331 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents.data(),
2332 KeyIdents.size());
2333 ConsumeCodeCompletionToken();
2334 MatchRHSPunctuation(tok::r_paren, LParenLoc);
2335 return ExprError();
2336 }
2337
Chris Lattner4f472a32009-04-11 18:13:45 +00002338 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc);
Chris Lattner1ba64452010-08-27 22:32:41 +00002339 if (!SelIdent && // missing selector name.
2340 Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon))
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002341 return ExprError(Diag(Tok, diag::err_expected_ident));
2342
Fariborz Jahanian4bef4622007-10-16 20:40:23 +00002343 KeyIdents.push_back(SelIdent);
Steve Naroff152dd812007-12-05 22:21:29 +00002344 unsigned nColons = 0;
2345 if (Tok.isNot(tok::r_paren)) {
Fariborz Jahanian76a94272007-10-15 23:39:13 +00002346 while (1) {
Chris Lattner1ba64452010-08-27 22:32:41 +00002347 if (Tok.is(tok::coloncolon)) { // Handle :: in C++.
2348 ++nColons;
2349 KeyIdents.push_back(0);
2350 } else if (Tok.isNot(tok::colon))
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002351 return ExprError(Diag(Tok, diag::err_expected_colon));
2352
Chris Lattner1ba64452010-08-27 22:32:41 +00002353 ++nColons;
Fariborz Jahanian76a94272007-10-15 23:39:13 +00002354 ConsumeToken(); // Eat the ':'.
2355 if (Tok.is(tok::r_paren))
2356 break;
Douglas Gregor67c692c2010-08-26 15:07:07 +00002357
2358 if (Tok.is(tok::code_completion)) {
2359 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents.data(),
2360 KeyIdents.size());
2361 ConsumeCodeCompletionToken();
2362 MatchRHSPunctuation(tok::r_paren, LParenLoc);
2363 return ExprError();
2364 }
2365
Fariborz Jahanian76a94272007-10-15 23:39:13 +00002366 // Check for another keyword selector.
2367 SourceLocation Loc;
Chris Lattner4f472a32009-04-11 18:13:45 +00002368 SelIdent = ParseObjCSelectorPiece(Loc);
Fariborz Jahanian4bef4622007-10-16 20:40:23 +00002369 KeyIdents.push_back(SelIdent);
Fariborz Jahanian76a94272007-10-15 23:39:13 +00002370 if (!SelIdent && Tok.isNot(tok::colon))
2371 break;
2372 }
Steve Naroff152dd812007-12-05 22:21:29 +00002373 }
Fariborz Jahanian76a94272007-10-15 23:39:13 +00002374 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
Steve Naroff152dd812007-12-05 22:21:29 +00002375 Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]);
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002376 return Owned(Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc,
2377 LParenLoc, RParenLoc));
Gabor Greif24032f12007-10-19 15:38:32 +00002378 }