1 //===--- ParseObjC.cpp - Objective C Parsing ------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Objective-C portions of the Parser interface.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/PrettyDeclStackTrace.h"
15 #include "clang/Basic/CharInfo.h"
16 #include "clang/Basic/TargetInfo.h"
17 #include "clang/Parse/ParseDiagnostic.h"
18 #include "clang/Parse/Parser.h"
19 #include "clang/Parse/RAIIObjectsForParser.h"
20 #include "clang/Sema/DeclSpec.h"
21 #include "clang/Sema/Scope.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringExtras.h"
24
25 using namespace clang;
26
27 /// Skips attributes after an Objective-C @ directive. Emits a diagnostic.
MaybeSkipAttributes(tok::ObjCKeywordKind Kind)28 void Parser::MaybeSkipAttributes(tok::ObjCKeywordKind Kind) {
29 ParsedAttributes attrs(AttrFactory);
30 if (Tok.is(tok::kw___attribute)) {
31 if (Kind == tok::objc_interface || Kind == tok::objc_protocol)
32 Diag(Tok, diag::err_objc_postfix_attribute_hint)
33 << (Kind == tok::objc_protocol);
34 else
35 Diag(Tok, diag::err_objc_postfix_attribute);
36 ParseGNUAttributes(attrs);
37 }
38 }
39
40 /// ParseObjCAtDirectives - Handle parts of the external-declaration production:
41 /// external-declaration: [C99 6.9]
42 /// [OBJC] objc-class-definition
43 /// [OBJC] objc-class-declaration
44 /// [OBJC] objc-alias-declaration
45 /// [OBJC] objc-protocol-definition
46 /// [OBJC] objc-method-definition
47 /// [OBJC] '@' 'end'
48 Parser::DeclGroupPtrTy
ParseObjCAtDirectives(ParsedAttributesWithRange & Attrs)49 Parser::ParseObjCAtDirectives(ParsedAttributesWithRange &Attrs) {
50 SourceLocation AtLoc = ConsumeToken(); // the "@"
51
52 if (Tok.is(tok::code_completion)) {
53 Actions.CodeCompleteObjCAtDirective(getCurScope());
54 cutOffParsing();
55 return nullptr;
56 }
57
58 Decl *SingleDecl = nullptr;
59 switch (Tok.getObjCKeywordID()) {
60 case tok::objc_class:
61 return ParseObjCAtClassDeclaration(AtLoc);
62 case tok::objc_interface:
63 SingleDecl = ParseObjCAtInterfaceDeclaration(AtLoc, Attrs);
64 break;
65 case tok::objc_protocol:
66 return ParseObjCAtProtocolDeclaration(AtLoc, Attrs);
67 case tok::objc_implementation:
68 return ParseObjCAtImplementationDeclaration(AtLoc, Attrs);
69 case tok::objc_end:
70 return ParseObjCAtEndDeclaration(AtLoc);
71 case tok::objc_compatibility_alias:
72 SingleDecl = ParseObjCAtAliasDeclaration(AtLoc);
73 break;
74 case tok::objc_synthesize:
75 SingleDecl = ParseObjCPropertySynthesize(AtLoc);
76 break;
77 case tok::objc_dynamic:
78 SingleDecl = ParseObjCPropertyDynamic(AtLoc);
79 break;
80 case tok::objc_import:
81 if (getLangOpts().Modules || getLangOpts().DebuggerSupport) {
82 SingleDecl = ParseModuleImport(AtLoc);
83 break;
84 }
85 Diag(AtLoc, diag::err_atimport);
86 SkipUntil(tok::semi);
87 return Actions.ConvertDeclToDeclGroup(nullptr);
88 default:
89 Diag(AtLoc, diag::err_unexpected_at);
90 SkipUntil(tok::semi);
91 SingleDecl = nullptr;
92 break;
93 }
94 return Actions.ConvertDeclToDeclGroup(SingleDecl);
95 }
96
97 /// Class to handle popping type parameters when leaving the scope.
98 class Parser::ObjCTypeParamListScope {
99 Sema &Actions;
100 Scope *S;
101 ObjCTypeParamList *Params;
102
103 public:
ObjCTypeParamListScope(Sema & Actions,Scope * S)104 ObjCTypeParamListScope(Sema &Actions, Scope *S)
105 : Actions(Actions), S(S), Params(nullptr) {}
106
~ObjCTypeParamListScope()107 ~ObjCTypeParamListScope() {
108 leave();
109 }
110
enter(ObjCTypeParamList * P)111 void enter(ObjCTypeParamList *P) {
112 assert(!Params);
113 Params = P;
114 }
115
leave()116 void leave() {
117 if (Params)
118 Actions.popObjCTypeParamList(S, Params);
119 Params = nullptr;
120 }
121 };
122
123 ///
124 /// objc-class-declaration:
125 /// '@' 'class' objc-class-forward-decl (',' objc-class-forward-decl)* ';'
126 ///
127 /// objc-class-forward-decl:
128 /// identifier objc-type-parameter-list[opt]
129 ///
130 Parser::DeclGroupPtrTy
ParseObjCAtClassDeclaration(SourceLocation atLoc)131 Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) {
132 ConsumeToken(); // the identifier "class"
133 SmallVector<IdentifierInfo *, 8> ClassNames;
134 SmallVector<SourceLocation, 8> ClassLocs;
135 SmallVector<ObjCTypeParamList *, 8> ClassTypeParams;
136
137 while (1) {
138 MaybeSkipAttributes(tok::objc_class);
139 if (expectIdentifier()) {
140 SkipUntil(tok::semi);
141 return Actions.ConvertDeclToDeclGroup(nullptr);
142 }
143 ClassNames.push_back(Tok.getIdentifierInfo());
144 ClassLocs.push_back(Tok.getLocation());
145 ConsumeToken();
146
147 // Parse the optional objc-type-parameter-list.
148 ObjCTypeParamList *TypeParams = nullptr;
149 if (Tok.is(tok::less))
150 TypeParams = parseObjCTypeParamList();
151 ClassTypeParams.push_back(TypeParams);
152 if (!TryConsumeToken(tok::comma))
153 break;
154 }
155
156 // Consume the ';'.
157 if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@class"))
158 return Actions.ConvertDeclToDeclGroup(nullptr);
159
160 return Actions.ActOnForwardClassDeclaration(atLoc, ClassNames.data(),
161 ClassLocs.data(),
162 ClassTypeParams,
163 ClassNames.size());
164 }
165
CheckNestedObjCContexts(SourceLocation AtLoc)166 void Parser::CheckNestedObjCContexts(SourceLocation AtLoc)
167 {
168 Sema::ObjCContainerKind ock = Actions.getObjCContainerKind();
169 if (ock == Sema::OCK_None)
170 return;
171
172 Decl *Decl = Actions.getObjCDeclContext();
173 if (CurParsedObjCImpl) {
174 CurParsedObjCImpl->finish(AtLoc);
175 } else {
176 Actions.ActOnAtEnd(getCurScope(), AtLoc);
177 }
178 Diag(AtLoc, diag::err_objc_missing_end)
179 << FixItHint::CreateInsertion(AtLoc, "@end\n");
180 if (Decl)
181 Diag(Decl->getBeginLoc(), diag::note_objc_container_start) << (int)ock;
182 }
183
184 ///
185 /// objc-interface:
186 /// objc-class-interface-attributes[opt] objc-class-interface
187 /// objc-category-interface
188 ///
189 /// objc-class-interface:
190 /// '@' 'interface' identifier objc-type-parameter-list[opt]
191 /// objc-superclass[opt] objc-protocol-refs[opt]
192 /// objc-class-instance-variables[opt]
193 /// objc-interface-decl-list
194 /// @end
195 ///
196 /// objc-category-interface:
197 /// '@' 'interface' identifier objc-type-parameter-list[opt]
198 /// '(' identifier[opt] ')' objc-protocol-refs[opt]
199 /// objc-interface-decl-list
200 /// @end
201 ///
202 /// objc-superclass:
203 /// ':' identifier objc-type-arguments[opt]
204 ///
205 /// objc-class-interface-attributes:
206 /// __attribute__((visibility("default")))
207 /// __attribute__((visibility("hidden")))
208 /// __attribute__((deprecated))
209 /// __attribute__((unavailable))
210 /// __attribute__((objc_exception)) - used by NSException on 64-bit
211 /// __attribute__((objc_root_class))
212 ///
ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,ParsedAttributes & attrs)213 Decl *Parser::ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,
214 ParsedAttributes &attrs) {
215 assert(Tok.isObjCAtKeyword(tok::objc_interface) &&
216 "ParseObjCAtInterfaceDeclaration(): Expected @interface");
217 CheckNestedObjCContexts(AtLoc);
218 ConsumeToken(); // the "interface" identifier
219
220 // Code completion after '@interface'.
221 if (Tok.is(tok::code_completion)) {
222 Actions.CodeCompleteObjCInterfaceDecl(getCurScope());
223 cutOffParsing();
224 return nullptr;
225 }
226
227 MaybeSkipAttributes(tok::objc_interface);
228
229 if (expectIdentifier())
230 return nullptr; // missing class or category name.
231
232 // We have a class or category name - consume it.
233 IdentifierInfo *nameId = Tok.getIdentifierInfo();
234 SourceLocation nameLoc = ConsumeToken();
235
236 // Parse the objc-type-parameter-list or objc-protocol-refs. For the latter
237 // case, LAngleLoc will be valid and ProtocolIdents will capture the
238 // protocol references (that have not yet been resolved).
239 SourceLocation LAngleLoc, EndProtoLoc;
240 SmallVector<IdentifierLocPair, 8> ProtocolIdents;
241 ObjCTypeParamList *typeParameterList = nullptr;
242 ObjCTypeParamListScope typeParamScope(Actions, getCurScope());
243 if (Tok.is(tok::less))
244 typeParameterList = parseObjCTypeParamListOrProtocolRefs(
245 typeParamScope, LAngleLoc, ProtocolIdents, EndProtoLoc);
246
247 if (Tok.is(tok::l_paren) &&
248 !isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { // we have a category.
249
250 BalancedDelimiterTracker T(*this, tok::l_paren);
251 T.consumeOpen();
252
253 SourceLocation categoryLoc;
254 IdentifierInfo *categoryId = nullptr;
255 if (Tok.is(tok::code_completion)) {
256 Actions.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId, nameLoc);
257 cutOffParsing();
258 return nullptr;
259 }
260
261 // For ObjC2, the category name is optional (not an error).
262 if (Tok.is(tok::identifier)) {
263 categoryId = Tok.getIdentifierInfo();
264 categoryLoc = ConsumeToken();
265 }
266 else if (!getLangOpts().ObjC) {
267 Diag(Tok, diag::err_expected)
268 << tok::identifier; // missing category name.
269 return nullptr;
270 }
271
272 T.consumeClose();
273 if (T.getCloseLocation().isInvalid())
274 return nullptr;
275
276 // Next, we need to check for any protocol references.
277 assert(LAngleLoc.isInvalid() && "Cannot have already parsed protocols");
278 SmallVector<Decl *, 8> ProtocolRefs;
279 SmallVector<SourceLocation, 8> ProtocolLocs;
280 if (Tok.is(tok::less) &&
281 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true, true,
282 LAngleLoc, EndProtoLoc,
283 /*consumeLastToken=*/true))
284 return nullptr;
285
286 Decl *CategoryType = Actions.ActOnStartCategoryInterface(
287 AtLoc, nameId, nameLoc, typeParameterList, categoryId, categoryLoc,
288 ProtocolRefs.data(), ProtocolRefs.size(), ProtocolLocs.data(),
289 EndProtoLoc, attrs);
290
291 if (Tok.is(tok::l_brace))
292 ParseObjCClassInstanceVariables(CategoryType, tok::objc_private, AtLoc);
293
294 ParseObjCInterfaceDeclList(tok::objc_not_keyword, CategoryType);
295
296 return CategoryType;
297 }
298 // Parse a class interface.
299 IdentifierInfo *superClassId = nullptr;
300 SourceLocation superClassLoc;
301 SourceLocation typeArgsLAngleLoc;
302 SmallVector<ParsedType, 4> typeArgs;
303 SourceLocation typeArgsRAngleLoc;
304 SmallVector<Decl *, 4> protocols;
305 SmallVector<SourceLocation, 4> protocolLocs;
306 if (Tok.is(tok::colon)) { // a super class is specified.
307 ConsumeToken();
308
309 // Code completion of superclass names.
310 if (Tok.is(tok::code_completion)) {
311 Actions.CodeCompleteObjCSuperclass(getCurScope(), nameId, nameLoc);
312 cutOffParsing();
313 return nullptr;
314 }
315
316 if (expectIdentifier())
317 return nullptr; // missing super class name.
318 superClassId = Tok.getIdentifierInfo();
319 superClassLoc = ConsumeToken();
320
321 // Type arguments for the superclass or protocol conformances.
322 if (Tok.is(tok::less)) {
323 parseObjCTypeArgsOrProtocolQualifiers(
324 nullptr, typeArgsLAngleLoc, typeArgs, typeArgsRAngleLoc, LAngleLoc,
325 protocols, protocolLocs, EndProtoLoc,
326 /*consumeLastToken=*/true,
327 /*warnOnIncompleteProtocols=*/true);
328 if (Tok.is(tok::eof))
329 return nullptr;
330 }
331 }
332
333 // Next, we need to check for any protocol references.
334 if (LAngleLoc.isValid()) {
335 if (!ProtocolIdents.empty()) {
336 // We already parsed the protocols named when we thought we had a
337 // type parameter list. Translate them into actual protocol references.
338 for (const auto &pair : ProtocolIdents) {
339 protocolLocs.push_back(pair.second);
340 }
341 Actions.FindProtocolDeclaration(/*WarnOnDeclarations=*/true,
342 /*ForObjCContainer=*/true,
343 ProtocolIdents, protocols);
344 }
345 } else if (protocols.empty() && Tok.is(tok::less) &&
346 ParseObjCProtocolReferences(protocols, protocolLocs, true, true,
347 LAngleLoc, EndProtoLoc,
348 /*consumeLastToken=*/true)) {
349 return nullptr;
350 }
351
352 if (Tok.isNot(tok::less))
353 Actions.ActOnTypedefedProtocols(protocols, protocolLocs,
354 superClassId, superClassLoc);
355
356 Decl *ClsType = Actions.ActOnStartClassInterface(
357 getCurScope(), AtLoc, nameId, nameLoc, typeParameterList, superClassId,
358 superClassLoc, typeArgs,
359 SourceRange(typeArgsLAngleLoc, typeArgsRAngleLoc), protocols.data(),
360 protocols.size(), protocolLocs.data(), EndProtoLoc, attrs);
361
362 if (Tok.is(tok::l_brace))
363 ParseObjCClassInstanceVariables(ClsType, tok::objc_protected, AtLoc);
364
365 ParseObjCInterfaceDeclList(tok::objc_interface, ClsType);
366
367 return ClsType;
368 }
369
370 /// Add an attribute for a context-sensitive type nullability to the given
371 /// declarator.
addContextSensitiveTypeNullability(Parser & P,Declarator & D,NullabilityKind nullability,SourceLocation nullabilityLoc,bool & addedToDeclSpec)372 static void addContextSensitiveTypeNullability(Parser &P,
373 Declarator &D,
374 NullabilityKind nullability,
375 SourceLocation nullabilityLoc,
376 bool &addedToDeclSpec) {
377 // Create the attribute.
378 auto getNullabilityAttr = [&](AttributePool &Pool) -> ParsedAttr * {
379 return Pool.create(P.getNullabilityKeyword(nullability),
380 SourceRange(nullabilityLoc), nullptr, SourceLocation(),
381 nullptr, 0, ParsedAttr::AS_ContextSensitiveKeyword);
382 };
383
384 if (D.getNumTypeObjects() > 0) {
385 // Add the attribute to the declarator chunk nearest the declarator.
386 D.getTypeObject(0).getAttrs().addAtEnd(
387 getNullabilityAttr(D.getAttributePool()));
388 } else if (!addedToDeclSpec) {
389 // Otherwise, just put it on the declaration specifiers (if one
390 // isn't there already).
391 D.getMutableDeclSpec().getAttributes().addAtEnd(
392 getNullabilityAttr(D.getMutableDeclSpec().getAttributes().getPool()));
393 addedToDeclSpec = true;
394 }
395 }
396
397 /// Parse an Objective-C type parameter list, if present, or capture
398 /// the locations of the protocol identifiers for a list of protocol
399 /// references.
400 ///
401 /// objc-type-parameter-list:
402 /// '<' objc-type-parameter (',' objc-type-parameter)* '>'
403 ///
404 /// objc-type-parameter:
405 /// objc-type-parameter-variance? identifier objc-type-parameter-bound[opt]
406 ///
407 /// objc-type-parameter-bound:
408 /// ':' type-name
409 ///
410 /// objc-type-parameter-variance:
411 /// '__covariant'
412 /// '__contravariant'
413 ///
414 /// \param lAngleLoc The location of the starting '<'.
415 ///
416 /// \param protocolIdents Will capture the list of identifiers, if the
417 /// angle brackets contain a list of protocol references rather than a
418 /// type parameter list.
419 ///
420 /// \param rAngleLoc The location of the ending '>'.
parseObjCTypeParamListOrProtocolRefs(ObjCTypeParamListScope & Scope,SourceLocation & lAngleLoc,SmallVectorImpl<IdentifierLocPair> & protocolIdents,SourceLocation & rAngleLoc,bool mayBeProtocolList)421 ObjCTypeParamList *Parser::parseObjCTypeParamListOrProtocolRefs(
422 ObjCTypeParamListScope &Scope, SourceLocation &lAngleLoc,
423 SmallVectorImpl<IdentifierLocPair> &protocolIdents,
424 SourceLocation &rAngleLoc, bool mayBeProtocolList) {
425 assert(Tok.is(tok::less) && "Not at the beginning of a type parameter list");
426
427 // Within the type parameter list, don't treat '>' as an operator.
428 GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
429
430 // Local function to "flush" the protocol identifiers, turning them into
431 // type parameters.
432 SmallVector<Decl *, 4> typeParams;
433 auto makeProtocolIdentsIntoTypeParameters = [&]() {
434 unsigned index = 0;
435 for (const auto &pair : protocolIdents) {
436 DeclResult typeParam = Actions.actOnObjCTypeParam(
437 getCurScope(), ObjCTypeParamVariance::Invariant, SourceLocation(),
438 index++, pair.first, pair.second, SourceLocation(), nullptr);
439 if (typeParam.isUsable())
440 typeParams.push_back(typeParam.get());
441 }
442
443 protocolIdents.clear();
444 mayBeProtocolList = false;
445 };
446
447 bool invalid = false;
448 lAngleLoc = ConsumeToken();
449
450 do {
451 // Parse the variance, if any.
452 SourceLocation varianceLoc;
453 ObjCTypeParamVariance variance = ObjCTypeParamVariance::Invariant;
454 if (Tok.is(tok::kw___covariant) || Tok.is(tok::kw___contravariant)) {
455 variance = Tok.is(tok::kw___covariant)
456 ? ObjCTypeParamVariance::Covariant
457 : ObjCTypeParamVariance::Contravariant;
458 varianceLoc = ConsumeToken();
459
460 // Once we've seen a variance specific , we know this is not a
461 // list of protocol references.
462 if (mayBeProtocolList) {
463 // Up until now, we have been queuing up parameters because they
464 // might be protocol references. Turn them into parameters now.
465 makeProtocolIdentsIntoTypeParameters();
466 }
467 }
468
469 // Parse the identifier.
470 if (!Tok.is(tok::identifier)) {
471 // Code completion.
472 if (Tok.is(tok::code_completion)) {
473 // FIXME: If these aren't protocol references, we'll need different
474 // completions.
475 Actions.CodeCompleteObjCProtocolReferences(protocolIdents);
476 cutOffParsing();
477
478 // FIXME: Better recovery here?.
479 return nullptr;
480 }
481
482 Diag(Tok, diag::err_objc_expected_type_parameter);
483 invalid = true;
484 break;
485 }
486
487 IdentifierInfo *paramName = Tok.getIdentifierInfo();
488 SourceLocation paramLoc = ConsumeToken();
489
490 // If there is a bound, parse it.
491 SourceLocation colonLoc;
492 TypeResult boundType;
493 if (TryConsumeToken(tok::colon, colonLoc)) {
494 // Once we've seen a bound, we know this is not a list of protocol
495 // references.
496 if (mayBeProtocolList) {
497 // Up until now, we have been queuing up parameters because they
498 // might be protocol references. Turn them into parameters now.
499 makeProtocolIdentsIntoTypeParameters();
500 }
501
502 // type-name
503 boundType = ParseTypeName();
504 if (boundType.isInvalid())
505 invalid = true;
506 } else if (mayBeProtocolList) {
507 // If this could still be a protocol list, just capture the identifier.
508 // We don't want to turn it into a parameter.
509 protocolIdents.push_back(std::make_pair(paramName, paramLoc));
510 continue;
511 }
512
513 // Create the type parameter.
514 DeclResult typeParam = Actions.actOnObjCTypeParam(
515 getCurScope(), variance, varianceLoc, typeParams.size(), paramName,
516 paramLoc, colonLoc, boundType.isUsable() ? boundType.get() : nullptr);
517 if (typeParam.isUsable())
518 typeParams.push_back(typeParam.get());
519 } while (TryConsumeToken(tok::comma));
520
521 // Parse the '>'.
522 if (invalid) {
523 SkipUntil(tok::greater, tok::at, StopBeforeMatch);
524 if (Tok.is(tok::greater))
525 ConsumeToken();
526 } else if (ParseGreaterThanInTemplateList(lAngleLoc, rAngleLoc,
527 /*ConsumeLastToken=*/true,
528 /*ObjCGenericList=*/true)) {
529 SkipUntil({tok::greater, tok::greaterequal, tok::at, tok::minus,
530 tok::minus, tok::plus, tok::colon, tok::l_paren, tok::l_brace,
531 tok::comma, tok::semi },
532 StopBeforeMatch);
533 if (Tok.is(tok::greater))
534 ConsumeToken();
535 }
536
537 if (mayBeProtocolList) {
538 // A type parameter list must be followed by either a ':' (indicating the
539 // presence of a superclass) or a '(' (indicating that this is a category
540 // or extension). This disambiguates between an objc-type-parameter-list
541 // and a objc-protocol-refs.
542 if (Tok.isNot(tok::colon) && Tok.isNot(tok::l_paren)) {
543 // Returning null indicates that we don't have a type parameter list.
544 // The results the caller needs to handle the protocol references are
545 // captured in the reference parameters already.
546 return nullptr;
547 }
548
549 // We have a type parameter list that looks like a list of protocol
550 // references. Turn that parameter list into type parameters.
551 makeProtocolIdentsIntoTypeParameters();
552 }
553
554 // Form the type parameter list and enter its scope.
555 ObjCTypeParamList *list = Actions.actOnObjCTypeParamList(
556 getCurScope(),
557 lAngleLoc,
558 typeParams,
559 rAngleLoc);
560 Scope.enter(list);
561
562 // Clear out the angle locations; they're used by the caller to indicate
563 // whether there are any protocol references.
564 lAngleLoc = SourceLocation();
565 rAngleLoc = SourceLocation();
566 return invalid ? nullptr : list;
567 }
568
569 /// Parse an objc-type-parameter-list.
parseObjCTypeParamList()570 ObjCTypeParamList *Parser::parseObjCTypeParamList() {
571 SourceLocation lAngleLoc;
572 SmallVector<IdentifierLocPair, 1> protocolIdents;
573 SourceLocation rAngleLoc;
574
575 ObjCTypeParamListScope Scope(Actions, getCurScope());
576 return parseObjCTypeParamListOrProtocolRefs(Scope, lAngleLoc, protocolIdents,
577 rAngleLoc,
578 /*mayBeProtocolList=*/false);
579 }
580
581 /// objc-interface-decl-list:
582 /// empty
583 /// objc-interface-decl-list objc-property-decl [OBJC2]
584 /// objc-interface-decl-list objc-method-requirement [OBJC2]
585 /// objc-interface-decl-list objc-method-proto ';'
586 /// objc-interface-decl-list declaration
587 /// objc-interface-decl-list ';'
588 ///
589 /// objc-method-requirement: [OBJC2]
590 /// @required
591 /// @optional
592 ///
ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey,Decl * CDecl)593 void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey,
594 Decl *CDecl) {
595 SmallVector<Decl *, 32> allMethods;
596 SmallVector<DeclGroupPtrTy, 8> allTUVariables;
597 tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword;
598
599 SourceRange AtEnd;
600
601 while (1) {
602 // If this is a method prototype, parse it.
603 if (Tok.isOneOf(tok::minus, tok::plus)) {
604 if (Decl *methodPrototype =
605 ParseObjCMethodPrototype(MethodImplKind, false))
606 allMethods.push_back(methodPrototype);
607 // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for
608 // method definitions.
609 if (ExpectAndConsumeSemi(diag::err_expected_semi_after_method_proto)) {
610 // We didn't find a semi and we error'ed out. Skip until a ';' or '@'.
611 SkipUntil(tok::at, StopAtSemi | StopBeforeMatch);
612 if (Tok.is(tok::semi))
613 ConsumeToken();
614 }
615 continue;
616 }
617 if (Tok.is(tok::l_paren)) {
618 Diag(Tok, diag::err_expected_minus_or_plus);
619 ParseObjCMethodDecl(Tok.getLocation(),
620 tok::minus,
621 MethodImplKind, false);
622 continue;
623 }
624 // Ignore excess semicolons.
625 if (Tok.is(tok::semi)) {
626 // FIXME: This should use ConsumeExtraSemi() for extraneous semicolons,
627 // to make -Wextra-semi diagnose them.
628 ConsumeToken();
629 continue;
630 }
631
632 // If we got to the end of the file, exit the loop.
633 if (isEofOrEom())
634 break;
635
636 // Code completion within an Objective-C interface.
637 if (Tok.is(tok::code_completion)) {
638 Actions.CodeCompleteOrdinaryName(getCurScope(),
639 CurParsedObjCImpl? Sema::PCC_ObjCImplementation
640 : Sema::PCC_ObjCInterface);
641 return cutOffParsing();
642 }
643
644 // If we don't have an @ directive, parse it as a function definition.
645 if (Tok.isNot(tok::at)) {
646 // The code below does not consume '}'s because it is afraid of eating the
647 // end of a namespace. Because of the way this code is structured, an
648 // erroneous r_brace would cause an infinite loop if not handled here.
649 if (Tok.is(tok::r_brace))
650 break;
651
652 ParsedAttributesWithRange attrs(AttrFactory);
653
654 // Since we call ParseDeclarationOrFunctionDefinition() instead of
655 // ParseExternalDeclaration() below (so that this doesn't parse nested
656 // @interfaces), this needs to duplicate some code from the latter.
657 if (Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert)) {
658 SourceLocation DeclEnd;
659 allTUVariables.push_back(
660 ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs));
661 continue;
662 }
663
664 allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs));
665 continue;
666 }
667
668 // Otherwise, we have an @ directive, eat the @.
669 SourceLocation AtLoc = ConsumeToken(); // the "@"
670 if (Tok.is(tok::code_completion)) {
671 Actions.CodeCompleteObjCAtDirective(getCurScope());
672 return cutOffParsing();
673 }
674
675 tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID();
676
677 if (DirectiveKind == tok::objc_end) { // @end -> terminate list
678 AtEnd.setBegin(AtLoc);
679 AtEnd.setEnd(Tok.getLocation());
680 break;
681 } else if (DirectiveKind == tok::objc_not_keyword) {
682 Diag(Tok, diag::err_objc_unknown_at);
683 SkipUntil(tok::semi);
684 continue;
685 }
686
687 // Eat the identifier.
688 ConsumeToken();
689
690 switch (DirectiveKind) {
691 default:
692 // FIXME: If someone forgets an @end on a protocol, this loop will
693 // continue to eat up tons of stuff and spew lots of nonsense errors. It
694 // would probably be better to bail out if we saw an @class or @interface
695 // or something like that.
696 Diag(AtLoc, diag::err_objc_illegal_interface_qual);
697 // Skip until we see an '@' or '}' or ';'.
698 SkipUntil(tok::r_brace, tok::at, StopAtSemi);
699 break;
700
701 case tok::objc_implementation:
702 case tok::objc_interface:
703 Diag(AtLoc, diag::err_objc_missing_end)
704 << FixItHint::CreateInsertion(AtLoc, "@end\n");
705 Diag(CDecl->getBeginLoc(), diag::note_objc_container_start)
706 << (int)Actions.getObjCContainerKind();
707 ConsumeToken();
708 break;
709
710 case tok::objc_required:
711 case tok::objc_optional:
712 // This is only valid on protocols.
713 if (contextKey != tok::objc_protocol)
714 Diag(AtLoc, diag::err_objc_directive_only_in_protocol);
715 else
716 MethodImplKind = DirectiveKind;
717 break;
718
719 case tok::objc_property:
720 ObjCDeclSpec OCDS;
721 SourceLocation LParenLoc;
722 // Parse property attribute list, if any.
723 if (Tok.is(tok::l_paren)) {
724 LParenLoc = Tok.getLocation();
725 ParseObjCPropertyAttribute(OCDS);
726 }
727
728 bool addedToDeclSpec = false;
729 auto ObjCPropertyCallback = [&](ParsingFieldDeclarator &FD) {
730 if (FD.D.getIdentifier() == nullptr) {
731 Diag(AtLoc, diag::err_objc_property_requires_field_name)
732 << FD.D.getSourceRange();
733 return;
734 }
735 if (FD.BitfieldSize) {
736 Diag(AtLoc, diag::err_objc_property_bitfield)
737 << FD.D.getSourceRange();
738 return;
739 }
740
741 // Map a nullability property attribute to a context-sensitive keyword
742 // attribute.
743 if (OCDS.getPropertyAttributes() &
744 ObjCPropertyAttribute::kind_nullability)
745 addContextSensitiveTypeNullability(*this, FD.D, OCDS.getNullability(),
746 OCDS.getNullabilityLoc(),
747 addedToDeclSpec);
748
749 // Install the property declarator into interfaceDecl.
750 IdentifierInfo *SelName =
751 OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier();
752
753 Selector GetterSel = PP.getSelectorTable().getNullarySelector(SelName);
754 IdentifierInfo *SetterName = OCDS.getSetterName();
755 Selector SetterSel;
756 if (SetterName)
757 SetterSel = PP.getSelectorTable().getSelector(1, &SetterName);
758 else
759 SetterSel = SelectorTable::constructSetterSelector(
760 PP.getIdentifierTable(), PP.getSelectorTable(),
761 FD.D.getIdentifier());
762 Decl *Property = Actions.ActOnProperty(
763 getCurScope(), AtLoc, LParenLoc, FD, OCDS, GetterSel, SetterSel,
764 MethodImplKind);
765
766 FD.complete(Property);
767 };
768
769 // Parse all the comma separated declarators.
770 ParsingDeclSpec DS(*this);
771 ParseStructDeclaration(DS, ObjCPropertyCallback);
772
773 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
774 break;
775 }
776 }
777
778 // We break out of the big loop in two cases: when we see @end or when we see
779 // EOF. In the former case, eat the @end. In the later case, emit an error.
780 if (Tok.is(tok::code_completion)) {
781 Actions.CodeCompleteObjCAtDirective(getCurScope());
782 return cutOffParsing();
783 } else if (Tok.isObjCAtKeyword(tok::objc_end)) {
784 ConsumeToken(); // the "end" identifier
785 } else {
786 Diag(Tok, diag::err_objc_missing_end)
787 << FixItHint::CreateInsertion(Tok.getLocation(), "\n@end\n");
788 Diag(CDecl->getBeginLoc(), diag::note_objc_container_start)
789 << (int)Actions.getObjCContainerKind();
790 AtEnd.setBegin(Tok.getLocation());
791 AtEnd.setEnd(Tok.getLocation());
792 }
793
794 // Insert collected methods declarations into the @interface object.
795 // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit.
796 Actions.ActOnAtEnd(getCurScope(), AtEnd, allMethods, allTUVariables);
797 }
798
799 /// Diagnose redundant or conflicting nullability information.
diagnoseRedundantPropertyNullability(Parser & P,ObjCDeclSpec & DS,NullabilityKind nullability,SourceLocation nullabilityLoc)800 static void diagnoseRedundantPropertyNullability(Parser &P,
801 ObjCDeclSpec &DS,
802 NullabilityKind nullability,
803 SourceLocation nullabilityLoc){
804 if (DS.getNullability() == nullability) {
805 P.Diag(nullabilityLoc, diag::warn_nullability_duplicate)
806 << DiagNullabilityKind(nullability, true)
807 << SourceRange(DS.getNullabilityLoc());
808 return;
809 }
810
811 P.Diag(nullabilityLoc, diag::err_nullability_conflicting)
812 << DiagNullabilityKind(nullability, true)
813 << DiagNullabilityKind(DS.getNullability(), true)
814 << SourceRange(DS.getNullabilityLoc());
815 }
816
817 /// Parse property attribute declarations.
818 ///
819 /// property-attr-decl: '(' property-attrlist ')'
820 /// property-attrlist:
821 /// property-attribute
822 /// property-attrlist ',' property-attribute
823 /// property-attribute:
824 /// getter '=' identifier
825 /// setter '=' identifier ':'
826 /// direct
827 /// readonly
828 /// readwrite
829 /// assign
830 /// retain
831 /// copy
832 /// nonatomic
833 /// atomic
834 /// strong
835 /// weak
836 /// unsafe_unretained
837 /// nonnull
838 /// nullable
839 /// null_unspecified
840 /// null_resettable
841 /// class
842 ///
ParseObjCPropertyAttribute(ObjCDeclSpec & DS)843 void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) {
844 assert(Tok.getKind() == tok::l_paren);
845 BalancedDelimiterTracker T(*this, tok::l_paren);
846 T.consumeOpen();
847
848 while (1) {
849 if (Tok.is(tok::code_completion)) {
850 Actions.CodeCompleteObjCPropertyFlags(getCurScope(), DS);
851 return cutOffParsing();
852 }
853 const IdentifierInfo *II = Tok.getIdentifierInfo();
854
855 // If this is not an identifier at all, bail out early.
856 if (!II) {
857 T.consumeClose();
858 return;
859 }
860
861 SourceLocation AttrName = ConsumeToken(); // consume last attribute name
862
863 if (II->isStr("readonly"))
864 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_readonly);
865 else if (II->isStr("assign"))
866 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_assign);
867 else if (II->isStr("unsafe_unretained"))
868 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_unsafe_unretained);
869 else if (II->isStr("readwrite"))
870 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_readwrite);
871 else if (II->isStr("retain"))
872 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_retain);
873 else if (II->isStr("strong"))
874 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_strong);
875 else if (II->isStr("copy"))
876 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_copy);
877 else if (II->isStr("nonatomic"))
878 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nonatomic);
879 else if (II->isStr("atomic"))
880 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_atomic);
881 else if (II->isStr("weak"))
882 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_weak);
883 else if (II->isStr("getter") || II->isStr("setter")) {
884 bool IsSetter = II->getNameStart()[0] == 's';
885
886 // getter/setter require extra treatment.
887 unsigned DiagID = IsSetter ? diag::err_objc_expected_equal_for_setter :
888 diag::err_objc_expected_equal_for_getter;
889
890 if (ExpectAndConsume(tok::equal, DiagID)) {
891 SkipUntil(tok::r_paren, StopAtSemi);
892 return;
893 }
894
895 if (Tok.is(tok::code_completion)) {
896 if (IsSetter)
897 Actions.CodeCompleteObjCPropertySetter(getCurScope());
898 else
899 Actions.CodeCompleteObjCPropertyGetter(getCurScope());
900 return cutOffParsing();
901 }
902
903 SourceLocation SelLoc;
904 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(SelLoc);
905
906 if (!SelIdent) {
907 Diag(Tok, diag::err_objc_expected_selector_for_getter_setter)
908 << IsSetter;
909 SkipUntil(tok::r_paren, StopAtSemi);
910 return;
911 }
912
913 if (IsSetter) {
914 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_setter);
915 DS.setSetterName(SelIdent, SelLoc);
916
917 if (ExpectAndConsume(tok::colon,
918 diag::err_expected_colon_after_setter_name)) {
919 SkipUntil(tok::r_paren, StopAtSemi);
920 return;
921 }
922 } else {
923 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_getter);
924 DS.setGetterName(SelIdent, SelLoc);
925 }
926 } else if (II->isStr("nonnull")) {
927 if (DS.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)
928 diagnoseRedundantPropertyNullability(*this, DS,
929 NullabilityKind::NonNull,
930 Tok.getLocation());
931 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability);
932 DS.setNullability(Tok.getLocation(), NullabilityKind::NonNull);
933 } else if (II->isStr("nullable")) {
934 if (DS.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)
935 diagnoseRedundantPropertyNullability(*this, DS,
936 NullabilityKind::Nullable,
937 Tok.getLocation());
938 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability);
939 DS.setNullability(Tok.getLocation(), NullabilityKind::Nullable);
940 } else if (II->isStr("null_unspecified")) {
941 if (DS.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)
942 diagnoseRedundantPropertyNullability(*this, DS,
943 NullabilityKind::Unspecified,
944 Tok.getLocation());
945 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability);
946 DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified);
947 } else if (II->isStr("null_resettable")) {
948 if (DS.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)
949 diagnoseRedundantPropertyNullability(*this, DS,
950 NullabilityKind::Unspecified,
951 Tok.getLocation());
952 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability);
953 DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified);
954
955 // Also set the null_resettable bit.
956 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_null_resettable);
957 } else if (II->isStr("class")) {
958 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_class);
959 } else if (II->isStr("direct")) {
960 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_direct);
961 } else {
962 Diag(AttrName, diag::err_objc_expected_property_attr) << II;
963 SkipUntil(tok::r_paren, StopAtSemi);
964 return;
965 }
966
967 if (Tok.isNot(tok::comma))
968 break;
969
970 ConsumeToken();
971 }
972
973 T.consumeClose();
974 }
975
976 /// objc-method-proto:
977 /// objc-instance-method objc-method-decl objc-method-attributes[opt]
978 /// objc-class-method objc-method-decl objc-method-attributes[opt]
979 ///
980 /// objc-instance-method: '-'
981 /// objc-class-method: '+'
982 ///
983 /// objc-method-attributes: [OBJC2]
984 /// __attribute__((deprecated))
985 ///
ParseObjCMethodPrototype(tok::ObjCKeywordKind MethodImplKind,bool MethodDefinition)986 Decl *Parser::ParseObjCMethodPrototype(tok::ObjCKeywordKind MethodImplKind,
987 bool MethodDefinition) {
988 assert(Tok.isOneOf(tok::minus, tok::plus) && "expected +/-");
989
990 tok::TokenKind methodType = Tok.getKind();
991 SourceLocation mLoc = ConsumeToken();
992 Decl *MDecl = ParseObjCMethodDecl(mLoc, methodType, MethodImplKind,
993 MethodDefinition);
994 // Since this rule is used for both method declarations and definitions,
995 // the caller is (optionally) responsible for consuming the ';'.
996 return MDecl;
997 }
998
999 /// objc-selector:
1000 /// identifier
1001 /// one of
1002 /// enum struct union if else while do for switch case default
1003 /// break continue return goto asm sizeof typeof __alignof
1004 /// unsigned long const short volatile signed restrict _Complex
1005 /// in out inout bycopy byref oneway int char float double void _Bool
1006 ///
ParseObjCSelectorPiece(SourceLocation & SelectorLoc)1007 IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) {
1008
1009 switch (Tok.getKind()) {
1010 default:
1011 return nullptr;
1012 case tok::colon:
1013 // Empty selector piece uses the location of the ':'.
1014 SelectorLoc = Tok.getLocation();
1015 return nullptr;
1016 case tok::ampamp:
1017 case tok::ampequal:
1018 case tok::amp:
1019 case tok::pipe:
1020 case tok::tilde:
1021 case tok::exclaim:
1022 case tok::exclaimequal:
1023 case tok::pipepipe:
1024 case tok::pipeequal:
1025 case tok::caret:
1026 case tok::caretequal: {
1027 std::string ThisTok(PP.getSpelling(Tok));
1028 if (isLetter(ThisTok[0])) {
1029 IdentifierInfo *II = &PP.getIdentifierTable().get(ThisTok);
1030 Tok.setKind(tok::identifier);
1031 SelectorLoc = ConsumeToken();
1032 return II;
1033 }
1034 return nullptr;
1035 }
1036
1037 case tok::identifier:
1038 case tok::kw_asm:
1039 case tok::kw_auto:
1040 case tok::kw_bool:
1041 case tok::kw_break:
1042 case tok::kw_case:
1043 case tok::kw_catch:
1044 case tok::kw_char:
1045 case tok::kw_class:
1046 case tok::kw_const:
1047 case tok::kw_const_cast:
1048 case tok::kw_continue:
1049 case tok::kw_default:
1050 case tok::kw_delete:
1051 case tok::kw_do:
1052 case tok::kw_double:
1053 case tok::kw_dynamic_cast:
1054 case tok::kw_else:
1055 case tok::kw_enum:
1056 case tok::kw_explicit:
1057 case tok::kw_export:
1058 case tok::kw_extern:
1059 case tok::kw_false:
1060 case tok::kw_float:
1061 case tok::kw_for:
1062 case tok::kw_friend:
1063 case tok::kw_goto:
1064 case tok::kw_if:
1065 case tok::kw_inline:
1066 case tok::kw_int:
1067 case tok::kw_long:
1068 case tok::kw_mutable:
1069 case tok::kw_namespace:
1070 case tok::kw_new:
1071 case tok::kw_operator:
1072 case tok::kw_private:
1073 case tok::kw_protected:
1074 case tok::kw_public:
1075 case tok::kw_register:
1076 case tok::kw_reinterpret_cast:
1077 case tok::kw_restrict:
1078 case tok::kw_return:
1079 case tok::kw_short:
1080 case tok::kw_signed:
1081 case tok::kw_sizeof:
1082 case tok::kw_static:
1083 case tok::kw_static_cast:
1084 case tok::kw_struct:
1085 case tok::kw_switch:
1086 case tok::kw_template:
1087 case tok::kw_this:
1088 case tok::kw_throw:
1089 case tok::kw_true:
1090 case tok::kw_try:
1091 case tok::kw_typedef:
1092 case tok::kw_typeid:
1093 case tok::kw_typename:
1094 case tok::kw_typeof:
1095 case tok::kw_union:
1096 case tok::kw_unsigned:
1097 case tok::kw_using:
1098 case tok::kw_virtual:
1099 case tok::kw_void:
1100 case tok::kw_volatile:
1101 case tok::kw_wchar_t:
1102 case tok::kw_while:
1103 case tok::kw__Bool:
1104 case tok::kw__Complex:
1105 case tok::kw___alignof:
1106 case tok::kw___auto_type:
1107 IdentifierInfo *II = Tok.getIdentifierInfo();
1108 SelectorLoc = ConsumeToken();
1109 return II;
1110 }
1111 }
1112
1113 /// objc-for-collection-in: 'in'
1114 ///
isTokIdentifier_in() const1115 bool Parser::isTokIdentifier_in() const {
1116 // FIXME: May have to do additional look-ahead to only allow for
1117 // valid tokens following an 'in'; such as an identifier, unary operators,
1118 // '[' etc.
1119 return (getLangOpts().ObjC && Tok.is(tok::identifier) &&
1120 Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]);
1121 }
1122
1123 /// ParseObjCTypeQualifierList - This routine parses the objective-c's type
1124 /// qualifier list and builds their bitmask representation in the input
1125 /// argument.
1126 ///
1127 /// objc-type-qualifiers:
1128 /// objc-type-qualifier
1129 /// objc-type-qualifiers objc-type-qualifier
1130 ///
1131 /// objc-type-qualifier:
1132 /// 'in'
1133 /// 'out'
1134 /// 'inout'
1135 /// 'oneway'
1136 /// 'bycopy'
1137 /// 'byref'
1138 /// 'nonnull'
1139 /// 'nullable'
1140 /// 'null_unspecified'
1141 ///
ParseObjCTypeQualifierList(ObjCDeclSpec & DS,DeclaratorContext Context)1142 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS,
1143 DeclaratorContext Context) {
1144 assert(Context == DeclaratorContext::ObjCParameterContext ||
1145 Context == DeclaratorContext::ObjCResultContext);
1146
1147 while (1) {
1148 if (Tok.is(tok::code_completion)) {
1149 Actions.CodeCompleteObjCPassingType(getCurScope(), DS,
1150 Context == DeclaratorContext::ObjCParameterContext);
1151 return cutOffParsing();
1152 }
1153
1154 if (Tok.isNot(tok::identifier))
1155 return;
1156
1157 const IdentifierInfo *II = Tok.getIdentifierInfo();
1158 for (unsigned i = 0; i != objc_NumQuals; ++i) {
1159 if (II != ObjCTypeQuals[i] ||
1160 NextToken().is(tok::less) ||
1161 NextToken().is(tok::coloncolon))
1162 continue;
1163
1164 ObjCDeclSpec::ObjCDeclQualifier Qual;
1165 NullabilityKind Nullability;
1166 switch (i) {
1167 default: llvm_unreachable("Unknown decl qualifier");
1168 case objc_in: Qual = ObjCDeclSpec::DQ_In; break;
1169 case objc_out: Qual = ObjCDeclSpec::DQ_Out; break;
1170 case objc_inout: Qual = ObjCDeclSpec::DQ_Inout; break;
1171 case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break;
1172 case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break;
1173 case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break;
1174
1175 case objc_nonnull:
1176 Qual = ObjCDeclSpec::DQ_CSNullability;
1177 Nullability = NullabilityKind::NonNull;
1178 break;
1179
1180 case objc_nullable:
1181 Qual = ObjCDeclSpec::DQ_CSNullability;
1182 Nullability = NullabilityKind::Nullable;
1183 break;
1184
1185 case objc_null_unspecified:
1186 Qual = ObjCDeclSpec::DQ_CSNullability;
1187 Nullability = NullabilityKind::Unspecified;
1188 break;
1189 }
1190
1191 // FIXME: Diagnose redundant specifiers.
1192 DS.setObjCDeclQualifier(Qual);
1193 if (Qual == ObjCDeclSpec::DQ_CSNullability)
1194 DS.setNullability(Tok.getLocation(), Nullability);
1195
1196 ConsumeToken();
1197 II = nullptr;
1198 break;
1199 }
1200
1201 // If this wasn't a recognized qualifier, bail out.
1202 if (II) return;
1203 }
1204 }
1205
1206 /// Take all the decl attributes out of the given list and add
1207 /// them to the given attribute set.
takeDeclAttributes(ParsedAttributesView & attrs,ParsedAttributesView & from)1208 static void takeDeclAttributes(ParsedAttributesView &attrs,
1209 ParsedAttributesView &from) {
1210 for (auto &AL : llvm::reverse(from)) {
1211 if (!AL.isUsedAsTypeAttr()) {
1212 from.remove(&AL);
1213 attrs.addAtEnd(&AL);
1214 }
1215 }
1216 }
1217
1218 /// takeDeclAttributes - Take all the decl attributes from the given
1219 /// declarator and add them to the given list.
takeDeclAttributes(ParsedAttributes & attrs,Declarator & D)1220 static void takeDeclAttributes(ParsedAttributes &attrs,
1221 Declarator &D) {
1222 // First, take ownership of all attributes.
1223 attrs.getPool().takeAllFrom(D.getAttributePool());
1224 attrs.getPool().takeAllFrom(D.getDeclSpec().getAttributePool());
1225
1226 // Now actually move the attributes over.
1227 takeDeclAttributes(attrs, D.getMutableDeclSpec().getAttributes());
1228 takeDeclAttributes(attrs, D.getAttributes());
1229 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
1230 takeDeclAttributes(attrs, D.getTypeObject(i).getAttrs());
1231 }
1232
1233 /// objc-type-name:
1234 /// '(' objc-type-qualifiers[opt] type-name ')'
1235 /// '(' objc-type-qualifiers[opt] ')'
1236 ///
ParseObjCTypeName(ObjCDeclSpec & DS,DeclaratorContext context,ParsedAttributes * paramAttrs)1237 ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS,
1238 DeclaratorContext context,
1239 ParsedAttributes *paramAttrs) {
1240 assert(context == DeclaratorContext::ObjCParameterContext ||
1241 context == DeclaratorContext::ObjCResultContext);
1242 assert((paramAttrs != nullptr) ==
1243 (context == DeclaratorContext::ObjCParameterContext));
1244
1245 assert(Tok.is(tok::l_paren) && "expected (");
1246
1247 BalancedDelimiterTracker T(*this, tok::l_paren);
1248 T.consumeOpen();
1249
1250 ObjCDeclContextSwitch ObjCDC(*this);
1251
1252 // Parse type qualifiers, in, inout, etc.
1253 ParseObjCTypeQualifierList(DS, context);
1254 SourceLocation TypeStartLoc = Tok.getLocation();
1255
1256 ParsedType Ty;
1257 if (isTypeSpecifierQualifier() || isObjCInstancetype()) {
1258 // Parse an abstract declarator.
1259 DeclSpec declSpec(AttrFactory);
1260 declSpec.setObjCQualifiers(&DS);
1261 DeclSpecContext dsContext = DeclSpecContext::DSC_normal;
1262 if (context == DeclaratorContext::ObjCResultContext)
1263 dsContext = DeclSpecContext::DSC_objc_method_result;
1264 ParseSpecifierQualifierList(declSpec, AS_none, dsContext);
1265 Declarator declarator(declSpec, context);
1266 ParseDeclarator(declarator);
1267
1268 // If that's not invalid, extract a type.
1269 if (!declarator.isInvalidType()) {
1270 // Map a nullability specifier to a context-sensitive keyword attribute.
1271 bool addedToDeclSpec = false;
1272 if (DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability)
1273 addContextSensitiveTypeNullability(*this, declarator,
1274 DS.getNullability(),
1275 DS.getNullabilityLoc(),
1276 addedToDeclSpec);
1277
1278 TypeResult type = Actions.ActOnTypeName(getCurScope(), declarator);
1279 if (!type.isInvalid())
1280 Ty = type.get();
1281
1282 // If we're parsing a parameter, steal all the decl attributes
1283 // and add them to the decl spec.
1284 if (context == DeclaratorContext::ObjCParameterContext)
1285 takeDeclAttributes(*paramAttrs, declarator);
1286 }
1287 }
1288
1289 if (Tok.is(tok::r_paren))
1290 T.consumeClose();
1291 else if (Tok.getLocation() == TypeStartLoc) {
1292 // If we didn't eat any tokens, then this isn't a type.
1293 Diag(Tok, diag::err_expected_type);
1294 SkipUntil(tok::r_paren, StopAtSemi);
1295 } else {
1296 // Otherwise, we found *something*, but didn't get a ')' in the right
1297 // place. Emit an error then return what we have as the type.
1298 T.consumeClose();
1299 }
1300 return Ty;
1301 }
1302
1303 /// objc-method-decl:
1304 /// objc-selector
1305 /// objc-keyword-selector objc-parmlist[opt]
1306 /// objc-type-name objc-selector
1307 /// objc-type-name objc-keyword-selector objc-parmlist[opt]
1308 ///
1309 /// objc-keyword-selector:
1310 /// objc-keyword-decl
1311 /// objc-keyword-selector objc-keyword-decl
1312 ///
1313 /// objc-keyword-decl:
1314 /// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier
1315 /// objc-selector ':' objc-keyword-attributes[opt] identifier
1316 /// ':' objc-type-name objc-keyword-attributes[opt] identifier
1317 /// ':' objc-keyword-attributes[opt] identifier
1318 ///
1319 /// objc-parmlist:
1320 /// objc-parms objc-ellipsis[opt]
1321 ///
1322 /// objc-parms:
1323 /// objc-parms , parameter-declaration
1324 ///
1325 /// objc-ellipsis:
1326 /// , ...
1327 ///
1328 /// objc-keyword-attributes: [OBJC2]
1329 /// __attribute__((unused))
1330 ///
ParseObjCMethodDecl(SourceLocation mLoc,tok::TokenKind mType,tok::ObjCKeywordKind MethodImplKind,bool MethodDefinition)1331 Decl *Parser::ParseObjCMethodDecl(SourceLocation mLoc,
1332 tok::TokenKind mType,
1333 tok::ObjCKeywordKind MethodImplKind,
1334 bool MethodDefinition) {
1335 ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent);
1336
1337 if (Tok.is(tok::code_completion)) {
1338 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
1339 /*ReturnType=*/nullptr);
1340 cutOffParsing();
1341 return nullptr;
1342 }
1343
1344 // Parse the return type if present.
1345 ParsedType ReturnType;
1346 ObjCDeclSpec DSRet;
1347 if (Tok.is(tok::l_paren))
1348 ReturnType = ParseObjCTypeName(DSRet, DeclaratorContext::ObjCResultContext,
1349 nullptr);
1350
1351 // If attributes exist before the method, parse them.
1352 ParsedAttributes methodAttrs(AttrFactory);
1353 if (getLangOpts().ObjC)
1354 MaybeParseGNUAttributes(methodAttrs);
1355 MaybeParseCXX11Attributes(methodAttrs);
1356
1357 if (Tok.is(tok::code_completion)) {
1358 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
1359 ReturnType);
1360 cutOffParsing();
1361 return nullptr;
1362 }
1363
1364 // Now parse the selector.
1365 SourceLocation selLoc;
1366 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(selLoc);
1367
1368 // An unnamed colon is valid.
1369 if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name.
1370 Diag(Tok, diag::err_expected_selector_for_method)
1371 << SourceRange(mLoc, Tok.getLocation());
1372 // Skip until we get a ; or @.
1373 SkipUntil(tok::at, StopAtSemi | StopBeforeMatch);
1374 return nullptr;
1375 }
1376
1377 SmallVector<DeclaratorChunk::ParamInfo, 8> CParamInfo;
1378 if (Tok.isNot(tok::colon)) {
1379 // If attributes exist after the method, parse them.
1380 if (getLangOpts().ObjC)
1381 MaybeParseGNUAttributes(methodAttrs);
1382 MaybeParseCXX11Attributes(methodAttrs);
1383
1384 Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent);
1385 Decl *Result = Actions.ActOnMethodDeclaration(
1386 getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType,
1387 selLoc, Sel, nullptr, CParamInfo.data(), CParamInfo.size(), methodAttrs,
1388 MethodImplKind, false, MethodDefinition);
1389 PD.complete(Result);
1390 return Result;
1391 }
1392
1393 SmallVector<IdentifierInfo *, 12> KeyIdents;
1394 SmallVector<SourceLocation, 12> KeyLocs;
1395 SmallVector<Sema::ObjCArgInfo, 12> ArgInfos;
1396 ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
1397 Scope::FunctionDeclarationScope | Scope::DeclScope);
1398
1399 AttributePool allParamAttrs(AttrFactory);
1400 while (1) {
1401 ParsedAttributes paramAttrs(AttrFactory);
1402 Sema::ObjCArgInfo ArgInfo;
1403
1404 // Each iteration parses a single keyword argument.
1405 if (ExpectAndConsume(tok::colon))
1406 break;
1407
1408 ArgInfo.Type = nullptr;
1409 if (Tok.is(tok::l_paren)) // Parse the argument type if present.
1410 ArgInfo.Type = ParseObjCTypeName(ArgInfo.DeclSpec,
1411 DeclaratorContext::ObjCParameterContext,
1412 ¶mAttrs);
1413
1414 // If attributes exist before the argument name, parse them.
1415 // Regardless, collect all the attributes we've parsed so far.
1416 if (getLangOpts().ObjC)
1417 MaybeParseGNUAttributes(paramAttrs);
1418 MaybeParseCXX11Attributes(paramAttrs);
1419 ArgInfo.ArgAttrs = paramAttrs;
1420
1421 // Code completion for the next piece of the selector.
1422 if (Tok.is(tok::code_completion)) {
1423 KeyIdents.push_back(SelIdent);
1424 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
1425 mType == tok::minus,
1426 /*AtParameterName=*/true,
1427 ReturnType, KeyIdents);
1428 cutOffParsing();
1429 return nullptr;
1430 }
1431
1432 if (expectIdentifier())
1433 break; // missing argument name.
1434
1435 ArgInfo.Name = Tok.getIdentifierInfo();
1436 ArgInfo.NameLoc = Tok.getLocation();
1437 ConsumeToken(); // Eat the identifier.
1438
1439 ArgInfos.push_back(ArgInfo);
1440 KeyIdents.push_back(SelIdent);
1441 KeyLocs.push_back(selLoc);
1442
1443 // Make sure the attributes persist.
1444 allParamAttrs.takeAllFrom(paramAttrs.getPool());
1445
1446 // Code completion for the next piece of the selector.
1447 if (Tok.is(tok::code_completion)) {
1448 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
1449 mType == tok::minus,
1450 /*AtParameterName=*/false,
1451 ReturnType, KeyIdents);
1452 cutOffParsing();
1453 return nullptr;
1454 }
1455
1456 // Check for another keyword selector.
1457 SelIdent = ParseObjCSelectorPiece(selLoc);
1458 if (!SelIdent && Tok.isNot(tok::colon))
1459 break;
1460 if (!SelIdent) {
1461 SourceLocation ColonLoc = Tok.getLocation();
1462 if (PP.getLocForEndOfToken(ArgInfo.NameLoc) == ColonLoc) {
1463 Diag(ArgInfo.NameLoc, diag::warn_missing_selector_name) << ArgInfo.Name;
1464 Diag(ArgInfo.NameLoc, diag::note_missing_selector_name) << ArgInfo.Name;
1465 Diag(ColonLoc, diag::note_force_empty_selector_name) << ArgInfo.Name;
1466 }
1467 }
1468 // We have a selector or a colon, continue parsing.
1469 }
1470
1471 bool isVariadic = false;
1472 bool cStyleParamWarned = false;
1473 // Parse the (optional) parameter list.
1474 while (Tok.is(tok::comma)) {
1475 ConsumeToken();
1476 if (Tok.is(tok::ellipsis)) {
1477 isVariadic = true;
1478 ConsumeToken();
1479 break;
1480 }
1481 if (!cStyleParamWarned) {
1482 Diag(Tok, diag::warn_cstyle_param);
1483 cStyleParamWarned = true;
1484 }
1485 DeclSpec DS(AttrFactory);
1486 ParseDeclarationSpecifiers(DS);
1487 // Parse the declarator.
1488 Declarator ParmDecl(DS, DeclaratorContext::PrototypeContext);
1489 ParseDeclarator(ParmDecl);
1490 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
1491 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
1492 CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
1493 ParmDecl.getIdentifierLoc(),
1494 Param,
1495 nullptr));
1496 }
1497
1498 // FIXME: Add support for optional parameter list...
1499 // If attributes exist after the method, parse them.
1500 if (getLangOpts().ObjC)
1501 MaybeParseGNUAttributes(methodAttrs);
1502 MaybeParseCXX11Attributes(methodAttrs);
1503
1504 if (KeyIdents.size() == 0)
1505 return nullptr;
1506
1507 Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(),
1508 &KeyIdents[0]);
1509 Decl *Result = Actions.ActOnMethodDeclaration(
1510 getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType, KeyLocs,
1511 Sel, &ArgInfos[0], CParamInfo.data(), CParamInfo.size(), methodAttrs,
1512 MethodImplKind, isVariadic, MethodDefinition);
1513
1514 PD.complete(Result);
1515 return Result;
1516 }
1517
1518 /// objc-protocol-refs:
1519 /// '<' identifier-list '>'
1520 ///
1521 bool Parser::
ParseObjCProtocolReferences(SmallVectorImpl<Decl * > & Protocols,SmallVectorImpl<SourceLocation> & ProtocolLocs,bool WarnOnDeclarations,bool ForObjCContainer,SourceLocation & LAngleLoc,SourceLocation & EndLoc,bool consumeLastToken)1522 ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &Protocols,
1523 SmallVectorImpl<SourceLocation> &ProtocolLocs,
1524 bool WarnOnDeclarations, bool ForObjCContainer,
1525 SourceLocation &LAngleLoc, SourceLocation &EndLoc,
1526 bool consumeLastToken) {
1527 assert(Tok.is(tok::less) && "expected <");
1528
1529 LAngleLoc = ConsumeToken(); // the "<"
1530
1531 SmallVector<IdentifierLocPair, 8> ProtocolIdents;
1532
1533 while (1) {
1534 if (Tok.is(tok::code_completion)) {
1535 Actions.CodeCompleteObjCProtocolReferences(ProtocolIdents);
1536 cutOffParsing();
1537 return true;
1538 }
1539
1540 if (expectIdentifier()) {
1541 SkipUntil(tok::greater, StopAtSemi);
1542 return true;
1543 }
1544 ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(),
1545 Tok.getLocation()));
1546 ProtocolLocs.push_back(Tok.getLocation());
1547 ConsumeToken();
1548
1549 if (!TryConsumeToken(tok::comma))
1550 break;
1551 }
1552
1553 // Consume the '>'.
1554 if (ParseGreaterThanInTemplateList(LAngleLoc, EndLoc, consumeLastToken,
1555 /*ObjCGenericList=*/false))
1556 return true;
1557
1558 // Convert the list of protocols identifiers into a list of protocol decls.
1559 Actions.FindProtocolDeclaration(WarnOnDeclarations, ForObjCContainer,
1560 ProtocolIdents, Protocols);
1561 return false;
1562 }
1563
parseObjCProtocolQualifierType(SourceLocation & rAngleLoc)1564 TypeResult Parser::parseObjCProtocolQualifierType(SourceLocation &rAngleLoc) {
1565 assert(Tok.is(tok::less) && "Protocol qualifiers start with '<'");
1566 assert(getLangOpts().ObjC && "Protocol qualifiers only exist in Objective-C");
1567
1568 SourceLocation lAngleLoc;
1569 SmallVector<Decl *, 8> protocols;
1570 SmallVector<SourceLocation, 8> protocolLocs;
1571 (void)ParseObjCProtocolReferences(protocols, protocolLocs, false, false,
1572 lAngleLoc, rAngleLoc,
1573 /*consumeLastToken=*/true);
1574 TypeResult result = Actions.actOnObjCProtocolQualifierType(lAngleLoc,
1575 protocols,
1576 protocolLocs,
1577 rAngleLoc);
1578 if (result.isUsable()) {
1579 Diag(lAngleLoc, diag::warn_objc_protocol_qualifier_missing_id)
1580 << FixItHint::CreateInsertion(lAngleLoc, "id")
1581 << SourceRange(lAngleLoc, rAngleLoc);
1582 }
1583
1584 return result;
1585 }
1586
1587 /// Parse Objective-C type arguments or protocol qualifiers.
1588 ///
1589 /// objc-type-arguments:
1590 /// '<' type-name '...'[opt] (',' type-name '...'[opt])* '>'
1591 ///
parseObjCTypeArgsOrProtocolQualifiers(ParsedType baseType,SourceLocation & typeArgsLAngleLoc,SmallVectorImpl<ParsedType> & typeArgs,SourceLocation & typeArgsRAngleLoc,SourceLocation & protocolLAngleLoc,SmallVectorImpl<Decl * > & protocols,SmallVectorImpl<SourceLocation> & protocolLocs,SourceLocation & protocolRAngleLoc,bool consumeLastToken,bool warnOnIncompleteProtocols)1592 void Parser::parseObjCTypeArgsOrProtocolQualifiers(
1593 ParsedType baseType,
1594 SourceLocation &typeArgsLAngleLoc,
1595 SmallVectorImpl<ParsedType> &typeArgs,
1596 SourceLocation &typeArgsRAngleLoc,
1597 SourceLocation &protocolLAngleLoc,
1598 SmallVectorImpl<Decl *> &protocols,
1599 SmallVectorImpl<SourceLocation> &protocolLocs,
1600 SourceLocation &protocolRAngleLoc,
1601 bool consumeLastToken,
1602 bool warnOnIncompleteProtocols) {
1603 assert(Tok.is(tok::less) && "Not at the start of type args or protocols");
1604 SourceLocation lAngleLoc = ConsumeToken();
1605
1606 // Whether all of the elements we've parsed thus far are single
1607 // identifiers, which might be types or might be protocols.
1608 bool allSingleIdentifiers = true;
1609 SmallVector<IdentifierInfo *, 4> identifiers;
1610 SmallVectorImpl<SourceLocation> &identifierLocs = protocolLocs;
1611
1612 // Parse a list of comma-separated identifiers, bailing out if we
1613 // see something different.
1614 do {
1615 // Parse a single identifier.
1616 if (Tok.is(tok::identifier) &&
1617 (NextToken().is(tok::comma) ||
1618 NextToken().is(tok::greater) ||
1619 NextToken().is(tok::greatergreater))) {
1620 identifiers.push_back(Tok.getIdentifierInfo());
1621 identifierLocs.push_back(ConsumeToken());
1622 continue;
1623 }
1624
1625 if (Tok.is(tok::code_completion)) {
1626 // FIXME: Also include types here.
1627 SmallVector<IdentifierLocPair, 4> identifierLocPairs;
1628 for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1629 identifierLocPairs.push_back(IdentifierLocPair(identifiers[i],
1630 identifierLocs[i]));
1631 }
1632
1633 QualType BaseT = Actions.GetTypeFromParser(baseType);
1634 if (!BaseT.isNull() && BaseT->acceptsObjCTypeParams()) {
1635 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
1636 } else {
1637 Actions.CodeCompleteObjCProtocolReferences(identifierLocPairs);
1638 }
1639 cutOffParsing();
1640 return;
1641 }
1642
1643 allSingleIdentifiers = false;
1644 break;
1645 } while (TryConsumeToken(tok::comma));
1646
1647 // If we parsed an identifier list, semantic analysis sorts out
1648 // whether it refers to protocols or to type arguments.
1649 if (allSingleIdentifiers) {
1650 // Parse the closing '>'.
1651 SourceLocation rAngleLoc;
1652 (void)ParseGreaterThanInTemplateList(lAngleLoc, rAngleLoc, consumeLastToken,
1653 /*ObjCGenericList=*/true);
1654
1655 // Let Sema figure out what we parsed.
1656 Actions.actOnObjCTypeArgsOrProtocolQualifiers(getCurScope(),
1657 baseType,
1658 lAngleLoc,
1659 identifiers,
1660 identifierLocs,
1661 rAngleLoc,
1662 typeArgsLAngleLoc,
1663 typeArgs,
1664 typeArgsRAngleLoc,
1665 protocolLAngleLoc,
1666 protocols,
1667 protocolRAngleLoc,
1668 warnOnIncompleteProtocols);
1669 return;
1670 }
1671
1672 // We parsed an identifier list but stumbled into non single identifiers, this
1673 // means we might (a) check that what we already parsed is a legitimate type
1674 // (not a protocol or unknown type) and (b) parse the remaining ones, which
1675 // must all be type args.
1676
1677 // Convert the identifiers into type arguments.
1678 bool invalid = false;
1679 IdentifierInfo *foundProtocolId = nullptr, *foundValidTypeId = nullptr;
1680 SourceLocation foundProtocolSrcLoc, foundValidTypeSrcLoc;
1681 SmallVector<IdentifierInfo *, 2> unknownTypeArgs;
1682 SmallVector<SourceLocation, 2> unknownTypeArgsLoc;
1683
1684 for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1685 ParsedType typeArg
1686 = Actions.getTypeName(*identifiers[i], identifierLocs[i], getCurScope());
1687 if (typeArg) {
1688 DeclSpec DS(AttrFactory);
1689 const char *prevSpec = nullptr;
1690 unsigned diagID;
1691 DS.SetTypeSpecType(TST_typename, identifierLocs[i], prevSpec, diagID,
1692 typeArg, Actions.getASTContext().getPrintingPolicy());
1693
1694 // Form a declarator to turn this into a type.
1695 Declarator D(DS, DeclaratorContext::TypeNameContext);
1696 TypeResult fullTypeArg = Actions.ActOnTypeName(getCurScope(), D);
1697 if (fullTypeArg.isUsable()) {
1698 typeArgs.push_back(fullTypeArg.get());
1699 if (!foundValidTypeId) {
1700 foundValidTypeId = identifiers[i];
1701 foundValidTypeSrcLoc = identifierLocs[i];
1702 }
1703 } else {
1704 invalid = true;
1705 unknownTypeArgs.push_back(identifiers[i]);
1706 unknownTypeArgsLoc.push_back(identifierLocs[i]);
1707 }
1708 } else {
1709 invalid = true;
1710 if (!Actions.LookupProtocol(identifiers[i], identifierLocs[i])) {
1711 unknownTypeArgs.push_back(identifiers[i]);
1712 unknownTypeArgsLoc.push_back(identifierLocs[i]);
1713 } else if (!foundProtocolId) {
1714 foundProtocolId = identifiers[i];
1715 foundProtocolSrcLoc = identifierLocs[i];
1716 }
1717 }
1718 }
1719
1720 // Continue parsing type-names.
1721 do {
1722 Token CurTypeTok = Tok;
1723 TypeResult typeArg = ParseTypeName();
1724
1725 // Consume the '...' for a pack expansion.
1726 SourceLocation ellipsisLoc;
1727 TryConsumeToken(tok::ellipsis, ellipsisLoc);
1728 if (typeArg.isUsable() && ellipsisLoc.isValid()) {
1729 typeArg = Actions.ActOnPackExpansion(typeArg.get(), ellipsisLoc);
1730 }
1731
1732 if (typeArg.isUsable()) {
1733 typeArgs.push_back(typeArg.get());
1734 if (!foundValidTypeId) {
1735 foundValidTypeId = CurTypeTok.getIdentifierInfo();
1736 foundValidTypeSrcLoc = CurTypeTok.getLocation();
1737 }
1738 } else {
1739 invalid = true;
1740 }
1741 } while (TryConsumeToken(tok::comma));
1742
1743 // Diagnose the mix between type args and protocols.
1744 if (foundProtocolId && foundValidTypeId)
1745 Actions.DiagnoseTypeArgsAndProtocols(foundProtocolId, foundProtocolSrcLoc,
1746 foundValidTypeId,
1747 foundValidTypeSrcLoc);
1748
1749 // Diagnose unknown arg types.
1750 ParsedType T;
1751 if (unknownTypeArgs.size())
1752 for (unsigned i = 0, e = unknownTypeArgsLoc.size(); i < e; ++i)
1753 Actions.DiagnoseUnknownTypeName(unknownTypeArgs[i], unknownTypeArgsLoc[i],
1754 getCurScope(), nullptr, T);
1755
1756 // Parse the closing '>'.
1757 SourceLocation rAngleLoc;
1758 (void)ParseGreaterThanInTemplateList(lAngleLoc, rAngleLoc, consumeLastToken,
1759 /*ObjCGenericList=*/true);
1760
1761 if (invalid) {
1762 typeArgs.clear();
1763 return;
1764 }
1765
1766 // Record left/right angle locations.
1767 typeArgsLAngleLoc = lAngleLoc;
1768 typeArgsRAngleLoc = rAngleLoc;
1769 }
1770
parseObjCTypeArgsAndProtocolQualifiers(ParsedType baseType,SourceLocation & typeArgsLAngleLoc,SmallVectorImpl<ParsedType> & typeArgs,SourceLocation & typeArgsRAngleLoc,SourceLocation & protocolLAngleLoc,SmallVectorImpl<Decl * > & protocols,SmallVectorImpl<SourceLocation> & protocolLocs,SourceLocation & protocolRAngleLoc,bool consumeLastToken)1771 void Parser::parseObjCTypeArgsAndProtocolQualifiers(
1772 ParsedType baseType,
1773 SourceLocation &typeArgsLAngleLoc,
1774 SmallVectorImpl<ParsedType> &typeArgs,
1775 SourceLocation &typeArgsRAngleLoc,
1776 SourceLocation &protocolLAngleLoc,
1777 SmallVectorImpl<Decl *> &protocols,
1778 SmallVectorImpl<SourceLocation> &protocolLocs,
1779 SourceLocation &protocolRAngleLoc,
1780 bool consumeLastToken) {
1781 assert(Tok.is(tok::less));
1782
1783 // Parse the first angle-bracket-delimited clause.
1784 parseObjCTypeArgsOrProtocolQualifiers(baseType,
1785 typeArgsLAngleLoc,
1786 typeArgs,
1787 typeArgsRAngleLoc,
1788 protocolLAngleLoc,
1789 protocols,
1790 protocolLocs,
1791 protocolRAngleLoc,
1792 consumeLastToken,
1793 /*warnOnIncompleteProtocols=*/false);
1794 if (Tok.is(tok::eof)) // Nothing else to do here...
1795 return;
1796
1797 // An Objective-C object pointer followed by type arguments
1798 // can then be followed again by a set of protocol references, e.g.,
1799 // \c NSArray<NSView><NSTextDelegate>
1800 if ((consumeLastToken && Tok.is(tok::less)) ||
1801 (!consumeLastToken && NextToken().is(tok::less))) {
1802 // If we aren't consuming the last token, the prior '>' is still hanging
1803 // there. Consume it before we parse the protocol qualifiers.
1804 if (!consumeLastToken)
1805 ConsumeToken();
1806
1807 if (!protocols.empty()) {
1808 SkipUntilFlags skipFlags = SkipUntilFlags();
1809 if (!consumeLastToken)
1810 skipFlags = skipFlags | StopBeforeMatch;
1811 Diag(Tok, diag::err_objc_type_args_after_protocols)
1812 << SourceRange(protocolLAngleLoc, protocolRAngleLoc);
1813 SkipUntil(tok::greater, tok::greatergreater, skipFlags);
1814 } else {
1815 ParseObjCProtocolReferences(protocols, protocolLocs,
1816 /*WarnOnDeclarations=*/false,
1817 /*ForObjCContainer=*/false,
1818 protocolLAngleLoc, protocolRAngleLoc,
1819 consumeLastToken);
1820 }
1821 }
1822 }
1823
parseObjCTypeArgsAndProtocolQualifiers(SourceLocation loc,ParsedType type,bool consumeLastToken,SourceLocation & endLoc)1824 TypeResult Parser::parseObjCTypeArgsAndProtocolQualifiers(
1825 SourceLocation loc,
1826 ParsedType type,
1827 bool consumeLastToken,
1828 SourceLocation &endLoc) {
1829 assert(Tok.is(tok::less));
1830 SourceLocation typeArgsLAngleLoc;
1831 SmallVector<ParsedType, 4> typeArgs;
1832 SourceLocation typeArgsRAngleLoc;
1833 SourceLocation protocolLAngleLoc;
1834 SmallVector<Decl *, 4> protocols;
1835 SmallVector<SourceLocation, 4> protocolLocs;
1836 SourceLocation protocolRAngleLoc;
1837
1838 // Parse type arguments and protocol qualifiers.
1839 parseObjCTypeArgsAndProtocolQualifiers(type, typeArgsLAngleLoc, typeArgs,
1840 typeArgsRAngleLoc, protocolLAngleLoc,
1841 protocols, protocolLocs,
1842 protocolRAngleLoc, consumeLastToken);
1843
1844 if (Tok.is(tok::eof))
1845 return true; // Invalid type result.
1846
1847 // Compute the location of the last token.
1848 if (consumeLastToken)
1849 endLoc = PrevTokLocation;
1850 else
1851 endLoc = Tok.getLocation();
1852
1853 return Actions.actOnObjCTypeArgsAndProtocolQualifiers(
1854 getCurScope(),
1855 loc,
1856 type,
1857 typeArgsLAngleLoc,
1858 typeArgs,
1859 typeArgsRAngleLoc,
1860 protocolLAngleLoc,
1861 protocols,
1862 protocolLocs,
1863 protocolRAngleLoc);
1864 }
1865
HelperActionsForIvarDeclarations(Decl * interfaceDecl,SourceLocation atLoc,BalancedDelimiterTracker & T,SmallVectorImpl<Decl * > & AllIvarDecls,bool RBraceMissing)1866 void Parser::HelperActionsForIvarDeclarations(Decl *interfaceDecl, SourceLocation atLoc,
1867 BalancedDelimiterTracker &T,
1868 SmallVectorImpl<Decl *> &AllIvarDecls,
1869 bool RBraceMissing) {
1870 if (!RBraceMissing)
1871 T.consumeClose();
1872
1873 Actions.ActOnObjCContainerStartDefinition(interfaceDecl);
1874 Actions.ActOnLastBitfield(T.getCloseLocation(), AllIvarDecls);
1875 Actions.ActOnObjCContainerFinishDefinition();
1876 // Call ActOnFields() even if we don't have any decls. This is useful
1877 // for code rewriting tools that need to be aware of the empty list.
1878 Actions.ActOnFields(getCurScope(), atLoc, interfaceDecl, AllIvarDecls,
1879 T.getOpenLocation(), T.getCloseLocation(),
1880 ParsedAttributesView());
1881 }
1882
1883 /// objc-class-instance-variables:
1884 /// '{' objc-instance-variable-decl-list[opt] '}'
1885 ///
1886 /// objc-instance-variable-decl-list:
1887 /// objc-visibility-spec
1888 /// objc-instance-variable-decl ';'
1889 /// ';'
1890 /// objc-instance-variable-decl-list objc-visibility-spec
1891 /// objc-instance-variable-decl-list objc-instance-variable-decl ';'
1892 /// objc-instance-variable-decl-list static_assert-declaration
1893 /// objc-instance-variable-decl-list ';'
1894 ///
1895 /// objc-visibility-spec:
1896 /// @private
1897 /// @protected
1898 /// @public
1899 /// @package [OBJC2]
1900 ///
1901 /// objc-instance-variable-decl:
1902 /// struct-declaration
1903 ///
ParseObjCClassInstanceVariables(Decl * interfaceDecl,tok::ObjCKeywordKind visibility,SourceLocation atLoc)1904 void Parser::ParseObjCClassInstanceVariables(Decl *interfaceDecl,
1905 tok::ObjCKeywordKind visibility,
1906 SourceLocation atLoc) {
1907 assert(Tok.is(tok::l_brace) && "expected {");
1908 SmallVector<Decl *, 32> AllIvarDecls;
1909
1910 ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope);
1911 ObjCDeclContextSwitch ObjCDC(*this);
1912
1913 BalancedDelimiterTracker T(*this, tok::l_brace);
1914 T.consumeOpen();
1915 // While we still have something to read, read the instance variables.
1916 while (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
1917 // Each iteration of this loop reads one objc-instance-variable-decl.
1918
1919 // Check for extraneous top-level semicolon.
1920 if (Tok.is(tok::semi)) {
1921 ConsumeExtraSemi(InstanceVariableList);
1922 continue;
1923 }
1924
1925 // Set the default visibility to private.
1926 if (TryConsumeToken(tok::at)) { // parse objc-visibility-spec
1927 if (Tok.is(tok::code_completion)) {
1928 Actions.CodeCompleteObjCAtVisibility(getCurScope());
1929 return cutOffParsing();
1930 }
1931
1932 switch (Tok.getObjCKeywordID()) {
1933 case tok::objc_private:
1934 case tok::objc_public:
1935 case tok::objc_protected:
1936 case tok::objc_package:
1937 visibility = Tok.getObjCKeywordID();
1938 ConsumeToken();
1939 continue;
1940
1941 case tok::objc_end:
1942 Diag(Tok, diag::err_objc_unexpected_atend);
1943 Tok.setLocation(Tok.getLocation().getLocWithOffset(-1));
1944 Tok.setKind(tok::at);
1945 Tok.setLength(1);
1946 PP.EnterToken(Tok, /*IsReinject*/true);
1947 HelperActionsForIvarDeclarations(interfaceDecl, atLoc,
1948 T, AllIvarDecls, true);
1949 return;
1950
1951 default:
1952 Diag(Tok, diag::err_objc_illegal_visibility_spec);
1953 continue;
1954 }
1955 }
1956
1957 if (Tok.is(tok::code_completion)) {
1958 Actions.CodeCompleteOrdinaryName(getCurScope(),
1959 Sema::PCC_ObjCInstanceVariableList);
1960 return cutOffParsing();
1961 }
1962
1963 // This needs to duplicate a small amount of code from
1964 // ParseStructUnionBody() for things that should work in both
1965 // C struct and in Objective-C class instance variables.
1966 if (Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert)) {
1967 SourceLocation DeclEnd;
1968 ParseStaticAssertDeclaration(DeclEnd);
1969 continue;
1970 }
1971
1972 auto ObjCIvarCallback = [&](ParsingFieldDeclarator &FD) {
1973 Actions.ActOnObjCContainerStartDefinition(interfaceDecl);
1974 // Install the declarator into the interface decl.
1975 FD.D.setObjCIvar(true);
1976 Decl *Field = Actions.ActOnIvar(
1977 getCurScope(), FD.D.getDeclSpec().getSourceRange().getBegin(), FD.D,
1978 FD.BitfieldSize, visibility);
1979 Actions.ActOnObjCContainerFinishDefinition();
1980 if (Field)
1981 AllIvarDecls.push_back(Field);
1982 FD.complete(Field);
1983 };
1984
1985 // Parse all the comma separated declarators.
1986 ParsingDeclSpec DS(*this);
1987 ParseStructDeclaration(DS, ObjCIvarCallback);
1988
1989 if (Tok.is(tok::semi)) {
1990 ConsumeToken();
1991 } else {
1992 Diag(Tok, diag::err_expected_semi_decl_list);
1993 // Skip to end of block or statement
1994 SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
1995 }
1996 }
1997 HelperActionsForIvarDeclarations(interfaceDecl, atLoc,
1998 T, AllIvarDecls, false);
1999 }
2000
2001 /// objc-protocol-declaration:
2002 /// objc-protocol-definition
2003 /// objc-protocol-forward-reference
2004 ///
2005 /// objc-protocol-definition:
2006 /// \@protocol identifier
2007 /// objc-protocol-refs[opt]
2008 /// objc-interface-decl-list
2009 /// \@end
2010 ///
2011 /// objc-protocol-forward-reference:
2012 /// \@protocol identifier-list ';'
2013 ///
2014 /// "\@protocol identifier ;" should be resolved as "\@protocol
2015 /// identifier-list ;": objc-interface-decl-list may not start with a
2016 /// semicolon in the first alternative if objc-protocol-refs are omitted.
2017 Parser::DeclGroupPtrTy
ParseObjCAtProtocolDeclaration(SourceLocation AtLoc,ParsedAttributes & attrs)2018 Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc,
2019 ParsedAttributes &attrs) {
2020 assert(Tok.isObjCAtKeyword(tok::objc_protocol) &&
2021 "ParseObjCAtProtocolDeclaration(): Expected @protocol");
2022 ConsumeToken(); // the "protocol" identifier
2023
2024 if (Tok.is(tok::code_completion)) {
2025 Actions.CodeCompleteObjCProtocolDecl(getCurScope());
2026 cutOffParsing();
2027 return nullptr;
2028 }
2029
2030 MaybeSkipAttributes(tok::objc_protocol);
2031
2032 if (expectIdentifier())
2033 return nullptr; // missing protocol name.
2034 // Save the protocol name, then consume it.
2035 IdentifierInfo *protocolName = Tok.getIdentifierInfo();
2036 SourceLocation nameLoc = ConsumeToken();
2037
2038 if (TryConsumeToken(tok::semi)) { // forward declaration of one protocol.
2039 IdentifierLocPair ProtoInfo(protocolName, nameLoc);
2040 return Actions.ActOnForwardProtocolDeclaration(AtLoc, ProtoInfo, attrs);
2041 }
2042
2043 CheckNestedObjCContexts(AtLoc);
2044
2045 if (Tok.is(tok::comma)) { // list of forward declarations.
2046 SmallVector<IdentifierLocPair, 8> ProtocolRefs;
2047 ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc));
2048
2049 // Parse the list of forward declarations.
2050 while (1) {
2051 ConsumeToken(); // the ','
2052 if (expectIdentifier()) {
2053 SkipUntil(tok::semi);
2054 return nullptr;
2055 }
2056 ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(),
2057 Tok.getLocation()));
2058 ConsumeToken(); // the identifier
2059
2060 if (Tok.isNot(tok::comma))
2061 break;
2062 }
2063 // Consume the ';'.
2064 if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@protocol"))
2065 return nullptr;
2066
2067 return Actions.ActOnForwardProtocolDeclaration(AtLoc, ProtocolRefs, attrs);
2068 }
2069
2070 // Last, and definitely not least, parse a protocol declaration.
2071 SourceLocation LAngleLoc, EndProtoLoc;
2072
2073 SmallVector<Decl *, 8> ProtocolRefs;
2074 SmallVector<SourceLocation, 8> ProtocolLocs;
2075 if (Tok.is(tok::less) &&
2076 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, false, true,
2077 LAngleLoc, EndProtoLoc,
2078 /*consumeLastToken=*/true))
2079 return nullptr;
2080
2081 Decl *ProtoType = Actions.ActOnStartProtocolInterface(
2082 AtLoc, protocolName, nameLoc, ProtocolRefs.data(), ProtocolRefs.size(),
2083 ProtocolLocs.data(), EndProtoLoc, attrs);
2084
2085 ParseObjCInterfaceDeclList(tok::objc_protocol, ProtoType);
2086 return Actions.ConvertDeclToDeclGroup(ProtoType);
2087 }
2088
2089 /// objc-implementation:
2090 /// objc-class-implementation-prologue
2091 /// objc-category-implementation-prologue
2092 ///
2093 /// objc-class-implementation-prologue:
2094 /// @implementation identifier objc-superclass[opt]
2095 /// objc-class-instance-variables[opt]
2096 ///
2097 /// objc-category-implementation-prologue:
2098 /// @implementation identifier ( identifier )
2099 Parser::DeclGroupPtrTy
ParseObjCAtImplementationDeclaration(SourceLocation AtLoc,ParsedAttributes & Attrs)2100 Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc,
2101 ParsedAttributes &Attrs) {
2102 assert(Tok.isObjCAtKeyword(tok::objc_implementation) &&
2103 "ParseObjCAtImplementationDeclaration(): Expected @implementation");
2104 CheckNestedObjCContexts(AtLoc);
2105 ConsumeToken(); // the "implementation" identifier
2106
2107 // Code completion after '@implementation'.
2108 if (Tok.is(tok::code_completion)) {
2109 Actions.CodeCompleteObjCImplementationDecl(getCurScope());
2110 cutOffParsing();
2111 return nullptr;
2112 }
2113
2114 MaybeSkipAttributes(tok::objc_implementation);
2115
2116 if (expectIdentifier())
2117 return nullptr; // missing class or category name.
2118 // We have a class or category name - consume it.
2119 IdentifierInfo *nameId = Tok.getIdentifierInfo();
2120 SourceLocation nameLoc = ConsumeToken(); // consume class or category name
2121 Decl *ObjCImpDecl = nullptr;
2122
2123 // Neither a type parameter list nor a list of protocol references is
2124 // permitted here. Parse and diagnose them.
2125 if (Tok.is(tok::less)) {
2126 SourceLocation lAngleLoc, rAngleLoc;
2127 SmallVector<IdentifierLocPair, 8> protocolIdents;
2128 SourceLocation diagLoc = Tok.getLocation();
2129 ObjCTypeParamListScope typeParamScope(Actions, getCurScope());
2130 if (parseObjCTypeParamListOrProtocolRefs(typeParamScope, lAngleLoc,
2131 protocolIdents, rAngleLoc)) {
2132 Diag(diagLoc, diag::err_objc_parameterized_implementation)
2133 << SourceRange(diagLoc, PrevTokLocation);
2134 } else if (lAngleLoc.isValid()) {
2135 Diag(lAngleLoc, diag::err_unexpected_protocol_qualifier)
2136 << FixItHint::CreateRemoval(SourceRange(lAngleLoc, rAngleLoc));
2137 }
2138 }
2139
2140 if (Tok.is(tok::l_paren)) {
2141 // we have a category implementation.
2142 ConsumeParen();
2143 SourceLocation categoryLoc, rparenLoc;
2144 IdentifierInfo *categoryId = nullptr;
2145
2146 if (Tok.is(tok::code_completion)) {
2147 Actions.CodeCompleteObjCImplementationCategory(getCurScope(), nameId, nameLoc);
2148 cutOffParsing();
2149 return nullptr;
2150 }
2151
2152 if (Tok.is(tok::identifier)) {
2153 categoryId = Tok.getIdentifierInfo();
2154 categoryLoc = ConsumeToken();
2155 } else {
2156 Diag(Tok, diag::err_expected)
2157 << tok::identifier; // missing category name.
2158 return nullptr;
2159 }
2160 if (Tok.isNot(tok::r_paren)) {
2161 Diag(Tok, diag::err_expected) << tok::r_paren;
2162 SkipUntil(tok::r_paren); // don't stop at ';'
2163 return nullptr;
2164 }
2165 rparenLoc = ConsumeParen();
2166 if (Tok.is(tok::less)) { // we have illegal '<' try to recover
2167 Diag(Tok, diag::err_unexpected_protocol_qualifier);
2168 SourceLocation protocolLAngleLoc, protocolRAngleLoc;
2169 SmallVector<Decl *, 4> protocols;
2170 SmallVector<SourceLocation, 4> protocolLocs;
2171 (void)ParseObjCProtocolReferences(protocols, protocolLocs,
2172 /*warnOnIncompleteProtocols=*/false,
2173 /*ForObjCContainer=*/false,
2174 protocolLAngleLoc, protocolRAngleLoc,
2175 /*consumeLastToken=*/true);
2176 }
2177 ObjCImpDecl = Actions.ActOnStartCategoryImplementation(
2178 AtLoc, nameId, nameLoc, categoryId, categoryLoc, Attrs);
2179
2180 } else {
2181 // We have a class implementation
2182 SourceLocation superClassLoc;
2183 IdentifierInfo *superClassId = nullptr;
2184 if (TryConsumeToken(tok::colon)) {
2185 // We have a super class
2186 if (expectIdentifier())
2187 return nullptr; // missing super class name.
2188 superClassId = Tok.getIdentifierInfo();
2189 superClassLoc = ConsumeToken(); // Consume super class name
2190 }
2191 ObjCImpDecl = Actions.ActOnStartClassImplementation(
2192 AtLoc, nameId, nameLoc, superClassId, superClassLoc, Attrs);
2193
2194 if (Tok.is(tok::l_brace)) // we have ivars
2195 ParseObjCClassInstanceVariables(ObjCImpDecl, tok::objc_private, AtLoc);
2196 else if (Tok.is(tok::less)) { // we have illegal '<' try to recover
2197 Diag(Tok, diag::err_unexpected_protocol_qualifier);
2198
2199 SourceLocation protocolLAngleLoc, protocolRAngleLoc;
2200 SmallVector<Decl *, 4> protocols;
2201 SmallVector<SourceLocation, 4> protocolLocs;
2202 (void)ParseObjCProtocolReferences(protocols, protocolLocs,
2203 /*warnOnIncompleteProtocols=*/false,
2204 /*ForObjCContainer=*/false,
2205 protocolLAngleLoc, protocolRAngleLoc,
2206 /*consumeLastToken=*/true);
2207 }
2208 }
2209 assert(ObjCImpDecl);
2210
2211 SmallVector<Decl *, 8> DeclsInGroup;
2212
2213 {
2214 ObjCImplParsingDataRAII ObjCImplParsing(*this, ObjCImpDecl);
2215 while (!ObjCImplParsing.isFinished() && !isEofOrEom()) {
2216 ParsedAttributesWithRange attrs(AttrFactory);
2217 MaybeParseCXX11Attributes(attrs);
2218 if (DeclGroupPtrTy DGP = ParseExternalDeclaration(attrs)) {
2219 DeclGroupRef DG = DGP.get();
2220 DeclsInGroup.append(DG.begin(), DG.end());
2221 }
2222 }
2223 }
2224
2225 return Actions.ActOnFinishObjCImplementation(ObjCImpDecl, DeclsInGroup);
2226 }
2227
2228 Parser::DeclGroupPtrTy
ParseObjCAtEndDeclaration(SourceRange atEnd)2229 Parser::ParseObjCAtEndDeclaration(SourceRange atEnd) {
2230 assert(Tok.isObjCAtKeyword(tok::objc_end) &&
2231 "ParseObjCAtEndDeclaration(): Expected @end");
2232 ConsumeToken(); // the "end" identifier
2233 if (CurParsedObjCImpl)
2234 CurParsedObjCImpl->finish(atEnd);
2235 else
2236 // missing @implementation
2237 Diag(atEnd.getBegin(), diag::err_expected_objc_container);
2238 return nullptr;
2239 }
2240
~ObjCImplParsingDataRAII()2241 Parser::ObjCImplParsingDataRAII::~ObjCImplParsingDataRAII() {
2242 if (!Finished) {
2243 finish(P.Tok.getLocation());
2244 if (P.isEofOrEom()) {
2245 P.Diag(P.Tok, diag::err_objc_missing_end)
2246 << FixItHint::CreateInsertion(P.Tok.getLocation(), "\n@end\n");
2247 P.Diag(Dcl->getBeginLoc(), diag::note_objc_container_start)
2248 << Sema::OCK_Implementation;
2249 }
2250 }
2251 P.CurParsedObjCImpl = nullptr;
2252 assert(LateParsedObjCMethods.empty());
2253 }
2254
finish(SourceRange AtEnd)2255 void Parser::ObjCImplParsingDataRAII::finish(SourceRange AtEnd) {
2256 assert(!Finished);
2257 P.Actions.DefaultSynthesizeProperties(P.getCurScope(), Dcl, AtEnd.getBegin());
2258 for (size_t i = 0; i < LateParsedObjCMethods.size(); ++i)
2259 P.ParseLexedObjCMethodDefs(*LateParsedObjCMethods[i],
2260 true/*Methods*/);
2261
2262 P.Actions.ActOnAtEnd(P.getCurScope(), AtEnd);
2263
2264 if (HasCFunction)
2265 for (size_t i = 0; i < LateParsedObjCMethods.size(); ++i)
2266 P.ParseLexedObjCMethodDefs(*LateParsedObjCMethods[i],
2267 false/*c-functions*/);
2268
2269 /// Clear and free the cached objc methods.
2270 for (LateParsedObjCMethodContainer::iterator
2271 I = LateParsedObjCMethods.begin(),
2272 E = LateParsedObjCMethods.end(); I != E; ++I)
2273 delete *I;
2274 LateParsedObjCMethods.clear();
2275
2276 Finished = true;
2277 }
2278
2279 /// compatibility-alias-decl:
2280 /// @compatibility_alias alias-name class-name ';'
2281 ///
ParseObjCAtAliasDeclaration(SourceLocation atLoc)2282 Decl *Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc) {
2283 assert(Tok.isObjCAtKeyword(tok::objc_compatibility_alias) &&
2284 "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias");
2285 ConsumeToken(); // consume compatibility_alias
2286 if (expectIdentifier())
2287 return nullptr;
2288 IdentifierInfo *aliasId = Tok.getIdentifierInfo();
2289 SourceLocation aliasLoc = ConsumeToken(); // consume alias-name
2290 if (expectIdentifier())
2291 return nullptr;
2292 IdentifierInfo *classId = Tok.getIdentifierInfo();
2293 SourceLocation classLoc = ConsumeToken(); // consume class-name;
2294 ExpectAndConsume(tok::semi, diag::err_expected_after, "@compatibility_alias");
2295 return Actions.ActOnCompatibilityAlias(atLoc, aliasId, aliasLoc,
2296 classId, classLoc);
2297 }
2298
2299 /// property-synthesis:
2300 /// @synthesize property-ivar-list ';'
2301 ///
2302 /// property-ivar-list:
2303 /// property-ivar
2304 /// property-ivar-list ',' property-ivar
2305 ///
2306 /// property-ivar:
2307 /// identifier
2308 /// identifier '=' identifier
2309 ///
ParseObjCPropertySynthesize(SourceLocation atLoc)2310 Decl *Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) {
2311 assert(Tok.isObjCAtKeyword(tok::objc_synthesize) &&
2312 "ParseObjCPropertySynthesize(): Expected '@synthesize'");
2313 ConsumeToken(); // consume synthesize
2314
2315 while (true) {
2316 if (Tok.is(tok::code_completion)) {
2317 Actions.CodeCompleteObjCPropertyDefinition(getCurScope());
2318 cutOffParsing();
2319 return nullptr;
2320 }
2321
2322 if (Tok.isNot(tok::identifier)) {
2323 Diag(Tok, diag::err_synthesized_property_name);
2324 SkipUntil(tok::semi);
2325 return nullptr;
2326 }
2327
2328 IdentifierInfo *propertyIvar = nullptr;
2329 IdentifierInfo *propertyId = Tok.getIdentifierInfo();
2330 SourceLocation propertyLoc = ConsumeToken(); // consume property name
2331 SourceLocation propertyIvarLoc;
2332 if (TryConsumeToken(tok::equal)) {
2333 // property '=' ivar-name
2334 if (Tok.is(tok::code_completion)) {
2335 Actions.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId);
2336 cutOffParsing();
2337 return nullptr;
2338 }
2339
2340 if (expectIdentifier())
2341 break;
2342 propertyIvar = Tok.getIdentifierInfo();
2343 propertyIvarLoc = ConsumeToken(); // consume ivar-name
2344 }
2345 Actions.ActOnPropertyImplDecl(
2346 getCurScope(), atLoc, propertyLoc, true,
2347 propertyId, propertyIvar, propertyIvarLoc,
2348 ObjCPropertyQueryKind::OBJC_PR_query_unknown);
2349 if (Tok.isNot(tok::comma))
2350 break;
2351 ConsumeToken(); // consume ','
2352 }
2353 ExpectAndConsume(tok::semi, diag::err_expected_after, "@synthesize");
2354 return nullptr;
2355 }
2356
2357 /// property-dynamic:
2358 /// @dynamic property-list
2359 ///
2360 /// property-list:
2361 /// identifier
2362 /// property-list ',' identifier
2363 ///
ParseObjCPropertyDynamic(SourceLocation atLoc)2364 Decl *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) {
2365 assert(Tok.isObjCAtKeyword(tok::objc_dynamic) &&
2366 "ParseObjCPropertyDynamic(): Expected '@dynamic'");
2367 ConsumeToken(); // consume dynamic
2368
2369 bool isClassProperty = false;
2370 if (Tok.is(tok::l_paren)) {
2371 ConsumeParen();
2372 const IdentifierInfo *II = Tok.getIdentifierInfo();
2373
2374 if (!II) {
2375 Diag(Tok, diag::err_objc_expected_property_attr) << II;
2376 SkipUntil(tok::r_paren, StopAtSemi);
2377 } else {
2378 SourceLocation AttrName = ConsumeToken(); // consume attribute name
2379 if (II->isStr("class")) {
2380 isClassProperty = true;
2381 if (Tok.isNot(tok::r_paren)) {
2382 Diag(Tok, diag::err_expected) << tok::r_paren;
2383 SkipUntil(tok::r_paren, StopAtSemi);
2384 } else
2385 ConsumeParen();
2386 } else {
2387 Diag(AttrName, diag::err_objc_expected_property_attr) << II;
2388 SkipUntil(tok::r_paren, StopAtSemi);
2389 }
2390 }
2391 }
2392
2393 while (true) {
2394 if (Tok.is(tok::code_completion)) {
2395 Actions.CodeCompleteObjCPropertyDefinition(getCurScope());
2396 cutOffParsing();
2397 return nullptr;
2398 }
2399
2400 if (expectIdentifier()) {
2401 SkipUntil(tok::semi);
2402 return nullptr;
2403 }
2404
2405 IdentifierInfo *propertyId = Tok.getIdentifierInfo();
2406 SourceLocation propertyLoc = ConsumeToken(); // consume property name
2407 Actions.ActOnPropertyImplDecl(
2408 getCurScope(), atLoc, propertyLoc, false,
2409 propertyId, nullptr, SourceLocation(),
2410 isClassProperty ? ObjCPropertyQueryKind::OBJC_PR_query_class :
2411 ObjCPropertyQueryKind::OBJC_PR_query_unknown);
2412
2413 if (Tok.isNot(tok::comma))
2414 break;
2415 ConsumeToken(); // consume ','
2416 }
2417 ExpectAndConsume(tok::semi, diag::err_expected_after, "@dynamic");
2418 return nullptr;
2419 }
2420
2421 /// objc-throw-statement:
2422 /// throw expression[opt];
2423 ///
ParseObjCThrowStmt(SourceLocation atLoc)2424 StmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) {
2425 ExprResult Res;
2426 ConsumeToken(); // consume throw
2427 if (Tok.isNot(tok::semi)) {
2428 Res = ParseExpression();
2429 if (Res.isInvalid()) {
2430 SkipUntil(tok::semi);
2431 return StmtError();
2432 }
2433 }
2434 // consume ';'
2435 ExpectAndConsume(tok::semi, diag::err_expected_after, "@throw");
2436 return Actions.ActOnObjCAtThrowStmt(atLoc, Res.get(), getCurScope());
2437 }
2438
2439 /// objc-synchronized-statement:
2440 /// @synchronized '(' expression ')' compound-statement
2441 ///
2442 StmtResult
ParseObjCSynchronizedStmt(SourceLocation atLoc)2443 Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) {
2444 ConsumeToken(); // consume synchronized
2445 if (Tok.isNot(tok::l_paren)) {
2446 Diag(Tok, diag::err_expected_lparen_after) << "@synchronized";
2447 return StmtError();
2448 }
2449
2450 // The operand is surrounded with parentheses.
2451 ConsumeParen(); // '('
2452 ExprResult operand(ParseExpression());
2453
2454 if (Tok.is(tok::r_paren)) {
2455 ConsumeParen(); // ')'
2456 } else {
2457 if (!operand.isInvalid())
2458 Diag(Tok, diag::err_expected) << tok::r_paren;
2459
2460 // Skip forward until we see a left brace, but don't consume it.
2461 SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch);
2462 }
2463
2464 // Require a compound statement.
2465 if (Tok.isNot(tok::l_brace)) {
2466 if (!operand.isInvalid())
2467 Diag(Tok, diag::err_expected) << tok::l_brace;
2468 return StmtError();
2469 }
2470
2471 // Check the @synchronized operand now.
2472 if (!operand.isInvalid())
2473 operand = Actions.ActOnObjCAtSynchronizedOperand(atLoc, operand.get());
2474
2475 // Parse the compound statement within a new scope.
2476 ParseScope bodyScope(this, Scope::DeclScope | Scope::CompoundStmtScope);
2477 StmtResult body(ParseCompoundStatementBody());
2478 bodyScope.Exit();
2479
2480 // If there was a semantic or parse error earlier with the
2481 // operand, fail now.
2482 if (operand.isInvalid())
2483 return StmtError();
2484
2485 if (body.isInvalid())
2486 body = Actions.ActOnNullStmt(Tok.getLocation());
2487
2488 return Actions.ActOnObjCAtSynchronizedStmt(atLoc, operand.get(), body.get());
2489 }
2490
2491 /// objc-try-catch-statement:
2492 /// @try compound-statement objc-catch-list[opt]
2493 /// @try compound-statement objc-catch-list[opt] @finally compound-statement
2494 ///
2495 /// objc-catch-list:
2496 /// @catch ( parameter-declaration ) compound-statement
2497 /// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement
2498 /// catch-parameter-declaration:
2499 /// parameter-declaration
2500 /// '...' [OBJC2]
2501 ///
ParseObjCTryStmt(SourceLocation atLoc)2502 StmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) {
2503 bool catch_or_finally_seen = false;
2504
2505 ConsumeToken(); // consume try
2506 if (Tok.isNot(tok::l_brace)) {
2507 Diag(Tok, diag::err_expected) << tok::l_brace;
2508 return StmtError();
2509 }
2510 StmtVector CatchStmts;
2511 StmtResult FinallyStmt;
2512 ParseScope TryScope(this, Scope::DeclScope | Scope::CompoundStmtScope);
2513 StmtResult TryBody(ParseCompoundStatementBody());
2514 TryScope.Exit();
2515 if (TryBody.isInvalid())
2516 TryBody = Actions.ActOnNullStmt(Tok.getLocation());
2517
2518 while (Tok.is(tok::at)) {
2519 // At this point, we need to lookahead to determine if this @ is the start
2520 // of an @catch or @finally. We don't want to consume the @ token if this
2521 // is an @try or @encode or something else.
2522 Token AfterAt = GetLookAheadToken(1);
2523 if (!AfterAt.isObjCAtKeyword(tok::objc_catch) &&
2524 !AfterAt.isObjCAtKeyword(tok::objc_finally))
2525 break;
2526
2527 SourceLocation AtCatchFinallyLoc = ConsumeToken();
2528 if (Tok.isObjCAtKeyword(tok::objc_catch)) {
2529 Decl *FirstPart = nullptr;
2530 ConsumeToken(); // consume catch
2531 if (Tok.is(tok::l_paren)) {
2532 ConsumeParen();
2533 ParseScope CatchScope(this, Scope::DeclScope |
2534 Scope::CompoundStmtScope |
2535 Scope::AtCatchScope);
2536 if (Tok.isNot(tok::ellipsis)) {
2537 DeclSpec DS(AttrFactory);
2538 ParseDeclarationSpecifiers(DS);
2539 Declarator ParmDecl(DS, DeclaratorContext::ObjCCatchContext);
2540 ParseDeclarator(ParmDecl);
2541
2542 // Inform the actions module about the declarator, so it
2543 // gets added to the current scope.
2544 FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl);
2545 } else
2546 ConsumeToken(); // consume '...'
2547
2548 SourceLocation RParenLoc;
2549
2550 if (Tok.is(tok::r_paren))
2551 RParenLoc = ConsumeParen();
2552 else // Skip over garbage, until we get to ')'. Eat the ')'.
2553 SkipUntil(tok::r_paren, StopAtSemi);
2554
2555 StmtResult CatchBody(true);
2556 if (Tok.is(tok::l_brace))
2557 CatchBody = ParseCompoundStatementBody();
2558 else
2559 Diag(Tok, diag::err_expected) << tok::l_brace;
2560 if (CatchBody.isInvalid())
2561 CatchBody = Actions.ActOnNullStmt(Tok.getLocation());
2562
2563 StmtResult Catch = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc,
2564 RParenLoc,
2565 FirstPart,
2566 CatchBody.get());
2567 if (!Catch.isInvalid())
2568 CatchStmts.push_back(Catch.get());
2569
2570 } else {
2571 Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after)
2572 << "@catch clause";
2573 return StmtError();
2574 }
2575 catch_or_finally_seen = true;
2576 } else {
2577 assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?");
2578 ConsumeToken(); // consume finally
2579 ParseScope FinallyScope(this,
2580 Scope::DeclScope | Scope::CompoundStmtScope);
2581
2582 bool ShouldCapture =
2583 getTargetInfo().getTriple().isWindowsMSVCEnvironment();
2584 if (ShouldCapture)
2585 Actions.ActOnCapturedRegionStart(Tok.getLocation(), getCurScope(),
2586 CR_ObjCAtFinally, 1);
2587
2588 StmtResult FinallyBody(true);
2589 if (Tok.is(tok::l_brace))
2590 FinallyBody = ParseCompoundStatementBody();
2591 else
2592 Diag(Tok, diag::err_expected) << tok::l_brace;
2593
2594 if (FinallyBody.isInvalid()) {
2595 FinallyBody = Actions.ActOnNullStmt(Tok.getLocation());
2596 if (ShouldCapture)
2597 Actions.ActOnCapturedRegionError();
2598 } else if (ShouldCapture) {
2599 FinallyBody = Actions.ActOnCapturedRegionEnd(FinallyBody.get());
2600 }
2601
2602 FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc,
2603 FinallyBody.get());
2604 catch_or_finally_seen = true;
2605 break;
2606 }
2607 }
2608 if (!catch_or_finally_seen) {
2609 Diag(atLoc, diag::err_missing_catch_finally);
2610 return StmtError();
2611 }
2612
2613 return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.get(),
2614 CatchStmts,
2615 FinallyStmt.get());
2616 }
2617
2618 /// objc-autoreleasepool-statement:
2619 /// @autoreleasepool compound-statement
2620 ///
2621 StmtResult
ParseObjCAutoreleasePoolStmt(SourceLocation atLoc)2622 Parser::ParseObjCAutoreleasePoolStmt(SourceLocation atLoc) {
2623 ConsumeToken(); // consume autoreleasepool
2624 if (Tok.isNot(tok::l_brace)) {
2625 Diag(Tok, diag::err_expected) << tok::l_brace;
2626 return StmtError();
2627 }
2628 // Enter a scope to hold everything within the compound stmt. Compound
2629 // statements can always hold declarations.
2630 ParseScope BodyScope(this, Scope::DeclScope | Scope::CompoundStmtScope);
2631
2632 StmtResult AutoreleasePoolBody(ParseCompoundStatementBody());
2633
2634 BodyScope.Exit();
2635 if (AutoreleasePoolBody.isInvalid())
2636 AutoreleasePoolBody = Actions.ActOnNullStmt(Tok.getLocation());
2637 return Actions.ActOnObjCAutoreleasePoolStmt(atLoc,
2638 AutoreleasePoolBody.get());
2639 }
2640
2641 /// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them
2642 /// for later parsing.
StashAwayMethodOrFunctionBodyTokens(Decl * MDecl)2643 void Parser::StashAwayMethodOrFunctionBodyTokens(Decl *MDecl) {
2644 if (SkipFunctionBodies && (!MDecl || Actions.canSkipFunctionBody(MDecl)) &&
2645 trySkippingFunctionBody()) {
2646 Actions.ActOnSkippedFunctionBody(MDecl);
2647 return;
2648 }
2649
2650 LexedMethod* LM = new LexedMethod(this, MDecl);
2651 CurParsedObjCImpl->LateParsedObjCMethods.push_back(LM);
2652 CachedTokens &Toks = LM->Toks;
2653 // Begin by storing the '{' or 'try' or ':' token.
2654 Toks.push_back(Tok);
2655 if (Tok.is(tok::kw_try)) {
2656 ConsumeToken();
2657 if (Tok.is(tok::colon)) {
2658 Toks.push_back(Tok);
2659 ConsumeToken();
2660 while (Tok.isNot(tok::l_brace)) {
2661 ConsumeAndStoreUntil(tok::l_paren, Toks, /*StopAtSemi=*/false);
2662 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
2663 }
2664 }
2665 Toks.push_back(Tok); // also store '{'
2666 }
2667 else if (Tok.is(tok::colon)) {
2668 ConsumeToken();
2669 // FIXME: This is wrong, due to C++11 braced initialization.
2670 while (Tok.isNot(tok::l_brace)) {
2671 ConsumeAndStoreUntil(tok::l_paren, Toks, /*StopAtSemi=*/false);
2672 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
2673 }
2674 Toks.push_back(Tok); // also store '{'
2675 }
2676 ConsumeBrace();
2677 // Consume everything up to (and including) the matching right brace.
2678 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
2679 while (Tok.is(tok::kw_catch)) {
2680 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false);
2681 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
2682 }
2683 }
2684
2685 /// objc-method-def: objc-method-proto ';'[opt] '{' body '}'
2686 ///
ParseObjCMethodDefinition()2687 Decl *Parser::ParseObjCMethodDefinition() {
2688 Decl *MDecl = ParseObjCMethodPrototype();
2689
2690 PrettyDeclStackTraceEntry CrashInfo(Actions.Context, MDecl, Tok.getLocation(),
2691 "parsing Objective-C method");
2692
2693 // parse optional ';'
2694 if (Tok.is(tok::semi)) {
2695 if (CurParsedObjCImpl) {
2696 Diag(Tok, diag::warn_semicolon_before_method_body)
2697 << FixItHint::CreateRemoval(Tok.getLocation());
2698 }
2699 ConsumeToken();
2700 }
2701
2702 // We should have an opening brace now.
2703 if (Tok.isNot(tok::l_brace)) {
2704 Diag(Tok, diag::err_expected_method_body);
2705
2706 // Skip over garbage, until we get to '{'. Don't eat the '{'.
2707 SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch);
2708
2709 // If we didn't find the '{', bail out.
2710 if (Tok.isNot(tok::l_brace))
2711 return nullptr;
2712 }
2713
2714 if (!MDecl) {
2715 ConsumeBrace();
2716 SkipUntil(tok::r_brace);
2717 return nullptr;
2718 }
2719
2720 // Allow the rest of sema to find private method decl implementations.
2721 Actions.AddAnyMethodToGlobalPool(MDecl);
2722 assert (CurParsedObjCImpl
2723 && "ParseObjCMethodDefinition - Method out of @implementation");
2724 // Consume the tokens and store them for later parsing.
2725 StashAwayMethodOrFunctionBodyTokens(MDecl);
2726 return MDecl;
2727 }
2728
ParseObjCAtStatement(SourceLocation AtLoc,ParsedStmtContext StmtCtx)2729 StmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc,
2730 ParsedStmtContext StmtCtx) {
2731 if (Tok.is(tok::code_completion)) {
2732 Actions.CodeCompleteObjCAtStatement(getCurScope());
2733 cutOffParsing();
2734 return StmtError();
2735 }
2736
2737 if (Tok.isObjCAtKeyword(tok::objc_try))
2738 return ParseObjCTryStmt(AtLoc);
2739
2740 if (Tok.isObjCAtKeyword(tok::objc_throw))
2741 return ParseObjCThrowStmt(AtLoc);
2742
2743 if (Tok.isObjCAtKeyword(tok::objc_synchronized))
2744 return ParseObjCSynchronizedStmt(AtLoc);
2745
2746 if (Tok.isObjCAtKeyword(tok::objc_autoreleasepool))
2747 return ParseObjCAutoreleasePoolStmt(AtLoc);
2748
2749 if (Tok.isObjCAtKeyword(tok::objc_import) &&
2750 getLangOpts().DebuggerSupport) {
2751 SkipUntil(tok::semi);
2752 return Actions.ActOnNullStmt(Tok.getLocation());
2753 }
2754
2755 ExprStatementTokLoc = AtLoc;
2756 ExprResult Res(ParseExpressionWithLeadingAt(AtLoc));
2757 if (Res.isInvalid()) {
2758 // If the expression is invalid, skip ahead to the next semicolon. Not
2759 // doing this opens us up to the possibility of infinite loops if
2760 // ParseExpression does not consume any tokens.
2761 SkipUntil(tok::semi);
2762 return StmtError();
2763 }
2764
2765 // Otherwise, eat the semicolon.
2766 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
2767 return handleExprStmt(Res, StmtCtx);
2768 }
2769
ParseObjCAtExpression(SourceLocation AtLoc)2770 ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {
2771 switch (Tok.getKind()) {
2772 case tok::code_completion:
2773 Actions.CodeCompleteObjCAtExpression(getCurScope());
2774 cutOffParsing();
2775 return ExprError();
2776
2777 case tok::minus:
2778 case tok::plus: {
2779 tok::TokenKind Kind = Tok.getKind();
2780 SourceLocation OpLoc = ConsumeToken();
2781
2782 if (!Tok.is(tok::numeric_constant)) {
2783 const char *Symbol = nullptr;
2784 switch (Kind) {
2785 case tok::minus: Symbol = "-"; break;
2786 case tok::plus: Symbol = "+"; break;
2787 default: llvm_unreachable("missing unary operator case");
2788 }
2789 Diag(Tok, diag::err_nsnumber_nonliteral_unary)
2790 << Symbol;
2791 return ExprError();
2792 }
2793
2794 ExprResult Lit(Actions.ActOnNumericConstant(Tok));
2795 if (Lit.isInvalid()) {
2796 return Lit;
2797 }
2798 ConsumeToken(); // Consume the literal token.
2799
2800 Lit = Actions.ActOnUnaryOp(getCurScope(), OpLoc, Kind, Lit.get());
2801 if (Lit.isInvalid())
2802 return Lit;
2803
2804 return ParsePostfixExpressionSuffix(
2805 Actions.BuildObjCNumericLiteral(AtLoc, Lit.get()));
2806 }
2807
2808 case tok::string_literal: // primary-expression: string-literal
2809 case tok::wide_string_literal:
2810 return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc));
2811
2812 case tok::char_constant:
2813 return ParsePostfixExpressionSuffix(ParseObjCCharacterLiteral(AtLoc));
2814
2815 case tok::numeric_constant:
2816 return ParsePostfixExpressionSuffix(ParseObjCNumericLiteral(AtLoc));
2817
2818 case tok::kw_true: // Objective-C++, etc.
2819 case tok::kw___objc_yes: // c/c++/objc/objc++ __objc_yes
2820 return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc, true));
2821 case tok::kw_false: // Objective-C++, etc.
2822 case tok::kw___objc_no: // c/c++/objc/objc++ __objc_no
2823 return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc, false));
2824
2825 case tok::l_square:
2826 // Objective-C array literal
2827 return ParsePostfixExpressionSuffix(ParseObjCArrayLiteral(AtLoc));
2828
2829 case tok::l_brace:
2830 // Objective-C dictionary literal
2831 return ParsePostfixExpressionSuffix(ParseObjCDictionaryLiteral(AtLoc));
2832
2833 case tok::l_paren:
2834 // Objective-C boxed expression
2835 return ParsePostfixExpressionSuffix(ParseObjCBoxedExpr(AtLoc));
2836
2837 default:
2838 if (Tok.getIdentifierInfo() == nullptr)
2839 return ExprError(Diag(AtLoc, diag::err_unexpected_at));
2840
2841 switch (Tok.getIdentifierInfo()->getObjCKeywordID()) {
2842 case tok::objc_encode:
2843 return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc));
2844 case tok::objc_protocol:
2845 return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc));
2846 case tok::objc_selector:
2847 return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc));
2848 case tok::objc_available:
2849 return ParseAvailabilityCheckExpr(AtLoc);
2850 default: {
2851 const char *str = nullptr;
2852 // Only provide the @try/@finally/@autoreleasepool fixit when we're sure
2853 // that this is a proper statement where such directives could actually
2854 // occur.
2855 if (GetLookAheadToken(1).is(tok::l_brace) &&
2856 ExprStatementTokLoc == AtLoc) {
2857 char ch = Tok.getIdentifierInfo()->getNameStart()[0];
2858 str =
2859 ch == 't' ? "try"
2860 : (ch == 'f' ? "finally"
2861 : (ch == 'a' ? "autoreleasepool" : nullptr));
2862 }
2863 if (str) {
2864 SourceLocation kwLoc = Tok.getLocation();
2865 return ExprError(Diag(AtLoc, diag::err_unexpected_at) <<
2866 FixItHint::CreateReplacement(kwLoc, str));
2867 }
2868 else
2869 return ExprError(Diag(AtLoc, diag::err_unexpected_at));
2870 }
2871 }
2872 }
2873 }
2874
2875 /// Parse the receiver of an Objective-C++ message send.
2876 ///
2877 /// This routine parses the receiver of a message send in
2878 /// Objective-C++ either as a type or as an expression. Note that this
2879 /// routine must not be called to parse a send to 'super', since it
2880 /// has no way to return such a result.
2881 ///
2882 /// \param IsExpr Whether the receiver was parsed as an expression.
2883 ///
2884 /// \param TypeOrExpr If the receiver was parsed as an expression (\c
2885 /// IsExpr is true), the parsed expression. If the receiver was parsed
2886 /// as a type (\c IsExpr is false), the parsed type.
2887 ///
2888 /// \returns True if an error occurred during parsing or semantic
2889 /// analysis, in which case the arguments do not have valid
2890 /// values. Otherwise, returns false for a successful parse.
2891 ///
2892 /// objc-receiver: [C++]
2893 /// 'super' [not parsed here]
2894 /// expression
2895 /// simple-type-specifier
2896 /// typename-specifier
ParseObjCXXMessageReceiver(bool & IsExpr,void * & TypeOrExpr)2897 bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr) {
2898 InMessageExpressionRAIIObject InMessage(*this, true);
2899
2900 if (Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_typename,
2901 tok::annot_cxxscope))
2902 TryAnnotateTypeOrScopeToken();
2903
2904 if (!Actions.isSimpleTypeSpecifier(Tok.getKind())) {
2905 // objc-receiver:
2906 // expression
2907 // Make sure any typos in the receiver are corrected or diagnosed, so that
2908 // proper recovery can happen. FIXME: Perhaps filter the corrected expr to
2909 // only the things that are valid ObjC receivers?
2910 ExprResult Receiver = Actions.CorrectDelayedTyposInExpr(ParseExpression());
2911 if (Receiver.isInvalid())
2912 return true;
2913
2914 IsExpr = true;
2915 TypeOrExpr = Receiver.get();
2916 return false;
2917 }
2918
2919 // objc-receiver:
2920 // typename-specifier
2921 // simple-type-specifier
2922 // expression (that starts with one of the above)
2923 DeclSpec DS(AttrFactory);
2924 ParseCXXSimpleTypeSpecifier(DS);
2925
2926 if (Tok.is(tok::l_paren)) {
2927 // If we see an opening parentheses at this point, we are
2928 // actually parsing an expression that starts with a
2929 // function-style cast, e.g.,
2930 //
2931 // postfix-expression:
2932 // simple-type-specifier ( expression-list [opt] )
2933 // typename-specifier ( expression-list [opt] )
2934 //
2935 // Parse the remainder of this case, then the (optional)
2936 // postfix-expression suffix, followed by the (optional)
2937 // right-hand side of the binary expression. We have an
2938 // instance method.
2939 ExprResult Receiver = ParseCXXTypeConstructExpression(DS);
2940 if (!Receiver.isInvalid())
2941 Receiver = ParsePostfixExpressionSuffix(Receiver.get());
2942 if (!Receiver.isInvalid())
2943 Receiver = ParseRHSOfBinaryExpression(Receiver.get(), prec::Comma);
2944 if (Receiver.isInvalid())
2945 return true;
2946
2947 IsExpr = true;
2948 TypeOrExpr = Receiver.get();
2949 return false;
2950 }
2951
2952 // We have a class message. Turn the simple-type-specifier or
2953 // typename-specifier we parsed into a type and parse the
2954 // remainder of the class message.
2955 Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
2956 TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
2957 if (Type.isInvalid())
2958 return true;
2959
2960 IsExpr = false;
2961 TypeOrExpr = Type.get().getAsOpaquePtr();
2962 return false;
2963 }
2964
2965 /// Determine whether the parser is currently referring to a an
2966 /// Objective-C message send, using a simplified heuristic to avoid overhead.
2967 ///
2968 /// This routine will only return true for a subset of valid message-send
2969 /// expressions.
isSimpleObjCMessageExpression()2970 bool Parser::isSimpleObjCMessageExpression() {
2971 assert(Tok.is(tok::l_square) && getLangOpts().ObjC &&
2972 "Incorrect start for isSimpleObjCMessageExpression");
2973 return GetLookAheadToken(1).is(tok::identifier) &&
2974 GetLookAheadToken(2).is(tok::identifier);
2975 }
2976
isStartOfObjCClassMessageMissingOpenBracket()2977 bool Parser::isStartOfObjCClassMessageMissingOpenBracket() {
2978 if (!getLangOpts().ObjC || !NextToken().is(tok::identifier) ||
2979 InMessageExpression)
2980 return false;
2981
2982 TypeResult Type;
2983
2984 if (Tok.is(tok::annot_typename))
2985 Type = getTypeAnnotation(Tok);
2986 else if (Tok.is(tok::identifier))
2987 Type = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(),
2988 getCurScope());
2989 else
2990 return false;
2991
2992 // FIXME: Should not be querying properties of types from the parser.
2993 if (Type.isUsable() && Type.get().get()->isObjCObjectOrInterfaceType()) {
2994 const Token &AfterNext = GetLookAheadToken(2);
2995 if (AfterNext.isOneOf(tok::colon, tok::r_square)) {
2996 if (Tok.is(tok::identifier))
2997 TryAnnotateTypeOrScopeToken();
2998
2999 return Tok.is(tok::annot_typename);
3000 }
3001 }
3002
3003 return false;
3004 }
3005
3006 /// objc-message-expr:
3007 /// '[' objc-receiver objc-message-args ']'
3008 ///
3009 /// objc-receiver: [C]
3010 /// 'super'
3011 /// expression
3012 /// class-name
3013 /// type-name
3014 ///
ParseObjCMessageExpression()3015 ExprResult Parser::ParseObjCMessageExpression() {
3016 assert(Tok.is(tok::l_square) && "'[' expected");
3017 SourceLocation LBracLoc = ConsumeBracket(); // consume '['
3018
3019 if (Tok.is(tok::code_completion)) {
3020 Actions.CodeCompleteObjCMessageReceiver(getCurScope());
3021 cutOffParsing();
3022 return ExprError();
3023 }
3024
3025 InMessageExpressionRAIIObject InMessage(*this, true);
3026
3027 if (getLangOpts().CPlusPlus) {
3028 // We completely separate the C and C++ cases because C++ requires
3029 // more complicated (read: slower) parsing.
3030
3031 // Handle send to super.
3032 // FIXME: This doesn't benefit from the same typo-correction we
3033 // get in Objective-C.
3034 if (Tok.is(tok::identifier) && Tok.getIdentifierInfo() == Ident_super &&
3035 NextToken().isNot(tok::period) && getCurScope()->isInObjcMethodScope())
3036 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), nullptr,
3037 nullptr);
3038
3039 // Parse the receiver, which is either a type or an expression.
3040 bool IsExpr;
3041 void *TypeOrExpr = nullptr;
3042 if (ParseObjCXXMessageReceiver(IsExpr, TypeOrExpr)) {
3043 SkipUntil(tok::r_square, StopAtSemi);
3044 return ExprError();
3045 }
3046
3047 if (IsExpr)
3048 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), nullptr,
3049 static_cast<Expr *>(TypeOrExpr));
3050
3051 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
3052 ParsedType::getFromOpaquePtr(TypeOrExpr),
3053 nullptr);
3054 }
3055
3056 if (Tok.is(tok::identifier)) {
3057 IdentifierInfo *Name = Tok.getIdentifierInfo();
3058 SourceLocation NameLoc = Tok.getLocation();
3059 ParsedType ReceiverType;
3060 switch (Actions.getObjCMessageKind(getCurScope(), Name, NameLoc,
3061 Name == Ident_super,
3062 NextToken().is(tok::period),
3063 ReceiverType)) {
3064 case Sema::ObjCSuperMessage:
3065 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), nullptr,
3066 nullptr);
3067
3068 case Sema::ObjCClassMessage:
3069 if (!ReceiverType) {
3070 SkipUntil(tok::r_square, StopAtSemi);
3071 return ExprError();
3072 }
3073
3074 ConsumeToken(); // the type name
3075
3076 // Parse type arguments and protocol qualifiers.
3077 if (Tok.is(tok::less)) {
3078 SourceLocation NewEndLoc;
3079 TypeResult NewReceiverType
3080 = parseObjCTypeArgsAndProtocolQualifiers(NameLoc, ReceiverType,
3081 /*consumeLastToken=*/true,
3082 NewEndLoc);
3083 if (!NewReceiverType.isUsable()) {
3084 SkipUntil(tok::r_square, StopAtSemi);
3085 return ExprError();
3086 }
3087
3088 ReceiverType = NewReceiverType.get();
3089 }
3090
3091 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
3092 ReceiverType, nullptr);
3093
3094 case Sema::ObjCInstanceMessage:
3095 // Fall through to parse an expression.
3096 break;
3097 }
3098 }
3099
3100 // Otherwise, an arbitrary expression can be the receiver of a send.
3101 ExprResult Res = Actions.CorrectDelayedTyposInExpr(ParseExpression());
3102 if (Res.isInvalid()) {
3103 SkipUntil(tok::r_square, StopAtSemi);
3104 return Res;
3105 }
3106
3107 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), nullptr,
3108 Res.get());
3109 }
3110
3111 /// Parse the remainder of an Objective-C message following the
3112 /// '[' objc-receiver.
3113 ///
3114 /// This routine handles sends to super, class messages (sent to a
3115 /// class name), and instance messages (sent to an object), and the
3116 /// target is represented by \p SuperLoc, \p ReceiverType, or \p
3117 /// ReceiverExpr, respectively. Only one of these parameters may have
3118 /// a valid value.
3119 ///
3120 /// \param LBracLoc The location of the opening '['.
3121 ///
3122 /// \param SuperLoc If this is a send to 'super', the location of the
3123 /// 'super' keyword that indicates a send to the superclass.
3124 ///
3125 /// \param ReceiverType If this is a class message, the type of the
3126 /// class we are sending a message to.
3127 ///
3128 /// \param ReceiverExpr If this is an instance message, the expression
3129 /// used to compute the receiver object.
3130 ///
3131 /// objc-message-args:
3132 /// objc-selector
3133 /// objc-keywordarg-list
3134 ///
3135 /// objc-keywordarg-list:
3136 /// objc-keywordarg
3137 /// objc-keywordarg-list objc-keywordarg
3138 ///
3139 /// objc-keywordarg:
3140 /// selector-name[opt] ':' objc-keywordexpr
3141 ///
3142 /// objc-keywordexpr:
3143 /// nonempty-expr-list
3144 ///
3145 /// nonempty-expr-list:
3146 /// assignment-expression
3147 /// nonempty-expr-list , assignment-expression
3148 ///
3149 ExprResult
ParseObjCMessageExpressionBody(SourceLocation LBracLoc,SourceLocation SuperLoc,ParsedType ReceiverType,Expr * ReceiverExpr)3150 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc,
3151 SourceLocation SuperLoc,
3152 ParsedType ReceiverType,
3153 Expr *ReceiverExpr) {
3154 InMessageExpressionRAIIObject InMessage(*this, true);
3155
3156 if (Tok.is(tok::code_completion)) {
3157 if (SuperLoc.isValid())
3158 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, None,
3159 false);
3160 else if (ReceiverType)
3161 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, None,
3162 false);
3163 else
3164 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
3165 None, false);
3166 cutOffParsing();
3167 return ExprError();
3168 }
3169
3170 // Parse objc-selector
3171 SourceLocation Loc;
3172 IdentifierInfo *selIdent = ParseObjCSelectorPiece(Loc);
3173
3174 SmallVector<IdentifierInfo *, 12> KeyIdents;
3175 SmallVector<SourceLocation, 12> KeyLocs;
3176 ExprVector KeyExprs;
3177
3178 if (Tok.is(tok::colon)) {
3179 while (1) {
3180 // Each iteration parses a single keyword argument.
3181 KeyIdents.push_back(selIdent);
3182 KeyLocs.push_back(Loc);
3183
3184 if (ExpectAndConsume(tok::colon)) {
3185 // We must manually skip to a ']', otherwise the expression skipper will
3186 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3187 // the enclosing expression.
3188 SkipUntil(tok::r_square, StopAtSemi);
3189 return ExprError();
3190 }
3191
3192 /// Parse the expression after ':'
3193
3194 if (Tok.is(tok::code_completion)) {
3195 if (SuperLoc.isValid())
3196 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
3197 KeyIdents,
3198 /*AtArgumentExpression=*/true);
3199 else if (ReceiverType)
3200 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType,
3201 KeyIdents,
3202 /*AtArgumentExpression=*/true);
3203 else
3204 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
3205 KeyIdents,
3206 /*AtArgumentExpression=*/true);
3207
3208 cutOffParsing();
3209 return ExprError();
3210 }
3211
3212 ExprResult Expr;
3213 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
3214 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
3215 Expr = ParseBraceInitializer();
3216 } else
3217 Expr = ParseAssignmentExpression();
3218
3219 ExprResult Res(Expr);
3220 if (Res.isInvalid()) {
3221 // We must manually skip to a ']', otherwise the expression skipper will
3222 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3223 // the enclosing expression.
3224 SkipUntil(tok::r_square, StopAtSemi);
3225 return Res;
3226 }
3227
3228 // We have a valid expression.
3229 KeyExprs.push_back(Res.get());
3230
3231 // Code completion after each argument.
3232 if (Tok.is(tok::code_completion)) {
3233 if (SuperLoc.isValid())
3234 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
3235 KeyIdents,
3236 /*AtArgumentExpression=*/false);
3237 else if (ReceiverType)
3238 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType,
3239 KeyIdents,
3240 /*AtArgumentExpression=*/false);
3241 else
3242 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
3243 KeyIdents,
3244 /*AtArgumentExpression=*/false);
3245 cutOffParsing();
3246 return ExprError();
3247 }
3248
3249 // Check for another keyword selector.
3250 selIdent = ParseObjCSelectorPiece(Loc);
3251 if (!selIdent && Tok.isNot(tok::colon))
3252 break;
3253 // We have a selector or a colon, continue parsing.
3254 }
3255 // Parse the, optional, argument list, comma separated.
3256 while (Tok.is(tok::comma)) {
3257 SourceLocation commaLoc = ConsumeToken(); // Eat the ','.
3258 /// Parse the expression after ','
3259 ExprResult Res(ParseAssignmentExpression());
3260 if (Tok.is(tok::colon))
3261 Res = Actions.CorrectDelayedTyposInExpr(Res);
3262 if (Res.isInvalid()) {
3263 if (Tok.is(tok::colon)) {
3264 Diag(commaLoc, diag::note_extra_comma_message_arg) <<
3265 FixItHint::CreateRemoval(commaLoc);
3266 }
3267 // We must manually skip to a ']', otherwise the expression skipper will
3268 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3269 // the enclosing expression.
3270 SkipUntil(tok::r_square, StopAtSemi);
3271 return Res;
3272 }
3273
3274 // We have a valid expression.
3275 KeyExprs.push_back(Res.get());
3276 }
3277 } else if (!selIdent) {
3278 Diag(Tok, diag::err_expected) << tok::identifier; // missing selector name.
3279
3280 // We must manually skip to a ']', otherwise the expression skipper will
3281 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3282 // the enclosing expression.
3283 SkipUntil(tok::r_square, StopAtSemi);
3284 return ExprError();
3285 }
3286
3287 if (Tok.isNot(tok::r_square)) {
3288 Diag(Tok, diag::err_expected)
3289 << (Tok.is(tok::identifier) ? tok::colon : tok::r_square);
3290 // We must manually skip to a ']', otherwise the expression skipper will
3291 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3292 // the enclosing expression.
3293 SkipUntil(tok::r_square, StopAtSemi);
3294 return ExprError();
3295 }
3296
3297 SourceLocation RBracLoc = ConsumeBracket(); // consume ']'
3298
3299 unsigned nKeys = KeyIdents.size();
3300 if (nKeys == 0) {
3301 KeyIdents.push_back(selIdent);
3302 KeyLocs.push_back(Loc);
3303 }
3304 Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]);
3305
3306 if (SuperLoc.isValid())
3307 return Actions.ActOnSuperMessage(getCurScope(), SuperLoc, Sel,
3308 LBracLoc, KeyLocs, RBracLoc, KeyExprs);
3309 else if (ReceiverType)
3310 return Actions.ActOnClassMessage(getCurScope(), ReceiverType, Sel,
3311 LBracLoc, KeyLocs, RBracLoc, KeyExprs);
3312 return Actions.ActOnInstanceMessage(getCurScope(), ReceiverExpr, Sel,
3313 LBracLoc, KeyLocs, RBracLoc, KeyExprs);
3314 }
3315
ParseObjCStringLiteral(SourceLocation AtLoc)3316 ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) {
3317 ExprResult Res(ParseStringLiteralExpression());
3318 if (Res.isInvalid()) return Res;
3319
3320 // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string
3321 // expressions. At this point, we know that the only valid thing that starts
3322 // with '@' is an @"".
3323 SmallVector<SourceLocation, 4> AtLocs;
3324 ExprVector AtStrings;
3325 AtLocs.push_back(AtLoc);
3326 AtStrings.push_back(Res.get());
3327
3328 while (Tok.is(tok::at)) {
3329 AtLocs.push_back(ConsumeToken()); // eat the @.
3330
3331 // Invalid unless there is a string literal.
3332 if (!isTokenStringLiteral())
3333 return ExprError(Diag(Tok, diag::err_objc_concat_string));
3334
3335 ExprResult Lit(ParseStringLiteralExpression());
3336 if (Lit.isInvalid())
3337 return Lit;
3338
3339 AtStrings.push_back(Lit.get());
3340 }
3341
3342 return Actions.ParseObjCStringLiteral(AtLocs.data(), AtStrings);
3343 }
3344
3345 /// ParseObjCBooleanLiteral -
3346 /// objc-scalar-literal : '@' boolean-keyword
3347 /// ;
3348 /// boolean-keyword: 'true' | 'false' | '__objc_yes' | '__objc_no'
3349 /// ;
ParseObjCBooleanLiteral(SourceLocation AtLoc,bool ArgValue)3350 ExprResult Parser::ParseObjCBooleanLiteral(SourceLocation AtLoc,
3351 bool ArgValue) {
3352 SourceLocation EndLoc = ConsumeToken(); // consume the keyword.
3353 return Actions.ActOnObjCBoolLiteral(AtLoc, EndLoc, ArgValue);
3354 }
3355
3356 /// ParseObjCCharacterLiteral -
3357 /// objc-scalar-literal : '@' character-literal
3358 /// ;
ParseObjCCharacterLiteral(SourceLocation AtLoc)3359 ExprResult Parser::ParseObjCCharacterLiteral(SourceLocation AtLoc) {
3360 ExprResult Lit(Actions.ActOnCharacterConstant(Tok));
3361 if (Lit.isInvalid()) {
3362 return Lit;
3363 }
3364 ConsumeToken(); // Consume the literal token.
3365 return Actions.BuildObjCNumericLiteral(AtLoc, Lit.get());
3366 }
3367
3368 /// ParseObjCNumericLiteral -
3369 /// objc-scalar-literal : '@' scalar-literal
3370 /// ;
3371 /// scalar-literal : | numeric-constant /* any numeric constant. */
3372 /// ;
ParseObjCNumericLiteral(SourceLocation AtLoc)3373 ExprResult Parser::ParseObjCNumericLiteral(SourceLocation AtLoc) {
3374 ExprResult Lit(Actions.ActOnNumericConstant(Tok));
3375 if (Lit.isInvalid()) {
3376 return Lit;
3377 }
3378 ConsumeToken(); // Consume the literal token.
3379 return Actions.BuildObjCNumericLiteral(AtLoc, Lit.get());
3380 }
3381
3382 /// ParseObjCBoxedExpr -
3383 /// objc-box-expression:
3384 /// @( assignment-expression )
3385 ExprResult
ParseObjCBoxedExpr(SourceLocation AtLoc)3386 Parser::ParseObjCBoxedExpr(SourceLocation AtLoc) {
3387 if (Tok.isNot(tok::l_paren))
3388 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@");
3389
3390 BalancedDelimiterTracker T(*this, tok::l_paren);
3391 T.consumeOpen();
3392 ExprResult ValueExpr(ParseAssignmentExpression());
3393 if (T.consumeClose())
3394 return ExprError();
3395
3396 if (ValueExpr.isInvalid())
3397 return ExprError();
3398
3399 // Wrap the sub-expression in a parenthesized expression, to distinguish
3400 // a boxed expression from a literal.
3401 SourceLocation LPLoc = T.getOpenLocation(), RPLoc = T.getCloseLocation();
3402 ValueExpr = Actions.ActOnParenExpr(LPLoc, RPLoc, ValueExpr.get());
3403 return Actions.BuildObjCBoxedExpr(SourceRange(AtLoc, RPLoc),
3404 ValueExpr.get());
3405 }
3406
ParseObjCArrayLiteral(SourceLocation AtLoc)3407 ExprResult Parser::ParseObjCArrayLiteral(SourceLocation AtLoc) {
3408 ExprVector ElementExprs; // array elements.
3409 ConsumeBracket(); // consume the l_square.
3410
3411 bool HasInvalidEltExpr = false;
3412 while (Tok.isNot(tok::r_square)) {
3413 // Parse list of array element expressions (all must be id types).
3414 ExprResult Res(ParseAssignmentExpression());
3415 if (Res.isInvalid()) {
3416 // We must manually skip to a ']', otherwise the expression skipper will
3417 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3418 // the enclosing expression.
3419 SkipUntil(tok::r_square, StopAtSemi);
3420 return Res;
3421 }
3422
3423 Res = Actions.CorrectDelayedTyposInExpr(Res.get());
3424 if (Res.isInvalid())
3425 HasInvalidEltExpr = true;
3426
3427 // Parse the ellipsis that indicates a pack expansion.
3428 if (Tok.is(tok::ellipsis))
3429 Res = Actions.ActOnPackExpansion(Res.get(), ConsumeToken());
3430 if (Res.isInvalid())
3431 HasInvalidEltExpr = true;
3432
3433 ElementExprs.push_back(Res.get());
3434
3435 if (Tok.is(tok::comma))
3436 ConsumeToken(); // Eat the ','.
3437 else if (Tok.isNot(tok::r_square))
3438 return ExprError(Diag(Tok, diag::err_expected_either) << tok::r_square
3439 << tok::comma);
3440 }
3441 SourceLocation EndLoc = ConsumeBracket(); // location of ']'
3442
3443 if (HasInvalidEltExpr)
3444 return ExprError();
3445
3446 MultiExprArg Args(ElementExprs);
3447 return Actions.BuildObjCArrayLiteral(SourceRange(AtLoc, EndLoc), Args);
3448 }
3449
ParseObjCDictionaryLiteral(SourceLocation AtLoc)3450 ExprResult Parser::ParseObjCDictionaryLiteral(SourceLocation AtLoc) {
3451 SmallVector<ObjCDictionaryElement, 4> Elements; // dictionary elements.
3452 ConsumeBrace(); // consume the l_square.
3453 bool HasInvalidEltExpr = false;
3454 while (Tok.isNot(tok::r_brace)) {
3455 // Parse the comma separated key : value expressions.
3456 ExprResult KeyExpr;
3457 {
3458 ColonProtectionRAIIObject X(*this);
3459 KeyExpr = ParseAssignmentExpression();
3460 if (KeyExpr.isInvalid()) {
3461 // We must manually skip to a '}', otherwise the expression skipper will
3462 // stop at the '}' when it skips to the ';'. We want it to skip beyond
3463 // the enclosing expression.
3464 SkipUntil(tok::r_brace, StopAtSemi);
3465 return KeyExpr;
3466 }
3467 }
3468
3469 if (ExpectAndConsume(tok::colon)) {
3470 SkipUntil(tok::r_brace, StopAtSemi);
3471 return ExprError();
3472 }
3473
3474 ExprResult ValueExpr(ParseAssignmentExpression());
3475 if (ValueExpr.isInvalid()) {
3476 // We must manually skip to a '}', otherwise the expression skipper will
3477 // stop at the '}' when it skips to the ';'. We want it to skip beyond
3478 // the enclosing expression.
3479 SkipUntil(tok::r_brace, StopAtSemi);
3480 return ValueExpr;
3481 }
3482
3483 // Check the key and value for possible typos
3484 KeyExpr = Actions.CorrectDelayedTyposInExpr(KeyExpr.get());
3485 ValueExpr = Actions.CorrectDelayedTyposInExpr(ValueExpr.get());
3486 if (KeyExpr.isInvalid() || ValueExpr.isInvalid())
3487 HasInvalidEltExpr = true;
3488
3489 // Parse the ellipsis that designates this as a pack expansion. Do not
3490 // ActOnPackExpansion here, leave it to template instantiation time where
3491 // we can get better diagnostics.
3492 SourceLocation EllipsisLoc;
3493 if (getLangOpts().CPlusPlus)
3494 TryConsumeToken(tok::ellipsis, EllipsisLoc);
3495
3496 // We have a valid expression. Collect it in a vector so we can
3497 // build the argument list.
3498 ObjCDictionaryElement Element = {
3499 KeyExpr.get(), ValueExpr.get(), EllipsisLoc, None
3500 };
3501 Elements.push_back(Element);
3502
3503 if (!TryConsumeToken(tok::comma) && Tok.isNot(tok::r_brace))
3504 return ExprError(Diag(Tok, diag::err_expected_either) << tok::r_brace
3505 << tok::comma);
3506 }
3507 SourceLocation EndLoc = ConsumeBrace();
3508
3509 if (HasInvalidEltExpr)
3510 return ExprError();
3511
3512 // Create the ObjCDictionaryLiteral.
3513 return Actions.BuildObjCDictionaryLiteral(SourceRange(AtLoc, EndLoc),
3514 Elements);
3515 }
3516
3517 /// objc-encode-expression:
3518 /// \@encode ( type-name )
3519 ExprResult
ParseObjCEncodeExpression(SourceLocation AtLoc)3520 Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) {
3521 assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!");
3522
3523 SourceLocation EncLoc = ConsumeToken();
3524
3525 if (Tok.isNot(tok::l_paren))
3526 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode");
3527
3528 BalancedDelimiterTracker T(*this, tok::l_paren);
3529 T.consumeOpen();
3530
3531 TypeResult Ty = ParseTypeName();
3532
3533 T.consumeClose();
3534
3535 if (Ty.isInvalid())
3536 return ExprError();
3537
3538 return Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, T.getOpenLocation(),
3539 Ty.get(), T.getCloseLocation());
3540 }
3541
3542 /// objc-protocol-expression
3543 /// \@protocol ( protocol-name )
3544 ExprResult
ParseObjCProtocolExpression(SourceLocation AtLoc)3545 Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) {
3546 SourceLocation ProtoLoc = ConsumeToken();
3547
3548 if (Tok.isNot(tok::l_paren))
3549 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol");
3550
3551 BalancedDelimiterTracker T(*this, tok::l_paren);
3552 T.consumeOpen();
3553
3554 if (expectIdentifier())
3555 return ExprError();
3556
3557 IdentifierInfo *protocolId = Tok.getIdentifierInfo();
3558 SourceLocation ProtoIdLoc = ConsumeToken();
3559
3560 T.consumeClose();
3561
3562 return Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc,
3563 T.getOpenLocation(), ProtoIdLoc,
3564 T.getCloseLocation());
3565 }
3566
3567 /// objc-selector-expression
3568 /// @selector '(' '('[opt] objc-keyword-selector ')'[opt] ')'
ParseObjCSelectorExpression(SourceLocation AtLoc)3569 ExprResult Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) {
3570 SourceLocation SelectorLoc = ConsumeToken();
3571
3572 if (Tok.isNot(tok::l_paren))
3573 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector");
3574
3575 SmallVector<IdentifierInfo *, 12> KeyIdents;
3576 SourceLocation sLoc;
3577
3578 BalancedDelimiterTracker T(*this, tok::l_paren);
3579 T.consumeOpen();
3580 bool HasOptionalParen = Tok.is(tok::l_paren);
3581 if (HasOptionalParen)
3582 ConsumeParen();
3583
3584 if (Tok.is(tok::code_completion)) {
3585 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents);
3586 cutOffParsing();
3587 return ExprError();
3588 }
3589
3590 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc);
3591 if (!SelIdent && // missing selector name.
3592 Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon))
3593 return ExprError(Diag(Tok, diag::err_expected) << tok::identifier);
3594
3595 KeyIdents.push_back(SelIdent);
3596
3597 unsigned nColons = 0;
3598 if (Tok.isNot(tok::r_paren)) {
3599 while (1) {
3600 if (TryConsumeToken(tok::coloncolon)) { // Handle :: in C++.
3601 ++nColons;
3602 KeyIdents.push_back(nullptr);
3603 } else if (ExpectAndConsume(tok::colon)) // Otherwise expect ':'.
3604 return ExprError();
3605 ++nColons;
3606
3607 if (Tok.is(tok::r_paren))
3608 break;
3609
3610 if (Tok.is(tok::code_completion)) {
3611 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents);
3612 cutOffParsing();
3613 return ExprError();
3614 }
3615
3616 // Check for another keyword selector.
3617 SourceLocation Loc;
3618 SelIdent = ParseObjCSelectorPiece(Loc);
3619 KeyIdents.push_back(SelIdent);
3620 if (!SelIdent && Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon))
3621 break;
3622 }
3623 }
3624 if (HasOptionalParen && Tok.is(tok::r_paren))
3625 ConsumeParen(); // ')'
3626 T.consumeClose();
3627 Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]);
3628 return Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc,
3629 T.getOpenLocation(),
3630 T.getCloseLocation(),
3631 !HasOptionalParen);
3632 }
3633
ParseLexedObjCMethodDefs(LexedMethod & LM,bool parseMethod)3634 void Parser::ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod) {
3635 // MCDecl might be null due to error in method or c-function prototype, etc.
3636 Decl *MCDecl = LM.D;
3637 bool skip = MCDecl &&
3638 ((parseMethod && !Actions.isObjCMethodDecl(MCDecl)) ||
3639 (!parseMethod && Actions.isObjCMethodDecl(MCDecl)));
3640 if (skip)
3641 return;
3642
3643 // Save the current token position.
3644 SourceLocation OrigLoc = Tok.getLocation();
3645
3646 assert(!LM.Toks.empty() && "ParseLexedObjCMethodDef - Empty body!");
3647 // Store an artificial EOF token to ensure that we don't run off the end of
3648 // the method's body when we come to parse it.
3649 Token Eof;
3650 Eof.startToken();
3651 Eof.setKind(tok::eof);
3652 Eof.setEofData(MCDecl);
3653 Eof.setLocation(OrigLoc);
3654 LM.Toks.push_back(Eof);
3655 // Append the current token at the end of the new token stream so that it
3656 // doesn't get lost.
3657 LM.Toks.push_back(Tok);
3658 PP.EnterTokenStream(LM.Toks, true, /*IsReinject*/true);
3659
3660 // Consume the previously pushed token.
3661 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
3662
3663 assert(Tok.isOneOf(tok::l_brace, tok::kw_try, tok::colon) &&
3664 "Inline objective-c method not starting with '{' or 'try' or ':'");
3665 // Enter a scope for the method or c-function body.
3666 ParseScope BodyScope(this, (parseMethod ? Scope::ObjCMethodScope : 0) |
3667 Scope::FnScope | Scope::DeclScope |
3668 Scope::CompoundStmtScope);
3669
3670 // Tell the actions module that we have entered a method or c-function definition
3671 // with the specified Declarator for the method/function.
3672 if (parseMethod)
3673 Actions.ActOnStartOfObjCMethodDef(getCurScope(), MCDecl);
3674 else
3675 Actions.ActOnStartOfFunctionDef(getCurScope(), MCDecl);
3676 if (Tok.is(tok::kw_try))
3677 ParseFunctionTryBlock(MCDecl, BodyScope);
3678 else {
3679 if (Tok.is(tok::colon))
3680 ParseConstructorInitializer(MCDecl);
3681 else
3682 Actions.ActOnDefaultCtorInitializers(MCDecl);
3683 ParseFunctionStatementBody(MCDecl, BodyScope);
3684 }
3685
3686 if (Tok.getLocation() != OrigLoc) {
3687 // Due to parsing error, we either went over the cached tokens or
3688 // there are still cached tokens left. If it's the latter case skip the
3689 // leftover tokens.
3690 // Since this is an uncommon situation that should be avoided, use the
3691 // expensive isBeforeInTranslationUnit call.
3692 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(),
3693 OrigLoc))
3694 while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof))
3695 ConsumeAnyToken();
3696 }
3697 // Clean up the remaining EOF token.
3698 ConsumeAnyToken();
3699 }
3700