1 //===--- ParseObjC.cpp - Objective C Parsing ------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file implements the Objective-C portions of the Parser interface.
11 //===----------------------------------------------------------------------===//
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/ODRDiagsEmitter.h"
15 #include "clang/AST/PrettyDeclStackTrace.h"
16 #include "clang/Basic/CharInfo.h"
17 #include "clang/Basic/TargetInfo.h"
18 #include "clang/Parse/ParseDiagnostic.h"
19 #include "clang/Parse/Parser.h"
20 #include "clang/Parse/RAIIObjectsForParser.h"
21 #include "clang/Sema/DeclSpec.h"
22 #include "clang/Sema/Scope.h"
23 #include "llvm/ADT/SmallVector.h"
24 #include "llvm/ADT/StringExtras.h"
26 using namespace clang
;
28 /// Skips attributes after an Objective-C @ directive. Emits a diagnostic.
29 void Parser::MaybeSkipAttributes(tok::ObjCKeywordKind Kind
) {
30 ParsedAttributes
attrs(AttrFactory
);
31 if (Tok
.is(tok::kw___attribute
)) {
32 if (Kind
== tok::objc_interface
|| Kind
== tok::objc_protocol
)
33 Diag(Tok
, diag::err_objc_postfix_attribute_hint
)
34 << (Kind
== tok::objc_protocol
);
36 Diag(Tok
, diag::err_objc_postfix_attribute
);
37 ParseGNUAttributes(attrs
);
41 /// ParseObjCAtDirectives - Handle parts of the external-declaration production:
42 /// external-declaration: [C99 6.9]
43 /// [OBJC] objc-class-definition
44 /// [OBJC] objc-class-declaration
45 /// [OBJC] objc-alias-declaration
46 /// [OBJC] objc-protocol-definition
47 /// [OBJC] objc-method-definition
49 Parser::DeclGroupPtrTy
50 Parser::ParseObjCAtDirectives(ParsedAttributes
&DeclAttrs
,
51 ParsedAttributes
&DeclSpecAttrs
) {
52 DeclAttrs
.takeAllFrom(DeclSpecAttrs
);
54 SourceLocation AtLoc
= ConsumeToken(); // the "@"
56 if (Tok
.is(tok::code_completion
)) {
58 Actions
.CodeCompleteObjCAtDirective(getCurScope());
62 switch (Tok
.getObjCKeywordID()) {
63 case tok::objc_interface
:
64 case tok::objc_protocol
:
65 case tok::objc_implementation
:
68 for (const auto &Attr
: DeclAttrs
) {
69 if (Attr
.isGNUAttribute())
70 Diag(Tok
.getLocation(), diag::err_objc_unexpected_attr
);
74 Decl
*SingleDecl
= nullptr;
75 switch (Tok
.getObjCKeywordID()) {
77 return ParseObjCAtClassDeclaration(AtLoc
);
78 case tok::objc_interface
:
79 SingleDecl
= ParseObjCAtInterfaceDeclaration(AtLoc
, DeclAttrs
);
81 case tok::objc_protocol
:
82 return ParseObjCAtProtocolDeclaration(AtLoc
, DeclAttrs
);
83 case tok::objc_implementation
:
84 return ParseObjCAtImplementationDeclaration(AtLoc
, DeclAttrs
);
86 return ParseObjCAtEndDeclaration(AtLoc
);
87 case tok::objc_compatibility_alias
:
88 SingleDecl
= ParseObjCAtAliasDeclaration(AtLoc
);
90 case tok::objc_synthesize
:
91 SingleDecl
= ParseObjCPropertySynthesize(AtLoc
);
93 case tok::objc_dynamic
:
94 SingleDecl
= ParseObjCPropertyDynamic(AtLoc
);
96 case tok::objc_import
:
97 if (getLangOpts().Modules
|| getLangOpts().DebuggerSupport
) {
98 Sema::ModuleImportState IS
= Sema::ModuleImportState::NotACXX20Module
;
99 SingleDecl
= ParseModuleImport(AtLoc
, IS
);
102 Diag(AtLoc
, diag::err_atimport
);
103 SkipUntil(tok::semi
);
104 return Actions
.ConvertDeclToDeclGroup(nullptr);
106 Diag(AtLoc
, diag::err_unexpected_at
);
107 SkipUntil(tok::semi
);
108 SingleDecl
= nullptr;
111 return Actions
.ConvertDeclToDeclGroup(SingleDecl
);
114 /// Class to handle popping type parameters when leaving the scope.
115 class Parser::ObjCTypeParamListScope
{
118 ObjCTypeParamList
*Params
;
121 ObjCTypeParamListScope(Sema
&Actions
, Scope
*S
)
122 : Actions(Actions
), S(S
), Params(nullptr) {}
124 ~ObjCTypeParamListScope() {
128 void enter(ObjCTypeParamList
*P
) {
135 Actions
.popObjCTypeParamList(S
, Params
);
141 /// objc-class-declaration:
142 /// '@' 'class' objc-class-forward-decl (',' objc-class-forward-decl)* ';'
144 /// objc-class-forward-decl:
145 /// identifier objc-type-parameter-list[opt]
147 Parser::DeclGroupPtrTy
148 Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc
) {
149 ConsumeToken(); // the identifier "class"
150 SmallVector
<IdentifierInfo
*, 8> ClassNames
;
151 SmallVector
<SourceLocation
, 8> ClassLocs
;
152 SmallVector
<ObjCTypeParamList
*, 8> ClassTypeParams
;
155 MaybeSkipAttributes(tok::objc_class
);
156 if (Tok
.is(tok::code_completion
)) {
158 Actions
.CodeCompleteObjCClassForwardDecl(getCurScope());
159 return Actions
.ConvertDeclToDeclGroup(nullptr);
161 if (expectIdentifier()) {
162 SkipUntil(tok::semi
);
163 return Actions
.ConvertDeclToDeclGroup(nullptr);
165 ClassNames
.push_back(Tok
.getIdentifierInfo());
166 ClassLocs
.push_back(Tok
.getLocation());
169 // Parse the optional objc-type-parameter-list.
170 ObjCTypeParamList
*TypeParams
= nullptr;
171 if (Tok
.is(tok::less
))
172 TypeParams
= parseObjCTypeParamList();
173 ClassTypeParams
.push_back(TypeParams
);
174 if (!TryConsumeToken(tok::comma
))
179 if (ExpectAndConsume(tok::semi
, diag::err_expected_after
, "@class"))
180 return Actions
.ConvertDeclToDeclGroup(nullptr);
182 return Actions
.ActOnForwardClassDeclaration(atLoc
, ClassNames
.data(),
188 void Parser::CheckNestedObjCContexts(SourceLocation AtLoc
)
190 Sema::ObjCContainerKind ock
= Actions
.getObjCContainerKind();
191 if (ock
== Sema::OCK_None
)
194 Decl
*Decl
= Actions
.getObjCDeclContext();
195 if (CurParsedObjCImpl
) {
196 CurParsedObjCImpl
->finish(AtLoc
);
198 Actions
.ActOnAtEnd(getCurScope(), AtLoc
);
200 Diag(AtLoc
, diag::err_objc_missing_end
)
201 << FixItHint::CreateInsertion(AtLoc
, "@end\n");
203 Diag(Decl
->getBeginLoc(), diag::note_objc_container_start
) << (int)ock
;
208 /// objc-class-interface-attributes[opt] objc-class-interface
209 /// objc-category-interface
211 /// objc-class-interface:
212 /// '@' 'interface' identifier objc-type-parameter-list[opt]
213 /// objc-superclass[opt] objc-protocol-refs[opt]
214 /// objc-class-instance-variables[opt]
215 /// objc-interface-decl-list
218 /// objc-category-interface:
219 /// '@' 'interface' identifier objc-type-parameter-list[opt]
220 /// '(' identifier[opt] ')' objc-protocol-refs[opt]
221 /// objc-interface-decl-list
225 /// ':' identifier objc-type-arguments[opt]
227 /// objc-class-interface-attributes:
228 /// __attribute__((visibility("default")))
229 /// __attribute__((visibility("hidden")))
230 /// __attribute__((deprecated))
231 /// __attribute__((unavailable))
232 /// __attribute__((objc_exception)) - used by NSException on 64-bit
233 /// __attribute__((objc_root_class))
235 Decl
*Parser::ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc
,
236 ParsedAttributes
&attrs
) {
237 assert(Tok
.isObjCAtKeyword(tok::objc_interface
) &&
238 "ParseObjCAtInterfaceDeclaration(): Expected @interface");
239 CheckNestedObjCContexts(AtLoc
);
240 ConsumeToken(); // the "interface" identifier
242 // Code completion after '@interface'.
243 if (Tok
.is(tok::code_completion
)) {
245 Actions
.CodeCompleteObjCInterfaceDecl(getCurScope());
249 MaybeSkipAttributes(tok::objc_interface
);
251 if (expectIdentifier())
252 return nullptr; // missing class or category name.
254 // We have a class or category name - consume it.
255 IdentifierInfo
*nameId
= Tok
.getIdentifierInfo();
256 SourceLocation nameLoc
= ConsumeToken();
258 // Parse the objc-type-parameter-list or objc-protocol-refs. For the latter
259 // case, LAngleLoc will be valid and ProtocolIdents will capture the
260 // protocol references (that have not yet been resolved).
261 SourceLocation LAngleLoc
, EndProtoLoc
;
262 SmallVector
<IdentifierLocPair
, 8> ProtocolIdents
;
263 ObjCTypeParamList
*typeParameterList
= nullptr;
264 ObjCTypeParamListScope
typeParamScope(Actions
, getCurScope());
265 if (Tok
.is(tok::less
))
266 typeParameterList
= parseObjCTypeParamListOrProtocolRefs(
267 typeParamScope
, LAngleLoc
, ProtocolIdents
, EndProtoLoc
);
269 if (Tok
.is(tok::l_paren
) &&
270 !isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { // we have a category.
272 BalancedDelimiterTracker
T(*this, tok::l_paren
);
275 SourceLocation categoryLoc
;
276 IdentifierInfo
*categoryId
= nullptr;
277 if (Tok
.is(tok::code_completion
)) {
279 Actions
.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId
, nameLoc
);
283 // For ObjC2, the category name is optional (not an error).
284 if (Tok
.is(tok::identifier
)) {
285 categoryId
= Tok
.getIdentifierInfo();
286 categoryLoc
= ConsumeToken();
288 else if (!getLangOpts().ObjC
) {
289 Diag(Tok
, diag::err_expected
)
290 << tok::identifier
; // missing category name.
295 if (T
.getCloseLocation().isInvalid())
298 // Next, we need to check for any protocol references.
299 assert(LAngleLoc
.isInvalid() && "Cannot have already parsed protocols");
300 SmallVector
<Decl
*, 8> ProtocolRefs
;
301 SmallVector
<SourceLocation
, 8> ProtocolLocs
;
302 if (Tok
.is(tok::less
) &&
303 ParseObjCProtocolReferences(ProtocolRefs
, ProtocolLocs
, true, true,
304 LAngleLoc
, EndProtoLoc
,
305 /*consumeLastToken=*/true))
308 ObjCCategoryDecl
*CategoryType
= Actions
.ActOnStartCategoryInterface(
309 AtLoc
, nameId
, nameLoc
, typeParameterList
, categoryId
, categoryLoc
,
310 ProtocolRefs
.data(), ProtocolRefs
.size(), ProtocolLocs
.data(),
313 if (Tok
.is(tok::l_brace
))
314 ParseObjCClassInstanceVariables(CategoryType
, tok::objc_private
, AtLoc
);
316 ParseObjCInterfaceDeclList(tok::objc_not_keyword
, CategoryType
);
320 // Parse a class interface.
321 IdentifierInfo
*superClassId
= nullptr;
322 SourceLocation superClassLoc
;
323 SourceLocation typeArgsLAngleLoc
;
324 SmallVector
<ParsedType
, 4> typeArgs
;
325 SourceLocation typeArgsRAngleLoc
;
326 SmallVector
<Decl
*, 4> protocols
;
327 SmallVector
<SourceLocation
, 4> protocolLocs
;
328 if (Tok
.is(tok::colon
)) { // a super class is specified.
331 // Code completion of superclass names.
332 if (Tok
.is(tok::code_completion
)) {
334 Actions
.CodeCompleteObjCSuperclass(getCurScope(), nameId
, nameLoc
);
338 if (expectIdentifier())
339 return nullptr; // missing super class name.
340 superClassId
= Tok
.getIdentifierInfo();
341 superClassLoc
= ConsumeToken();
343 // Type arguments for the superclass or protocol conformances.
344 if (Tok
.is(tok::less
)) {
345 parseObjCTypeArgsOrProtocolQualifiers(
346 nullptr, typeArgsLAngleLoc
, typeArgs
, typeArgsRAngleLoc
, LAngleLoc
,
347 protocols
, protocolLocs
, EndProtoLoc
,
348 /*consumeLastToken=*/true,
349 /*warnOnIncompleteProtocols=*/true);
350 if (Tok
.is(tok::eof
))
355 // Next, we need to check for any protocol references.
356 if (LAngleLoc
.isValid()) {
357 if (!ProtocolIdents
.empty()) {
358 // We already parsed the protocols named when we thought we had a
359 // type parameter list. Translate them into actual protocol references.
360 for (const auto &pair
: ProtocolIdents
) {
361 protocolLocs
.push_back(pair
.second
);
363 Actions
.FindProtocolDeclaration(/*WarnOnDeclarations=*/true,
364 /*ForObjCContainer=*/true,
365 ProtocolIdents
, protocols
);
367 } else if (protocols
.empty() && Tok
.is(tok::less
) &&
368 ParseObjCProtocolReferences(protocols
, protocolLocs
, true, true,
369 LAngleLoc
, EndProtoLoc
,
370 /*consumeLastToken=*/true)) {
374 if (Tok
.isNot(tok::less
))
375 Actions
.ActOnTypedefedProtocols(protocols
, protocolLocs
,
376 superClassId
, superClassLoc
);
378 Sema::SkipBodyInfo SkipBody
;
379 ObjCInterfaceDecl
*ClsType
= Actions
.ActOnStartClassInterface(
380 getCurScope(), AtLoc
, nameId
, nameLoc
, typeParameterList
, superClassId
,
381 superClassLoc
, typeArgs
,
382 SourceRange(typeArgsLAngleLoc
, typeArgsRAngleLoc
), protocols
.data(),
383 protocols
.size(), protocolLocs
.data(), EndProtoLoc
, attrs
, &SkipBody
);
385 if (Tok
.is(tok::l_brace
))
386 ParseObjCClassInstanceVariables(ClsType
, tok::objc_protected
, AtLoc
);
388 ParseObjCInterfaceDeclList(tok::objc_interface
, ClsType
);
390 if (SkipBody
.CheckSameAsPrevious
) {
391 auto *PreviousDef
= cast
<ObjCInterfaceDecl
>(SkipBody
.Previous
);
392 if (Actions
.ActOnDuplicateODRHashDefinition(ClsType
, PreviousDef
)) {
393 ClsType
->mergeDuplicateDefinitionWithCommon(PreviousDef
->getDefinition());
395 ODRDiagsEmitter
DiagsEmitter(Diags
, Actions
.getASTContext(),
396 getPreprocessor().getLangOpts());
397 DiagsEmitter
.diagnoseMismatch(PreviousDef
, ClsType
);
398 ClsType
->setInvalidDecl();
405 /// Add an attribute for a context-sensitive type nullability to the given
407 static void addContextSensitiveTypeNullability(Parser
&P
,
409 NullabilityKind nullability
,
410 SourceLocation nullabilityLoc
,
411 bool &addedToDeclSpec
) {
412 // Create the attribute.
413 auto getNullabilityAttr
= [&](AttributePool
&Pool
) -> ParsedAttr
* {
414 return Pool
.create(P
.getNullabilityKeyword(nullability
),
415 SourceRange(nullabilityLoc
), nullptr, SourceLocation(),
416 nullptr, 0, ParsedAttr::Form::ContextSensitiveKeyword());
419 if (D
.getNumTypeObjects() > 0) {
420 // Add the attribute to the declarator chunk nearest the declarator.
421 D
.getTypeObject(0).getAttrs().addAtEnd(
422 getNullabilityAttr(D
.getAttributePool()));
423 } else if (!addedToDeclSpec
) {
424 // Otherwise, just put it on the declaration specifiers (if one
425 // isn't there already).
426 D
.getMutableDeclSpec().getAttributes().addAtEnd(
427 getNullabilityAttr(D
.getMutableDeclSpec().getAttributes().getPool()));
428 addedToDeclSpec
= true;
432 /// Parse an Objective-C type parameter list, if present, or capture
433 /// the locations of the protocol identifiers for a list of protocol
436 /// objc-type-parameter-list:
437 /// '<' objc-type-parameter (',' objc-type-parameter)* '>'
439 /// objc-type-parameter:
440 /// objc-type-parameter-variance? identifier objc-type-parameter-bound[opt]
442 /// objc-type-parameter-bound:
445 /// objc-type-parameter-variance:
447 /// '__contravariant'
449 /// \param lAngleLoc The location of the starting '<'.
451 /// \param protocolIdents Will capture the list of identifiers, if the
452 /// angle brackets contain a list of protocol references rather than a
453 /// type parameter list.
455 /// \param rAngleLoc The location of the ending '>'.
456 ObjCTypeParamList
*Parser::parseObjCTypeParamListOrProtocolRefs(
457 ObjCTypeParamListScope
&Scope
, SourceLocation
&lAngleLoc
,
458 SmallVectorImpl
<IdentifierLocPair
> &protocolIdents
,
459 SourceLocation
&rAngleLoc
, bool mayBeProtocolList
) {
460 assert(Tok
.is(tok::less
) && "Not at the beginning of a type parameter list");
462 // Within the type parameter list, don't treat '>' as an operator.
463 GreaterThanIsOperatorScope
G(GreaterThanIsOperator
, false);
465 // Local function to "flush" the protocol identifiers, turning them into
467 SmallVector
<Decl
*, 4> typeParams
;
468 auto makeProtocolIdentsIntoTypeParameters
= [&]() {
470 for (const auto &pair
: protocolIdents
) {
471 DeclResult typeParam
= Actions
.actOnObjCTypeParam(
472 getCurScope(), ObjCTypeParamVariance::Invariant
, SourceLocation(),
473 index
++, pair
.first
, pair
.second
, SourceLocation(), nullptr);
474 if (typeParam
.isUsable())
475 typeParams
.push_back(typeParam
.get());
478 protocolIdents
.clear();
479 mayBeProtocolList
= false;
482 bool invalid
= false;
483 lAngleLoc
= ConsumeToken();
486 // Parse the variance, if any.
487 SourceLocation varianceLoc
;
488 ObjCTypeParamVariance variance
= ObjCTypeParamVariance::Invariant
;
489 if (Tok
.is(tok::kw___covariant
) || Tok
.is(tok::kw___contravariant
)) {
490 variance
= Tok
.is(tok::kw___covariant
)
491 ? ObjCTypeParamVariance::Covariant
492 : ObjCTypeParamVariance::Contravariant
;
493 varianceLoc
= ConsumeToken();
495 // Once we've seen a variance specific , we know this is not a
496 // list of protocol references.
497 if (mayBeProtocolList
) {
498 // Up until now, we have been queuing up parameters because they
499 // might be protocol references. Turn them into parameters now.
500 makeProtocolIdentsIntoTypeParameters();
504 // Parse the identifier.
505 if (!Tok
.is(tok::identifier
)) {
507 if (Tok
.is(tok::code_completion
)) {
508 // FIXME: If these aren't protocol references, we'll need different
511 Actions
.CodeCompleteObjCProtocolReferences(protocolIdents
);
513 // FIXME: Better recovery here?.
517 Diag(Tok
, diag::err_objc_expected_type_parameter
);
522 IdentifierInfo
*paramName
= Tok
.getIdentifierInfo();
523 SourceLocation paramLoc
= ConsumeToken();
525 // If there is a bound, parse it.
526 SourceLocation colonLoc
;
527 TypeResult boundType
;
528 if (TryConsumeToken(tok::colon
, colonLoc
)) {
529 // Once we've seen a bound, we know this is not a list of protocol
531 if (mayBeProtocolList
) {
532 // Up until now, we have been queuing up parameters because they
533 // might be protocol references. Turn them into parameters now.
534 makeProtocolIdentsIntoTypeParameters();
538 boundType
= ParseTypeName();
539 if (boundType
.isInvalid())
541 } else if (mayBeProtocolList
) {
542 // If this could still be a protocol list, just capture the identifier.
543 // We don't want to turn it into a parameter.
544 protocolIdents
.push_back(std::make_pair(paramName
, paramLoc
));
548 // Create the type parameter.
549 DeclResult typeParam
= Actions
.actOnObjCTypeParam(
550 getCurScope(), variance
, varianceLoc
, typeParams
.size(), paramName
,
551 paramLoc
, colonLoc
, boundType
.isUsable() ? boundType
.get() : nullptr);
552 if (typeParam
.isUsable())
553 typeParams
.push_back(typeParam
.get());
554 } while (TryConsumeToken(tok::comma
));
558 SkipUntil(tok::greater
, tok::at
, StopBeforeMatch
);
559 if (Tok
.is(tok::greater
))
561 } else if (ParseGreaterThanInTemplateList(lAngleLoc
, rAngleLoc
,
562 /*ConsumeLastToken=*/true,
563 /*ObjCGenericList=*/true)) {
564 SkipUntil({tok::greater
, tok::greaterequal
, tok::at
, tok::minus
,
565 tok::minus
, tok::plus
, tok::colon
, tok::l_paren
, tok::l_brace
,
566 tok::comma
, tok::semi
},
568 if (Tok
.is(tok::greater
))
572 if (mayBeProtocolList
) {
573 // A type parameter list must be followed by either a ':' (indicating the
574 // presence of a superclass) or a '(' (indicating that this is a category
575 // or extension). This disambiguates between an objc-type-parameter-list
576 // and a objc-protocol-refs.
577 if (Tok
.isNot(tok::colon
) && Tok
.isNot(tok::l_paren
)) {
578 // Returning null indicates that we don't have a type parameter list.
579 // The results the caller needs to handle the protocol references are
580 // captured in the reference parameters already.
584 // We have a type parameter list that looks like a list of protocol
585 // references. Turn that parameter list into type parameters.
586 makeProtocolIdentsIntoTypeParameters();
589 // Form the type parameter list and enter its scope.
590 ObjCTypeParamList
*list
= Actions
.actOnObjCTypeParamList(
597 // Clear out the angle locations; they're used by the caller to indicate
598 // whether there are any protocol references.
599 lAngleLoc
= SourceLocation();
600 rAngleLoc
= SourceLocation();
601 return invalid
? nullptr : list
;
604 /// Parse an objc-type-parameter-list.
605 ObjCTypeParamList
*Parser::parseObjCTypeParamList() {
606 SourceLocation lAngleLoc
;
607 SmallVector
<IdentifierLocPair
, 1> protocolIdents
;
608 SourceLocation rAngleLoc
;
610 ObjCTypeParamListScope
Scope(Actions
, getCurScope());
611 return parseObjCTypeParamListOrProtocolRefs(Scope
, lAngleLoc
, protocolIdents
,
613 /*mayBeProtocolList=*/false);
616 static bool isTopLevelObjCKeyword(tok::ObjCKeywordKind DirectiveKind
) {
617 switch (DirectiveKind
) {
618 case tok::objc_class
:
619 case tok::objc_compatibility_alias
:
620 case tok::objc_interface
:
621 case tok::objc_implementation
:
622 case tok::objc_protocol
:
629 /// objc-interface-decl-list:
631 /// objc-interface-decl-list objc-property-decl [OBJC2]
632 /// objc-interface-decl-list objc-method-requirement [OBJC2]
633 /// objc-interface-decl-list objc-method-proto ';'
634 /// objc-interface-decl-list declaration
635 /// objc-interface-decl-list ';'
637 /// objc-method-requirement: [OBJC2]
641 void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey
,
643 SmallVector
<Decl
*, 32> allMethods
;
644 SmallVector
<DeclGroupPtrTy
, 8> allTUVariables
;
645 tok::ObjCKeywordKind MethodImplKind
= tok::objc_not_keyword
;
650 // If this is a method prototype, parse it.
651 if (Tok
.isOneOf(tok::minus
, tok::plus
)) {
652 if (Decl
*methodPrototype
=
653 ParseObjCMethodPrototype(MethodImplKind
, false))
654 allMethods
.push_back(methodPrototype
);
655 // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for
656 // method definitions.
657 if (ExpectAndConsumeSemi(diag::err_expected_semi_after_method_proto
)) {
658 // We didn't find a semi and we error'ed out. Skip until a ';' or '@'.
659 SkipUntil(tok::at
, StopAtSemi
| StopBeforeMatch
);
660 if (Tok
.is(tok::semi
))
665 if (Tok
.is(tok::l_paren
)) {
666 Diag(Tok
, diag::err_expected_minus_or_plus
);
667 ParseObjCMethodDecl(Tok
.getLocation(),
669 MethodImplKind
, false);
672 // Ignore excess semicolons.
673 if (Tok
.is(tok::semi
)) {
674 // FIXME: This should use ConsumeExtraSemi() for extraneous semicolons,
675 // to make -Wextra-semi diagnose them.
680 // If we got to the end of the file, exit the loop.
684 // Code completion within an Objective-C interface.
685 if (Tok
.is(tok::code_completion
)) {
687 Actions
.CodeCompleteOrdinaryName(getCurScope(),
688 CurParsedObjCImpl
? Sema::PCC_ObjCImplementation
689 : Sema::PCC_ObjCInterface
);
693 // If we don't have an @ directive, parse it as a function definition.
694 if (Tok
.isNot(tok::at
)) {
695 // The code below does not consume '}'s because it is afraid of eating the
696 // end of a namespace. Because of the way this code is structured, an
697 // erroneous r_brace would cause an infinite loop if not handled here.
698 if (Tok
.is(tok::r_brace
))
701 ParsedAttributes
EmptyDeclAttrs(AttrFactory
);
702 ParsedAttributes
EmptyDeclSpecAttrs(AttrFactory
);
704 // Since we call ParseDeclarationOrFunctionDefinition() instead of
705 // ParseExternalDeclaration() below (so that this doesn't parse nested
706 // @interfaces), this needs to duplicate some code from the latter.
707 if (Tok
.isOneOf(tok::kw_static_assert
, tok::kw__Static_assert
)) {
708 SourceLocation DeclEnd
;
709 ParsedAttributes
EmptyDeclSpecAttrs(AttrFactory
);
710 allTUVariables
.push_back(ParseDeclaration(DeclaratorContext::File
,
711 DeclEnd
, EmptyDeclAttrs
,
712 EmptyDeclSpecAttrs
));
716 allTUVariables
.push_back(ParseDeclarationOrFunctionDefinition(
717 EmptyDeclAttrs
, EmptyDeclSpecAttrs
));
721 // Otherwise, we have an @ directive, peak at the next token
722 SourceLocation AtLoc
= Tok
.getLocation();
723 const auto &NextTok
= NextToken();
724 if (NextTok
.is(tok::code_completion
)) {
726 Actions
.CodeCompleteObjCAtDirective(getCurScope());
730 tok::ObjCKeywordKind DirectiveKind
= NextTok
.getObjCKeywordID();
731 if (DirectiveKind
== tok::objc_end
) { // @end -> terminate list
732 ConsumeToken(); // the "@"
733 AtEnd
.setBegin(AtLoc
);
734 AtEnd
.setEnd(Tok
.getLocation());
736 } else if (DirectiveKind
== tok::objc_not_keyword
) {
737 Diag(NextTok
, diag::err_objc_unknown_at
);
738 SkipUntil(tok::semi
);
742 // If we see something like '@interface' that's only allowed at the top
743 // level, bail out as if we saw an '@end'. We'll diagnose this below.
744 if (isTopLevelObjCKeyword(DirectiveKind
))
747 // Otherwise parse it as part of the current declaration. Eat "@identifier".
751 switch (DirectiveKind
) {
753 // FIXME: If someone forgets an @end on a protocol, this loop will
754 // continue to eat up tons of stuff and spew lots of nonsense errors. It
755 // would probably be better to bail out if we saw an @class or @interface
756 // or something like that.
757 Diag(AtLoc
, diag::err_objc_illegal_interface_qual
);
758 // Skip until we see an '@' or '}' or ';'.
759 SkipUntil(tok::r_brace
, tok::at
, StopAtSemi
);
762 case tok::objc_required
:
763 case tok::objc_optional
:
764 // This is only valid on protocols.
765 if (contextKey
!= tok::objc_protocol
)
766 Diag(AtLoc
, diag::err_objc_directive_only_in_protocol
);
768 MethodImplKind
= DirectiveKind
;
771 case tok::objc_property
:
773 SourceLocation LParenLoc
;
774 // Parse property attribute list, if any.
775 if (Tok
.is(tok::l_paren
)) {
776 LParenLoc
= Tok
.getLocation();
777 ParseObjCPropertyAttribute(OCDS
);
780 bool addedToDeclSpec
= false;
781 auto ObjCPropertyCallback
= [&](ParsingFieldDeclarator
&FD
) {
782 if (FD
.D
.getIdentifier() == nullptr) {
783 Diag(AtLoc
, diag::err_objc_property_requires_field_name
)
784 << FD
.D
.getSourceRange();
787 if (FD
.BitfieldSize
) {
788 Diag(AtLoc
, diag::err_objc_property_bitfield
)
789 << FD
.D
.getSourceRange();
793 // Map a nullability property attribute to a context-sensitive keyword
795 if (OCDS
.getPropertyAttributes() &
796 ObjCPropertyAttribute::kind_nullability
)
797 addContextSensitiveTypeNullability(*this, FD
.D
, OCDS
.getNullability(),
798 OCDS
.getNullabilityLoc(),
801 // Install the property declarator into interfaceDecl.
802 IdentifierInfo
*SelName
=
803 OCDS
.getGetterName() ? OCDS
.getGetterName() : FD
.D
.getIdentifier();
805 Selector GetterSel
= PP
.getSelectorTable().getNullarySelector(SelName
);
806 IdentifierInfo
*SetterName
= OCDS
.getSetterName();
809 SetterSel
= PP
.getSelectorTable().getSelector(1, &SetterName
);
811 SetterSel
= SelectorTable::constructSetterSelector(
812 PP
.getIdentifierTable(), PP
.getSelectorTable(),
813 FD
.D
.getIdentifier());
814 Decl
*Property
= Actions
.ActOnProperty(
815 getCurScope(), AtLoc
, LParenLoc
, FD
, OCDS
, GetterSel
, SetterSel
,
818 FD
.complete(Property
);
821 // Parse all the comma separated declarators.
822 ParsingDeclSpec
DS(*this);
823 ParseStructDeclaration(DS
, ObjCPropertyCallback
);
825 ExpectAndConsume(tok::semi
, diag::err_expected_semi_decl_list
);
830 // We break out of the big loop in 3 cases: when we see @end or when we see
831 // top-level ObjC keyword or EOF. In the former case, eat the @end. In the
832 // later cases, emit an error.
833 if (Tok
.isObjCAtKeyword(tok::objc_end
)) {
834 ConsumeToken(); // the "end" identifier
836 Diag(Tok
, diag::err_objc_missing_end
)
837 << FixItHint::CreateInsertion(Tok
.getLocation(), "\n@end\n");
838 Diag(CDecl
->getBeginLoc(), diag::note_objc_container_start
)
839 << (int)Actions
.getObjCContainerKind();
840 AtEnd
.setBegin(Tok
.getLocation());
841 AtEnd
.setEnd(Tok
.getLocation());
844 // Insert collected methods declarations into the @interface object.
845 // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit.
846 Actions
.ActOnAtEnd(getCurScope(), AtEnd
, allMethods
, allTUVariables
);
849 /// Diagnose redundant or conflicting nullability information.
850 static void diagnoseRedundantPropertyNullability(Parser
&P
,
852 NullabilityKind nullability
,
853 SourceLocation nullabilityLoc
){
854 if (DS
.getNullability() == nullability
) {
855 P
.Diag(nullabilityLoc
, diag::warn_nullability_duplicate
)
856 << DiagNullabilityKind(nullability
, true)
857 << SourceRange(DS
.getNullabilityLoc());
861 P
.Diag(nullabilityLoc
, diag::err_nullability_conflicting
)
862 << DiagNullabilityKind(nullability
, true)
863 << DiagNullabilityKind(DS
.getNullability(), true)
864 << SourceRange(DS
.getNullabilityLoc());
867 /// Parse property attribute declarations.
869 /// property-attr-decl: '(' property-attrlist ')'
870 /// property-attrlist:
871 /// property-attribute
872 /// property-attrlist ',' property-attribute
873 /// property-attribute:
874 /// getter '=' identifier
875 /// setter '=' identifier ':'
886 /// unsafe_unretained
893 void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec
&DS
) {
894 assert(Tok
.getKind() == tok::l_paren
);
895 BalancedDelimiterTracker
T(*this, tok::l_paren
);
899 if (Tok
.is(tok::code_completion
)) {
901 Actions
.CodeCompleteObjCPropertyFlags(getCurScope(), DS
);
904 const IdentifierInfo
*II
= Tok
.getIdentifierInfo();
906 // If this is not an identifier at all, bail out early.
912 SourceLocation AttrName
= ConsumeToken(); // consume last attribute name
914 if (II
->isStr("readonly"))
915 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_readonly
);
916 else if (II
->isStr("assign"))
917 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_assign
);
918 else if (II
->isStr("unsafe_unretained"))
919 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_unsafe_unretained
);
920 else if (II
->isStr("readwrite"))
921 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_readwrite
);
922 else if (II
->isStr("retain"))
923 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_retain
);
924 else if (II
->isStr("strong"))
925 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_strong
);
926 else if (II
->isStr("copy"))
927 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_copy
);
928 else if (II
->isStr("nonatomic"))
929 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_nonatomic
);
930 else if (II
->isStr("atomic"))
931 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_atomic
);
932 else if (II
->isStr("weak"))
933 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_weak
);
934 else if (II
->isStr("getter") || II
->isStr("setter")) {
935 bool IsSetter
= II
->getNameStart()[0] == 's';
937 // getter/setter require extra treatment.
938 unsigned DiagID
= IsSetter
? diag::err_objc_expected_equal_for_setter
:
939 diag::err_objc_expected_equal_for_getter
;
941 if (ExpectAndConsume(tok::equal
, DiagID
)) {
942 SkipUntil(tok::r_paren
, StopAtSemi
);
946 if (Tok
.is(tok::code_completion
)) {
949 Actions
.CodeCompleteObjCPropertySetter(getCurScope());
951 Actions
.CodeCompleteObjCPropertyGetter(getCurScope());
955 SourceLocation SelLoc
;
956 IdentifierInfo
*SelIdent
= ParseObjCSelectorPiece(SelLoc
);
959 Diag(Tok
, diag::err_objc_expected_selector_for_getter_setter
)
961 SkipUntil(tok::r_paren
, StopAtSemi
);
966 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_setter
);
967 DS
.setSetterName(SelIdent
, SelLoc
);
969 if (ExpectAndConsume(tok::colon
,
970 diag::err_expected_colon_after_setter_name
)) {
971 SkipUntil(tok::r_paren
, StopAtSemi
);
975 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_getter
);
976 DS
.setGetterName(SelIdent
, SelLoc
);
978 } else if (II
->isStr("nonnull")) {
979 if (DS
.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability
)
980 diagnoseRedundantPropertyNullability(*this, DS
,
981 NullabilityKind::NonNull
,
983 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability
);
984 DS
.setNullability(Tok
.getLocation(), NullabilityKind::NonNull
);
985 } else if (II
->isStr("nullable")) {
986 if (DS
.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability
)
987 diagnoseRedundantPropertyNullability(*this, DS
,
988 NullabilityKind::Nullable
,
990 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability
);
991 DS
.setNullability(Tok
.getLocation(), NullabilityKind::Nullable
);
992 } else if (II
->isStr("null_unspecified")) {
993 if (DS
.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability
)
994 diagnoseRedundantPropertyNullability(*this, DS
,
995 NullabilityKind::Unspecified
,
997 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability
);
998 DS
.setNullability(Tok
.getLocation(), NullabilityKind::Unspecified
);
999 } else if (II
->isStr("null_resettable")) {
1000 if (DS
.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability
)
1001 diagnoseRedundantPropertyNullability(*this, DS
,
1002 NullabilityKind::Unspecified
,
1004 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability
);
1005 DS
.setNullability(Tok
.getLocation(), NullabilityKind::Unspecified
);
1007 // Also set the null_resettable bit.
1008 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_null_resettable
);
1009 } else if (II
->isStr("class")) {
1010 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_class
);
1011 } else if (II
->isStr("direct")) {
1012 DS
.setPropertyAttributes(ObjCPropertyAttribute::kind_direct
);
1014 Diag(AttrName
, diag::err_objc_expected_property_attr
) << II
;
1015 SkipUntil(tok::r_paren
, StopAtSemi
);
1019 if (Tok
.isNot(tok::comma
))
1028 /// objc-method-proto:
1029 /// objc-instance-method objc-method-decl objc-method-attributes[opt]
1030 /// objc-class-method objc-method-decl objc-method-attributes[opt]
1032 /// objc-instance-method: '-'
1033 /// objc-class-method: '+'
1035 /// objc-method-attributes: [OBJC2]
1036 /// __attribute__((deprecated))
1038 Decl
*Parser::ParseObjCMethodPrototype(tok::ObjCKeywordKind MethodImplKind
,
1039 bool MethodDefinition
) {
1040 assert(Tok
.isOneOf(tok::minus
, tok::plus
) && "expected +/-");
1042 tok::TokenKind methodType
= Tok
.getKind();
1043 SourceLocation mLoc
= ConsumeToken();
1044 Decl
*MDecl
= ParseObjCMethodDecl(mLoc
, methodType
, MethodImplKind
,
1046 // Since this rule is used for both method declarations and definitions,
1047 // the caller is (optionally) responsible for consuming the ';'.
1054 /// enum struct union if else while do for switch case default
1055 /// break continue return goto asm sizeof typeof __alignof
1056 /// unsigned long const short volatile signed restrict _Complex
1057 /// in out inout bycopy byref oneway int char float double void _Bool
1059 IdentifierInfo
*Parser::ParseObjCSelectorPiece(SourceLocation
&SelectorLoc
) {
1061 switch (Tok
.getKind()) {
1065 // Empty selector piece uses the location of the ':'.
1066 SelectorLoc
= Tok
.getLocation();
1074 case tok::exclaimequal
:
1076 case tok::pipeequal
:
1078 case tok::caretequal
: {
1079 std::string
ThisTok(PP
.getSpelling(Tok
));
1080 if (isLetter(ThisTok
[0])) {
1081 IdentifierInfo
*II
= &PP
.getIdentifierTable().get(ThisTok
);
1082 Tok
.setKind(tok::identifier
);
1083 SelectorLoc
= ConsumeToken();
1089 case tok::identifier
:
1099 case tok::kw_const_cast
:
1100 case tok::kw_continue
:
1101 case tok::kw_default
:
1102 case tok::kw_delete
:
1104 case tok::kw_double
:
1105 case tok::kw_dynamic_cast
:
1108 case tok::kw_explicit
:
1109 case tok::kw_export
:
1110 case tok::kw_extern
:
1114 case tok::kw_friend
:
1117 case tok::kw_inline
:
1120 case tok::kw_mutable
:
1121 case tok::kw_namespace
:
1123 case tok::kw_operator
:
1124 case tok::kw_private
:
1125 case tok::kw_protected
:
1126 case tok::kw_public
:
1127 case tok::kw_register
:
1128 case tok::kw_reinterpret_cast
:
1129 case tok::kw_restrict
:
1130 case tok::kw_return
:
1132 case tok::kw_signed
:
1133 case tok::kw_sizeof
:
1134 case tok::kw_static
:
1135 case tok::kw_static_cast
:
1136 case tok::kw_struct
:
1137 case tok::kw_switch
:
1138 case tok::kw_template
:
1143 case tok::kw_typedef
:
1144 case tok::kw_typeid
:
1145 case tok::kw_typename
:
1146 case tok::kw_typeof
:
1148 case tok::kw_unsigned
:
1150 case tok::kw_virtual
:
1152 case tok::kw_volatile
:
1153 case tok::kw_wchar_t
:
1156 case tok::kw__Complex
:
1157 case tok::kw___alignof
:
1158 case tok::kw___auto_type
:
1159 IdentifierInfo
*II
= Tok
.getIdentifierInfo();
1160 SelectorLoc
= ConsumeToken();
1165 /// objc-for-collection-in: 'in'
1167 bool Parser::isTokIdentifier_in() const {
1168 // FIXME: May have to do additional look-ahead to only allow for
1169 // valid tokens following an 'in'; such as an identifier, unary operators,
1171 return (getLangOpts().ObjC
&& Tok
.is(tok::identifier
) &&
1172 Tok
.getIdentifierInfo() == ObjCTypeQuals
[objc_in
]);
1175 /// ParseObjCTypeQualifierList - This routine parses the objective-c's type
1176 /// qualifier list and builds their bitmask representation in the input
1179 /// objc-type-qualifiers:
1180 /// objc-type-qualifier
1181 /// objc-type-qualifiers objc-type-qualifier
1183 /// objc-type-qualifier:
1192 /// 'null_unspecified'
1194 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec
&DS
,
1195 DeclaratorContext Context
) {
1196 assert(Context
== DeclaratorContext::ObjCParameter
||
1197 Context
== DeclaratorContext::ObjCResult
);
1200 if (Tok
.is(tok::code_completion
)) {
1202 Actions
.CodeCompleteObjCPassingType(
1203 getCurScope(), DS
, Context
== DeclaratorContext::ObjCParameter
);
1207 if (Tok
.isNot(tok::identifier
))
1210 const IdentifierInfo
*II
= Tok
.getIdentifierInfo();
1211 for (unsigned i
= 0; i
!= objc_NumQuals
; ++i
) {
1212 if (II
!= ObjCTypeQuals
[i
] ||
1213 NextToken().is(tok::less
) ||
1214 NextToken().is(tok::coloncolon
))
1217 ObjCDeclSpec::ObjCDeclQualifier Qual
;
1218 NullabilityKind Nullability
;
1220 default: llvm_unreachable("Unknown decl qualifier");
1221 case objc_in
: Qual
= ObjCDeclSpec::DQ_In
; break;
1222 case objc_out
: Qual
= ObjCDeclSpec::DQ_Out
; break;
1223 case objc_inout
: Qual
= ObjCDeclSpec::DQ_Inout
; break;
1224 case objc_oneway
: Qual
= ObjCDeclSpec::DQ_Oneway
; break;
1225 case objc_bycopy
: Qual
= ObjCDeclSpec::DQ_Bycopy
; break;
1226 case objc_byref
: Qual
= ObjCDeclSpec::DQ_Byref
; break;
1229 Qual
= ObjCDeclSpec::DQ_CSNullability
;
1230 Nullability
= NullabilityKind::NonNull
;
1234 Qual
= ObjCDeclSpec::DQ_CSNullability
;
1235 Nullability
= NullabilityKind::Nullable
;
1238 case objc_null_unspecified
:
1239 Qual
= ObjCDeclSpec::DQ_CSNullability
;
1240 Nullability
= NullabilityKind::Unspecified
;
1244 // FIXME: Diagnose redundant specifiers.
1245 DS
.setObjCDeclQualifier(Qual
);
1246 if (Qual
== ObjCDeclSpec::DQ_CSNullability
)
1247 DS
.setNullability(Tok
.getLocation(), Nullability
);
1254 // If this wasn't a recognized qualifier, bail out.
1259 /// Take all the decl attributes out of the given list and add
1260 /// them to the given attribute set.
1261 static void takeDeclAttributes(ParsedAttributesView
&attrs
,
1262 ParsedAttributesView
&from
) {
1263 for (auto &AL
: llvm::reverse(from
)) {
1264 if (!AL
.isUsedAsTypeAttr()) {
1266 attrs
.addAtEnd(&AL
);
1271 /// takeDeclAttributes - Take all the decl attributes from the given
1272 /// declarator and add them to the given list.
1273 static void takeDeclAttributes(ParsedAttributes
&attrs
,
1275 // This gets called only from Parser::ParseObjCTypeName(), and that should
1276 // never add declaration attributes to the Declarator.
1277 assert(D
.getDeclarationAttributes().empty());
1279 // First, take ownership of all attributes.
1280 attrs
.getPool().takeAllFrom(D
.getAttributePool());
1281 attrs
.getPool().takeAllFrom(D
.getDeclSpec().getAttributePool());
1283 // Now actually move the attributes over.
1284 takeDeclAttributes(attrs
, D
.getMutableDeclSpec().getAttributes());
1285 takeDeclAttributes(attrs
, D
.getAttributes());
1286 for (unsigned i
= 0, e
= D
.getNumTypeObjects(); i
!= e
; ++i
)
1287 takeDeclAttributes(attrs
, D
.getTypeObject(i
).getAttrs());
1291 /// '(' objc-type-qualifiers[opt] type-name ')'
1292 /// '(' objc-type-qualifiers[opt] ')'
1294 ParsedType
Parser::ParseObjCTypeName(ObjCDeclSpec
&DS
,
1295 DeclaratorContext context
,
1296 ParsedAttributes
*paramAttrs
) {
1297 assert(context
== DeclaratorContext::ObjCParameter
||
1298 context
== DeclaratorContext::ObjCResult
);
1299 assert((paramAttrs
!= nullptr) ==
1300 (context
== DeclaratorContext::ObjCParameter
));
1302 assert(Tok
.is(tok::l_paren
) && "expected (");
1304 BalancedDelimiterTracker
T(*this, tok::l_paren
);
1307 ObjCDeclContextSwitch
ObjCDC(*this);
1309 // Parse type qualifiers, in, inout, etc.
1310 ParseObjCTypeQualifierList(DS
, context
);
1311 SourceLocation TypeStartLoc
= Tok
.getLocation();
1314 if (isTypeSpecifierQualifier() || isObjCInstancetype()) {
1315 // Parse an abstract declarator.
1316 DeclSpec
declSpec(AttrFactory
);
1317 declSpec
.setObjCQualifiers(&DS
);
1318 DeclSpecContext dsContext
= DeclSpecContext::DSC_normal
;
1319 if (context
== DeclaratorContext::ObjCResult
)
1320 dsContext
= DeclSpecContext::DSC_objc_method_result
;
1321 ParseSpecifierQualifierList(declSpec
, AS_none
, dsContext
);
1322 Declarator
declarator(declSpec
, ParsedAttributesView::none(), context
);
1323 ParseDeclarator(declarator
);
1325 // If that's not invalid, extract a type.
1326 if (!declarator
.isInvalidType()) {
1327 // Map a nullability specifier to a context-sensitive keyword attribute.
1328 bool addedToDeclSpec
= false;
1329 if (DS
.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability
)
1330 addContextSensitiveTypeNullability(*this, declarator
,
1331 DS
.getNullability(),
1332 DS
.getNullabilityLoc(),
1335 TypeResult type
= Actions
.ActOnTypeName(declarator
);
1336 if (!type
.isInvalid())
1339 // If we're parsing a parameter, steal all the decl attributes
1340 // and add them to the decl spec.
1341 if (context
== DeclaratorContext::ObjCParameter
)
1342 takeDeclAttributes(*paramAttrs
, declarator
);
1346 if (Tok
.is(tok::r_paren
))
1348 else if (Tok
.getLocation() == TypeStartLoc
) {
1349 // If we didn't eat any tokens, then this isn't a type.
1350 Diag(Tok
, diag::err_expected_type
);
1351 SkipUntil(tok::r_paren
, StopAtSemi
);
1353 // Otherwise, we found *something*, but didn't get a ')' in the right
1354 // place. Emit an error then return what we have as the type.
1360 /// objc-method-decl:
1362 /// objc-keyword-selector objc-parmlist[opt]
1363 /// objc-type-name objc-selector
1364 /// objc-type-name objc-keyword-selector objc-parmlist[opt]
1366 /// objc-keyword-selector:
1367 /// objc-keyword-decl
1368 /// objc-keyword-selector objc-keyword-decl
1370 /// objc-keyword-decl:
1371 /// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier
1372 /// objc-selector ':' objc-keyword-attributes[opt] identifier
1373 /// ':' objc-type-name objc-keyword-attributes[opt] identifier
1374 /// ':' objc-keyword-attributes[opt] identifier
1377 /// objc-parms objc-ellipsis[opt]
1380 /// objc-parms , parameter-declaration
1385 /// objc-keyword-attributes: [OBJC2]
1386 /// __attribute__((unused))
1388 Decl
*Parser::ParseObjCMethodDecl(SourceLocation mLoc
,
1389 tok::TokenKind mType
,
1390 tok::ObjCKeywordKind MethodImplKind
,
1391 bool MethodDefinition
) {
1392 ParsingDeclRAIIObject
PD(*this, ParsingDeclRAIIObject::NoParent
);
1394 if (Tok
.is(tok::code_completion
)) {
1396 Actions
.CodeCompleteObjCMethodDecl(getCurScope(), mType
== tok::minus
,
1397 /*ReturnType=*/nullptr);
1401 // Parse the return type if present.
1402 ParsedType ReturnType
;
1404 if (Tok
.is(tok::l_paren
))
1406 ParseObjCTypeName(DSRet
, DeclaratorContext::ObjCResult
, nullptr);
1408 // If attributes exist before the method, parse them.
1409 ParsedAttributes
methodAttrs(AttrFactory
);
1410 MaybeParseAttributes(PAKM_CXX11
| (getLangOpts().ObjC
? PAKM_GNU
: 0),
1413 if (Tok
.is(tok::code_completion
)) {
1415 Actions
.CodeCompleteObjCMethodDecl(getCurScope(), mType
== tok::minus
,
1420 // Now parse the selector.
1421 SourceLocation selLoc
;
1422 IdentifierInfo
*SelIdent
= ParseObjCSelectorPiece(selLoc
);
1424 // An unnamed colon is valid.
1425 if (!SelIdent
&& Tok
.isNot(tok::colon
)) { // missing selector name.
1426 Diag(Tok
, diag::err_expected_selector_for_method
)
1427 << SourceRange(mLoc
, Tok
.getLocation());
1428 // Skip until we get a ; or @.
1429 SkipUntil(tok::at
, StopAtSemi
| StopBeforeMatch
);
1433 SmallVector
<DeclaratorChunk::ParamInfo
, 8> CParamInfo
;
1434 if (Tok
.isNot(tok::colon
)) {
1435 // If attributes exist after the method, parse them.
1436 MaybeParseAttributes(PAKM_CXX11
| (getLangOpts().ObjC
? PAKM_GNU
: 0),
1439 Selector Sel
= PP
.getSelectorTable().getNullarySelector(SelIdent
);
1440 Decl
*Result
= Actions
.ActOnMethodDeclaration(
1441 getCurScope(), mLoc
, Tok
.getLocation(), mType
, DSRet
, ReturnType
,
1442 selLoc
, Sel
, nullptr, CParamInfo
.data(), CParamInfo
.size(), methodAttrs
,
1443 MethodImplKind
, false, MethodDefinition
);
1444 PD
.complete(Result
);
1448 SmallVector
<IdentifierInfo
*, 12> KeyIdents
;
1449 SmallVector
<SourceLocation
, 12> KeyLocs
;
1450 SmallVector
<Sema::ObjCArgInfo
, 12> ArgInfos
;
1451 ParseScope
PrototypeScope(this, Scope::FunctionPrototypeScope
|
1452 Scope::FunctionDeclarationScope
| Scope::DeclScope
);
1454 AttributePool
allParamAttrs(AttrFactory
);
1456 ParsedAttributes
paramAttrs(AttrFactory
);
1457 Sema::ObjCArgInfo ArgInfo
;
1459 // Each iteration parses a single keyword argument.
1460 if (ExpectAndConsume(tok::colon
))
1463 ArgInfo
.Type
= nullptr;
1464 if (Tok
.is(tok::l_paren
)) // Parse the argument type if present.
1465 ArgInfo
.Type
= ParseObjCTypeName(
1466 ArgInfo
.DeclSpec
, DeclaratorContext::ObjCParameter
, ¶mAttrs
);
1468 // If attributes exist before the argument name, parse them.
1469 // Regardless, collect all the attributes we've parsed so far.
1470 MaybeParseAttributes(PAKM_CXX11
| (getLangOpts().ObjC
? PAKM_GNU
: 0),
1472 ArgInfo
.ArgAttrs
= paramAttrs
;
1474 // Code completion for the next piece of the selector.
1475 if (Tok
.is(tok::code_completion
)) {
1477 KeyIdents
.push_back(SelIdent
);
1478 Actions
.CodeCompleteObjCMethodDeclSelector(getCurScope(),
1479 mType
== tok::minus
,
1480 /*AtParameterName=*/true,
1481 ReturnType
, KeyIdents
);
1485 if (expectIdentifier())
1486 break; // missing argument name.
1488 ArgInfo
.Name
= Tok
.getIdentifierInfo();
1489 ArgInfo
.NameLoc
= Tok
.getLocation();
1490 ConsumeToken(); // Eat the identifier.
1492 ArgInfos
.push_back(ArgInfo
);
1493 KeyIdents
.push_back(SelIdent
);
1494 KeyLocs
.push_back(selLoc
);
1496 // Make sure the attributes persist.
1497 allParamAttrs
.takeAllFrom(paramAttrs
.getPool());
1499 // Code completion for the next piece of the selector.
1500 if (Tok
.is(tok::code_completion
)) {
1502 Actions
.CodeCompleteObjCMethodDeclSelector(getCurScope(),
1503 mType
== tok::minus
,
1504 /*AtParameterName=*/false,
1505 ReturnType
, KeyIdents
);
1509 // Check for another keyword selector.
1510 SelIdent
= ParseObjCSelectorPiece(selLoc
);
1511 if (!SelIdent
&& Tok
.isNot(tok::colon
))
1514 SourceLocation ColonLoc
= Tok
.getLocation();
1515 if (PP
.getLocForEndOfToken(ArgInfo
.NameLoc
) == ColonLoc
) {
1516 Diag(ArgInfo
.NameLoc
, diag::warn_missing_selector_name
) << ArgInfo
.Name
;
1517 Diag(ArgInfo
.NameLoc
, diag::note_missing_selector_name
) << ArgInfo
.Name
;
1518 Diag(ColonLoc
, diag::note_force_empty_selector_name
) << ArgInfo
.Name
;
1521 // We have a selector or a colon, continue parsing.
1524 bool isVariadic
= false;
1525 bool cStyleParamWarned
= false;
1526 // Parse the (optional) parameter list.
1527 while (Tok
.is(tok::comma
)) {
1529 if (Tok
.is(tok::ellipsis
)) {
1534 if (!cStyleParamWarned
) {
1535 Diag(Tok
, diag::warn_cstyle_param
);
1536 cStyleParamWarned
= true;
1538 DeclSpec
DS(AttrFactory
);
1539 ParseDeclarationSpecifiers(DS
);
1540 // Parse the declarator.
1541 Declarator
ParmDecl(DS
, ParsedAttributesView::none(),
1542 DeclaratorContext::Prototype
);
1543 ParseDeclarator(ParmDecl
);
1544 IdentifierInfo
*ParmII
= ParmDecl
.getIdentifier();
1545 Decl
*Param
= Actions
.ActOnParamDeclarator(getCurScope(), ParmDecl
);
1546 CParamInfo
.push_back(DeclaratorChunk::ParamInfo(ParmII
,
1547 ParmDecl
.getIdentifierLoc(),
1552 // FIXME: Add support for optional parameter list...
1553 // If attributes exist after the method, parse them.
1554 MaybeParseAttributes(PAKM_CXX11
| (getLangOpts().ObjC
? PAKM_GNU
: 0),
1557 if (KeyIdents
.size() == 0)
1560 Selector Sel
= PP
.getSelectorTable().getSelector(KeyIdents
.size(),
1562 Decl
*Result
= Actions
.ActOnMethodDeclaration(
1563 getCurScope(), mLoc
, Tok
.getLocation(), mType
, DSRet
, ReturnType
, KeyLocs
,
1564 Sel
, &ArgInfos
[0], CParamInfo
.data(), CParamInfo
.size(), methodAttrs
,
1565 MethodImplKind
, isVariadic
, MethodDefinition
);
1567 PD
.complete(Result
);
1571 /// objc-protocol-refs:
1572 /// '<' identifier-list '>'
1575 ParseObjCProtocolReferences(SmallVectorImpl
<Decl
*> &Protocols
,
1576 SmallVectorImpl
<SourceLocation
> &ProtocolLocs
,
1577 bool WarnOnDeclarations
, bool ForObjCContainer
,
1578 SourceLocation
&LAngleLoc
, SourceLocation
&EndLoc
,
1579 bool consumeLastToken
) {
1580 assert(Tok
.is(tok::less
) && "expected <");
1582 LAngleLoc
= ConsumeToken(); // the "<"
1584 SmallVector
<IdentifierLocPair
, 8> ProtocolIdents
;
1587 if (Tok
.is(tok::code_completion
)) {
1589 Actions
.CodeCompleteObjCProtocolReferences(ProtocolIdents
);
1593 if (expectIdentifier()) {
1594 SkipUntil(tok::greater
, StopAtSemi
);
1597 ProtocolIdents
.push_back(std::make_pair(Tok
.getIdentifierInfo(),
1598 Tok
.getLocation()));
1599 ProtocolLocs
.push_back(Tok
.getLocation());
1602 if (!TryConsumeToken(tok::comma
))
1607 if (ParseGreaterThanInTemplateList(LAngleLoc
, EndLoc
, consumeLastToken
,
1608 /*ObjCGenericList=*/false))
1611 // Convert the list of protocols identifiers into a list of protocol decls.
1612 Actions
.FindProtocolDeclaration(WarnOnDeclarations
, ForObjCContainer
,
1613 ProtocolIdents
, Protocols
);
1617 TypeResult
Parser::parseObjCProtocolQualifierType(SourceLocation
&rAngleLoc
) {
1618 assert(Tok
.is(tok::less
) && "Protocol qualifiers start with '<'");
1619 assert(getLangOpts().ObjC
&& "Protocol qualifiers only exist in Objective-C");
1621 SourceLocation lAngleLoc
;
1622 SmallVector
<Decl
*, 8> protocols
;
1623 SmallVector
<SourceLocation
, 8> protocolLocs
;
1624 (void)ParseObjCProtocolReferences(protocols
, protocolLocs
, false, false,
1625 lAngleLoc
, rAngleLoc
,
1626 /*consumeLastToken=*/true);
1627 TypeResult result
= Actions
.actOnObjCProtocolQualifierType(lAngleLoc
,
1631 if (result
.isUsable()) {
1632 Diag(lAngleLoc
, diag::warn_objc_protocol_qualifier_missing_id
)
1633 << FixItHint::CreateInsertion(lAngleLoc
, "id")
1634 << SourceRange(lAngleLoc
, rAngleLoc
);
1640 /// Parse Objective-C type arguments or protocol qualifiers.
1642 /// objc-type-arguments:
1643 /// '<' type-name '...'[opt] (',' type-name '...'[opt])* '>'
1645 void Parser::parseObjCTypeArgsOrProtocolQualifiers(
1646 ParsedType baseType
,
1647 SourceLocation
&typeArgsLAngleLoc
,
1648 SmallVectorImpl
<ParsedType
> &typeArgs
,
1649 SourceLocation
&typeArgsRAngleLoc
,
1650 SourceLocation
&protocolLAngleLoc
,
1651 SmallVectorImpl
<Decl
*> &protocols
,
1652 SmallVectorImpl
<SourceLocation
> &protocolLocs
,
1653 SourceLocation
&protocolRAngleLoc
,
1654 bool consumeLastToken
,
1655 bool warnOnIncompleteProtocols
) {
1656 assert(Tok
.is(tok::less
) && "Not at the start of type args or protocols");
1657 SourceLocation lAngleLoc
= ConsumeToken();
1659 // Whether all of the elements we've parsed thus far are single
1660 // identifiers, which might be types or might be protocols.
1661 bool allSingleIdentifiers
= true;
1662 SmallVector
<IdentifierInfo
*, 4> identifiers
;
1663 SmallVectorImpl
<SourceLocation
> &identifierLocs
= protocolLocs
;
1665 // Parse a list of comma-separated identifiers, bailing out if we
1666 // see something different.
1668 // Parse a single identifier.
1669 if (Tok
.is(tok::identifier
) &&
1670 (NextToken().is(tok::comma
) ||
1671 NextToken().is(tok::greater
) ||
1672 NextToken().is(tok::greatergreater
))) {
1673 identifiers
.push_back(Tok
.getIdentifierInfo());
1674 identifierLocs
.push_back(ConsumeToken());
1678 if (Tok
.is(tok::code_completion
)) {
1679 // FIXME: Also include types here.
1680 SmallVector
<IdentifierLocPair
, 4> identifierLocPairs
;
1681 for (unsigned i
= 0, n
= identifiers
.size(); i
!= n
; ++i
) {
1682 identifierLocPairs
.push_back(IdentifierLocPair(identifiers
[i
],
1683 identifierLocs
[i
]));
1686 QualType BaseT
= Actions
.GetTypeFromParser(baseType
);
1688 if (!BaseT
.isNull() && BaseT
->acceptsObjCTypeParams()) {
1689 Actions
.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type
);
1691 Actions
.CodeCompleteObjCProtocolReferences(identifierLocPairs
);
1696 allSingleIdentifiers
= false;
1698 } while (TryConsumeToken(tok::comma
));
1700 // If we parsed an identifier list, semantic analysis sorts out
1701 // whether it refers to protocols or to type arguments.
1702 if (allSingleIdentifiers
) {
1703 // Parse the closing '>'.
1704 SourceLocation rAngleLoc
;
1705 (void)ParseGreaterThanInTemplateList(lAngleLoc
, rAngleLoc
, consumeLastToken
,
1706 /*ObjCGenericList=*/true);
1708 // Let Sema figure out what we parsed.
1709 Actions
.actOnObjCTypeArgsOrProtocolQualifiers(getCurScope(),
1721 warnOnIncompleteProtocols
);
1725 // We parsed an identifier list but stumbled into non single identifiers, this
1726 // means we might (a) check that what we already parsed is a legitimate type
1727 // (not a protocol or unknown type) and (b) parse the remaining ones, which
1728 // must all be type args.
1730 // Convert the identifiers into type arguments.
1731 bool invalid
= false;
1732 IdentifierInfo
*foundProtocolId
= nullptr, *foundValidTypeId
= nullptr;
1733 SourceLocation foundProtocolSrcLoc
, foundValidTypeSrcLoc
;
1734 SmallVector
<IdentifierInfo
*, 2> unknownTypeArgs
;
1735 SmallVector
<SourceLocation
, 2> unknownTypeArgsLoc
;
1737 for (unsigned i
= 0, n
= identifiers
.size(); i
!= n
; ++i
) {
1739 = Actions
.getTypeName(*identifiers
[i
], identifierLocs
[i
], getCurScope());
1741 DeclSpec
DS(AttrFactory
);
1742 const char *prevSpec
= nullptr;
1744 DS
.SetTypeSpecType(TST_typename
, identifierLocs
[i
], prevSpec
, diagID
,
1745 typeArg
, Actions
.getASTContext().getPrintingPolicy());
1747 // Form a declarator to turn this into a type.
1748 Declarator
D(DS
, ParsedAttributesView::none(),
1749 DeclaratorContext::TypeName
);
1750 TypeResult fullTypeArg
= Actions
.ActOnTypeName(D
);
1751 if (fullTypeArg
.isUsable()) {
1752 typeArgs
.push_back(fullTypeArg
.get());
1753 if (!foundValidTypeId
) {
1754 foundValidTypeId
= identifiers
[i
];
1755 foundValidTypeSrcLoc
= identifierLocs
[i
];
1759 unknownTypeArgs
.push_back(identifiers
[i
]);
1760 unknownTypeArgsLoc
.push_back(identifierLocs
[i
]);
1764 if (!Actions
.LookupProtocol(identifiers
[i
], identifierLocs
[i
])) {
1765 unknownTypeArgs
.push_back(identifiers
[i
]);
1766 unknownTypeArgsLoc
.push_back(identifierLocs
[i
]);
1767 } else if (!foundProtocolId
) {
1768 foundProtocolId
= identifiers
[i
];
1769 foundProtocolSrcLoc
= identifierLocs
[i
];
1774 // Continue parsing type-names.
1776 Token CurTypeTok
= Tok
;
1777 TypeResult typeArg
= ParseTypeName();
1779 // Consume the '...' for a pack expansion.
1780 SourceLocation ellipsisLoc
;
1781 TryConsumeToken(tok::ellipsis
, ellipsisLoc
);
1782 if (typeArg
.isUsable() && ellipsisLoc
.isValid()) {
1783 typeArg
= Actions
.ActOnPackExpansion(typeArg
.get(), ellipsisLoc
);
1786 if (typeArg
.isUsable()) {
1787 typeArgs
.push_back(typeArg
.get());
1788 if (!foundValidTypeId
) {
1789 foundValidTypeId
= CurTypeTok
.getIdentifierInfo();
1790 foundValidTypeSrcLoc
= CurTypeTok
.getLocation();
1795 } while (TryConsumeToken(tok::comma
));
1797 // Diagnose the mix between type args and protocols.
1798 if (foundProtocolId
&& foundValidTypeId
)
1799 Actions
.DiagnoseTypeArgsAndProtocols(foundProtocolId
, foundProtocolSrcLoc
,
1801 foundValidTypeSrcLoc
);
1803 // Diagnose unknown arg types.
1805 if (unknownTypeArgs
.size())
1806 for (unsigned i
= 0, e
= unknownTypeArgsLoc
.size(); i
< e
; ++i
)
1807 Actions
.DiagnoseUnknownTypeName(unknownTypeArgs
[i
], unknownTypeArgsLoc
[i
],
1808 getCurScope(), nullptr, T
);
1810 // Parse the closing '>'.
1811 SourceLocation rAngleLoc
;
1812 (void)ParseGreaterThanInTemplateList(lAngleLoc
, rAngleLoc
, consumeLastToken
,
1813 /*ObjCGenericList=*/true);
1820 // Record left/right angle locations.
1821 typeArgsLAngleLoc
= lAngleLoc
;
1822 typeArgsRAngleLoc
= rAngleLoc
;
1825 void Parser::parseObjCTypeArgsAndProtocolQualifiers(
1826 ParsedType baseType
,
1827 SourceLocation
&typeArgsLAngleLoc
,
1828 SmallVectorImpl
<ParsedType
> &typeArgs
,
1829 SourceLocation
&typeArgsRAngleLoc
,
1830 SourceLocation
&protocolLAngleLoc
,
1831 SmallVectorImpl
<Decl
*> &protocols
,
1832 SmallVectorImpl
<SourceLocation
> &protocolLocs
,
1833 SourceLocation
&protocolRAngleLoc
,
1834 bool consumeLastToken
) {
1835 assert(Tok
.is(tok::less
));
1837 // Parse the first angle-bracket-delimited clause.
1838 parseObjCTypeArgsOrProtocolQualifiers(baseType
,
1847 /*warnOnIncompleteProtocols=*/false);
1848 if (Tok
.is(tok::eof
)) // Nothing else to do here...
1851 // An Objective-C object pointer followed by type arguments
1852 // can then be followed again by a set of protocol references, e.g.,
1853 // \c NSArray<NSView><NSTextDelegate>
1854 if ((consumeLastToken
&& Tok
.is(tok::less
)) ||
1855 (!consumeLastToken
&& NextToken().is(tok::less
))) {
1856 // If we aren't consuming the last token, the prior '>' is still hanging
1857 // there. Consume it before we parse the protocol qualifiers.
1858 if (!consumeLastToken
)
1861 if (!protocols
.empty()) {
1862 SkipUntilFlags skipFlags
= SkipUntilFlags();
1863 if (!consumeLastToken
)
1864 skipFlags
= skipFlags
| StopBeforeMatch
;
1865 Diag(Tok
, diag::err_objc_type_args_after_protocols
)
1866 << SourceRange(protocolLAngleLoc
, protocolRAngleLoc
);
1867 SkipUntil(tok::greater
, tok::greatergreater
, skipFlags
);
1869 ParseObjCProtocolReferences(protocols
, protocolLocs
,
1870 /*WarnOnDeclarations=*/false,
1871 /*ForObjCContainer=*/false,
1872 protocolLAngleLoc
, protocolRAngleLoc
,
1878 TypeResult
Parser::parseObjCTypeArgsAndProtocolQualifiers(
1881 bool consumeLastToken
,
1882 SourceLocation
&endLoc
) {
1883 assert(Tok
.is(tok::less
));
1884 SourceLocation typeArgsLAngleLoc
;
1885 SmallVector
<ParsedType
, 4> typeArgs
;
1886 SourceLocation typeArgsRAngleLoc
;
1887 SourceLocation protocolLAngleLoc
;
1888 SmallVector
<Decl
*, 4> protocols
;
1889 SmallVector
<SourceLocation
, 4> protocolLocs
;
1890 SourceLocation protocolRAngleLoc
;
1892 // Parse type arguments and protocol qualifiers.
1893 parseObjCTypeArgsAndProtocolQualifiers(type
, typeArgsLAngleLoc
, typeArgs
,
1894 typeArgsRAngleLoc
, protocolLAngleLoc
,
1895 protocols
, protocolLocs
,
1896 protocolRAngleLoc
, consumeLastToken
);
1898 if (Tok
.is(tok::eof
))
1899 return true; // Invalid type result.
1901 // Compute the location of the last token.
1902 if (consumeLastToken
)
1903 endLoc
= PrevTokLocation
;
1905 endLoc
= Tok
.getLocation();
1907 return Actions
.actOnObjCTypeArgsAndProtocolQualifiers(
1920 void Parser::HelperActionsForIvarDeclarations(
1921 ObjCContainerDecl
*interfaceDecl
, SourceLocation atLoc
,
1922 BalancedDelimiterTracker
&T
, SmallVectorImpl
<Decl
*> &AllIvarDecls
,
1923 bool RBraceMissing
) {
1927 assert(getObjCDeclContext() == interfaceDecl
&&
1928 "Ivars should have interfaceDecl as their decl context");
1929 Actions
.ActOnLastBitfield(T
.getCloseLocation(), AllIvarDecls
);
1930 // Call ActOnFields() even if we don't have any decls. This is useful
1931 // for code rewriting tools that need to be aware of the empty list.
1932 Actions
.ActOnFields(getCurScope(), atLoc
, interfaceDecl
, AllIvarDecls
,
1933 T
.getOpenLocation(), T
.getCloseLocation(),
1934 ParsedAttributesView());
1937 /// objc-class-instance-variables:
1938 /// '{' objc-instance-variable-decl-list[opt] '}'
1940 /// objc-instance-variable-decl-list:
1941 /// objc-visibility-spec
1942 /// objc-instance-variable-decl ';'
1944 /// objc-instance-variable-decl-list objc-visibility-spec
1945 /// objc-instance-variable-decl-list objc-instance-variable-decl ';'
1946 /// objc-instance-variable-decl-list static_assert-declaration
1947 /// objc-instance-variable-decl-list ';'
1949 /// objc-visibility-spec:
1953 /// @package [OBJC2]
1955 /// objc-instance-variable-decl:
1956 /// struct-declaration
1958 void Parser::ParseObjCClassInstanceVariables(ObjCContainerDecl
*interfaceDecl
,
1959 tok::ObjCKeywordKind visibility
,
1960 SourceLocation atLoc
) {
1961 assert(Tok
.is(tok::l_brace
) && "expected {");
1962 SmallVector
<Decl
*, 32> AllIvarDecls
;
1964 ParseScope
ClassScope(this, Scope::DeclScope
| Scope::ClassScope
);
1966 BalancedDelimiterTracker
T(*this, tok::l_brace
);
1968 // While we still have something to read, read the instance variables.
1969 while (Tok
.isNot(tok::r_brace
) && !isEofOrEom()) {
1970 // Each iteration of this loop reads one objc-instance-variable-decl.
1972 // Check for extraneous top-level semicolon.
1973 if (Tok
.is(tok::semi
)) {
1974 ConsumeExtraSemi(InstanceVariableList
);
1978 // Set the default visibility to private.
1979 if (TryConsumeToken(tok::at
)) { // parse objc-visibility-spec
1980 if (Tok
.is(tok::code_completion
)) {
1982 Actions
.CodeCompleteObjCAtVisibility(getCurScope());
1986 switch (Tok
.getObjCKeywordID()) {
1987 case tok::objc_private
:
1988 case tok::objc_public
:
1989 case tok::objc_protected
:
1990 case tok::objc_package
:
1991 visibility
= Tok
.getObjCKeywordID();
1996 Diag(Tok
, diag::err_objc_unexpected_atend
);
1997 Tok
.setLocation(Tok
.getLocation().getLocWithOffset(-1));
1998 Tok
.setKind(tok::at
);
2000 PP
.EnterToken(Tok
, /*IsReinject*/true);
2001 HelperActionsForIvarDeclarations(interfaceDecl
, atLoc
,
2002 T
, AllIvarDecls
, true);
2006 Diag(Tok
, diag::err_objc_illegal_visibility_spec
);
2011 if (Tok
.is(tok::code_completion
)) {
2013 Actions
.CodeCompleteOrdinaryName(getCurScope(),
2014 Sema::PCC_ObjCInstanceVariableList
);
2018 // This needs to duplicate a small amount of code from
2019 // ParseStructUnionBody() for things that should work in both
2020 // C struct and in Objective-C class instance variables.
2021 if (Tok
.isOneOf(tok::kw_static_assert
, tok::kw__Static_assert
)) {
2022 SourceLocation DeclEnd
;
2023 ParseStaticAssertDeclaration(DeclEnd
);
2027 auto ObjCIvarCallback
= [&](ParsingFieldDeclarator
&FD
) {
2028 assert(getObjCDeclContext() == interfaceDecl
&&
2029 "Ivar should have interfaceDecl as its decl context");
2030 // Install the declarator into the interface decl.
2031 FD
.D
.setObjCIvar(true);
2032 Decl
*Field
= Actions
.ActOnIvar(
2033 getCurScope(), FD
.D
.getDeclSpec().getSourceRange().getBegin(), FD
.D
,
2034 FD
.BitfieldSize
, visibility
);
2036 AllIvarDecls
.push_back(Field
);
2040 // Parse all the comma separated declarators.
2041 ParsingDeclSpec
DS(*this);
2042 ParseStructDeclaration(DS
, ObjCIvarCallback
);
2044 if (Tok
.is(tok::semi
)) {
2047 Diag(Tok
, diag::err_expected_semi_decl_list
);
2048 // Skip to end of block or statement
2049 SkipUntil(tok::r_brace
, StopAtSemi
| StopBeforeMatch
);
2052 HelperActionsForIvarDeclarations(interfaceDecl
, atLoc
,
2053 T
, AllIvarDecls
, false);
2056 /// objc-protocol-declaration:
2057 /// objc-protocol-definition
2058 /// objc-protocol-forward-reference
2060 /// objc-protocol-definition:
2061 /// \@protocol identifier
2062 /// objc-protocol-refs[opt]
2063 /// objc-interface-decl-list
2066 /// objc-protocol-forward-reference:
2067 /// \@protocol identifier-list ';'
2069 /// "\@protocol identifier ;" should be resolved as "\@protocol
2070 /// identifier-list ;": objc-interface-decl-list may not start with a
2071 /// semicolon in the first alternative if objc-protocol-refs are omitted.
2072 Parser::DeclGroupPtrTy
2073 Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc
,
2074 ParsedAttributes
&attrs
) {
2075 assert(Tok
.isObjCAtKeyword(tok::objc_protocol
) &&
2076 "ParseObjCAtProtocolDeclaration(): Expected @protocol");
2077 ConsumeToken(); // the "protocol" identifier
2079 if (Tok
.is(tok::code_completion
)) {
2081 Actions
.CodeCompleteObjCProtocolDecl(getCurScope());
2085 MaybeSkipAttributes(tok::objc_protocol
);
2087 if (expectIdentifier())
2088 return nullptr; // missing protocol name.
2089 // Save the protocol name, then consume it.
2090 IdentifierInfo
*protocolName
= Tok
.getIdentifierInfo();
2091 SourceLocation nameLoc
= ConsumeToken();
2093 if (TryConsumeToken(tok::semi
)) { // forward declaration of one protocol.
2094 IdentifierLocPair
ProtoInfo(protocolName
, nameLoc
);
2095 return Actions
.ActOnForwardProtocolDeclaration(AtLoc
, ProtoInfo
, attrs
);
2098 CheckNestedObjCContexts(AtLoc
);
2100 if (Tok
.is(tok::comma
)) { // list of forward declarations.
2101 SmallVector
<IdentifierLocPair
, 8> ProtocolRefs
;
2102 ProtocolRefs
.push_back(std::make_pair(protocolName
, nameLoc
));
2104 // Parse the list of forward declarations.
2106 ConsumeToken(); // the ','
2107 if (expectIdentifier()) {
2108 SkipUntil(tok::semi
);
2111 ProtocolRefs
.push_back(IdentifierLocPair(Tok
.getIdentifierInfo(),
2112 Tok
.getLocation()));
2113 ConsumeToken(); // the identifier
2115 if (Tok
.isNot(tok::comma
))
2119 if (ExpectAndConsume(tok::semi
, diag::err_expected_after
, "@protocol"))
2122 return Actions
.ActOnForwardProtocolDeclaration(AtLoc
, ProtocolRefs
, attrs
);
2125 // Last, and definitely not least, parse a protocol declaration.
2126 SourceLocation LAngleLoc
, EndProtoLoc
;
2128 SmallVector
<Decl
*, 8> ProtocolRefs
;
2129 SmallVector
<SourceLocation
, 8> ProtocolLocs
;
2130 if (Tok
.is(tok::less
) &&
2131 ParseObjCProtocolReferences(ProtocolRefs
, ProtocolLocs
, false, true,
2132 LAngleLoc
, EndProtoLoc
,
2133 /*consumeLastToken=*/true))
2136 Sema::SkipBodyInfo SkipBody
;
2137 ObjCProtocolDecl
*ProtoType
= Actions
.ActOnStartProtocolInterface(
2138 AtLoc
, protocolName
, nameLoc
, ProtocolRefs
.data(), ProtocolRefs
.size(),
2139 ProtocolLocs
.data(), EndProtoLoc
, attrs
, &SkipBody
);
2141 ParseObjCInterfaceDeclList(tok::objc_protocol
, ProtoType
);
2142 if (SkipBody
.CheckSameAsPrevious
) {
2143 auto *PreviousDef
= cast
<ObjCProtocolDecl
>(SkipBody
.Previous
);
2144 if (Actions
.ActOnDuplicateODRHashDefinition(ProtoType
, PreviousDef
)) {
2145 ProtoType
->mergeDuplicateDefinitionWithCommon(
2146 PreviousDef
->getDefinition());
2148 ODRDiagsEmitter
DiagsEmitter(Diags
, Actions
.getASTContext(),
2149 getPreprocessor().getLangOpts());
2150 DiagsEmitter
.diagnoseMismatch(PreviousDef
, ProtoType
);
2153 return Actions
.ConvertDeclToDeclGroup(ProtoType
);
2156 /// objc-implementation:
2157 /// objc-class-implementation-prologue
2158 /// objc-category-implementation-prologue
2160 /// objc-class-implementation-prologue:
2161 /// @implementation identifier objc-superclass[opt]
2162 /// objc-class-instance-variables[opt]
2164 /// objc-category-implementation-prologue:
2165 /// @implementation identifier ( identifier )
2166 Parser::DeclGroupPtrTy
2167 Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc
,
2168 ParsedAttributes
&Attrs
) {
2169 assert(Tok
.isObjCAtKeyword(tok::objc_implementation
) &&
2170 "ParseObjCAtImplementationDeclaration(): Expected @implementation");
2171 CheckNestedObjCContexts(AtLoc
);
2172 ConsumeToken(); // the "implementation" identifier
2174 // Code completion after '@implementation'.
2175 if (Tok
.is(tok::code_completion
)) {
2177 Actions
.CodeCompleteObjCImplementationDecl(getCurScope());
2181 MaybeSkipAttributes(tok::objc_implementation
);
2183 if (expectIdentifier())
2184 return nullptr; // missing class or category name.
2185 // We have a class or category name - consume it.
2186 IdentifierInfo
*nameId
= Tok
.getIdentifierInfo();
2187 SourceLocation nameLoc
= ConsumeToken(); // consume class or category name
2188 ObjCImplDecl
*ObjCImpDecl
= nullptr;
2190 // Neither a type parameter list nor a list of protocol references is
2191 // permitted here. Parse and diagnose them.
2192 if (Tok
.is(tok::less
)) {
2193 SourceLocation lAngleLoc
, rAngleLoc
;
2194 SmallVector
<IdentifierLocPair
, 8> protocolIdents
;
2195 SourceLocation diagLoc
= Tok
.getLocation();
2196 ObjCTypeParamListScope
typeParamScope(Actions
, getCurScope());
2197 if (parseObjCTypeParamListOrProtocolRefs(typeParamScope
, lAngleLoc
,
2198 protocolIdents
, rAngleLoc
)) {
2199 Diag(diagLoc
, diag::err_objc_parameterized_implementation
)
2200 << SourceRange(diagLoc
, PrevTokLocation
);
2201 } else if (lAngleLoc
.isValid()) {
2202 Diag(lAngleLoc
, diag::err_unexpected_protocol_qualifier
)
2203 << FixItHint::CreateRemoval(SourceRange(lAngleLoc
, rAngleLoc
));
2207 if (Tok
.is(tok::l_paren
)) {
2208 // we have a category implementation.
2210 SourceLocation categoryLoc
, rparenLoc
;
2211 IdentifierInfo
*categoryId
= nullptr;
2213 if (Tok
.is(tok::code_completion
)) {
2215 Actions
.CodeCompleteObjCImplementationCategory(getCurScope(), nameId
, nameLoc
);
2219 if (Tok
.is(tok::identifier
)) {
2220 categoryId
= Tok
.getIdentifierInfo();
2221 categoryLoc
= ConsumeToken();
2223 Diag(Tok
, diag::err_expected
)
2224 << tok::identifier
; // missing category name.
2227 if (Tok
.isNot(tok::r_paren
)) {
2228 Diag(Tok
, diag::err_expected
) << tok::r_paren
;
2229 SkipUntil(tok::r_paren
); // don't stop at ';'
2232 rparenLoc
= ConsumeParen();
2233 if (Tok
.is(tok::less
)) { // we have illegal '<' try to recover
2234 Diag(Tok
, diag::err_unexpected_protocol_qualifier
);
2235 SourceLocation protocolLAngleLoc
, protocolRAngleLoc
;
2236 SmallVector
<Decl
*, 4> protocols
;
2237 SmallVector
<SourceLocation
, 4> protocolLocs
;
2238 (void)ParseObjCProtocolReferences(protocols
, protocolLocs
,
2239 /*warnOnIncompleteProtocols=*/false,
2240 /*ForObjCContainer=*/false,
2241 protocolLAngleLoc
, protocolRAngleLoc
,
2242 /*consumeLastToken=*/true);
2244 ObjCImpDecl
= Actions
.ActOnStartCategoryImplementation(
2245 AtLoc
, nameId
, nameLoc
, categoryId
, categoryLoc
, Attrs
);
2248 // We have a class implementation
2249 SourceLocation superClassLoc
;
2250 IdentifierInfo
*superClassId
= nullptr;
2251 if (TryConsumeToken(tok::colon
)) {
2252 // We have a super class
2253 if (expectIdentifier())
2254 return nullptr; // missing super class name.
2255 superClassId
= Tok
.getIdentifierInfo();
2256 superClassLoc
= ConsumeToken(); // Consume super class name
2258 ObjCImpDecl
= Actions
.ActOnStartClassImplementation(
2259 AtLoc
, nameId
, nameLoc
, superClassId
, superClassLoc
, Attrs
);
2261 if (Tok
.is(tok::l_brace
)) // we have ivars
2262 ParseObjCClassInstanceVariables(ObjCImpDecl
, tok::objc_private
, AtLoc
);
2263 else if (Tok
.is(tok::less
)) { // we have illegal '<' try to recover
2264 Diag(Tok
, diag::err_unexpected_protocol_qualifier
);
2266 SourceLocation protocolLAngleLoc
, protocolRAngleLoc
;
2267 SmallVector
<Decl
*, 4> protocols
;
2268 SmallVector
<SourceLocation
, 4> protocolLocs
;
2269 (void)ParseObjCProtocolReferences(protocols
, protocolLocs
,
2270 /*warnOnIncompleteProtocols=*/false,
2271 /*ForObjCContainer=*/false,
2272 protocolLAngleLoc
, protocolRAngleLoc
,
2273 /*consumeLastToken=*/true);
2276 assert(ObjCImpDecl
);
2278 SmallVector
<Decl
*, 8> DeclsInGroup
;
2281 ObjCImplParsingDataRAII
ObjCImplParsing(*this, ObjCImpDecl
);
2282 while (!ObjCImplParsing
.isFinished() && !isEofOrEom()) {
2283 ParsedAttributes
DeclAttrs(AttrFactory
);
2284 MaybeParseCXX11Attributes(DeclAttrs
);
2285 ParsedAttributes
EmptyDeclSpecAttrs(AttrFactory
);
2286 if (DeclGroupPtrTy DGP
=
2287 ParseExternalDeclaration(DeclAttrs
, EmptyDeclSpecAttrs
)) {
2288 DeclGroupRef DG
= DGP
.get();
2289 DeclsInGroup
.append(DG
.begin(), DG
.end());
2294 return Actions
.ActOnFinishObjCImplementation(ObjCImpDecl
, DeclsInGroup
);
2297 Parser::DeclGroupPtrTy
2298 Parser::ParseObjCAtEndDeclaration(SourceRange atEnd
) {
2299 assert(Tok
.isObjCAtKeyword(tok::objc_end
) &&
2300 "ParseObjCAtEndDeclaration(): Expected @end");
2301 ConsumeToken(); // the "end" identifier
2302 if (CurParsedObjCImpl
)
2303 CurParsedObjCImpl
->finish(atEnd
);
2305 // missing @implementation
2306 Diag(atEnd
.getBegin(), diag::err_expected_objc_container
);
2310 Parser::ObjCImplParsingDataRAII::~ObjCImplParsingDataRAII() {
2312 finish(P
.Tok
.getLocation());
2313 if (P
.isEofOrEom()) {
2314 P
.Diag(P
.Tok
, diag::err_objc_missing_end
)
2315 << FixItHint::CreateInsertion(P
.Tok
.getLocation(), "\n@end\n");
2316 P
.Diag(Dcl
->getBeginLoc(), diag::note_objc_container_start
)
2317 << Sema::OCK_Implementation
;
2320 P
.CurParsedObjCImpl
= nullptr;
2321 assert(LateParsedObjCMethods
.empty());
2324 void Parser::ObjCImplParsingDataRAII::finish(SourceRange AtEnd
) {
2326 P
.Actions
.DefaultSynthesizeProperties(P
.getCurScope(), Dcl
, AtEnd
.getBegin());
2327 for (size_t i
= 0; i
< LateParsedObjCMethods
.size(); ++i
)
2328 P
.ParseLexedObjCMethodDefs(*LateParsedObjCMethods
[i
],
2331 P
.Actions
.ActOnAtEnd(P
.getCurScope(), AtEnd
);
2334 for (size_t i
= 0; i
< LateParsedObjCMethods
.size(); ++i
)
2335 P
.ParseLexedObjCMethodDefs(*LateParsedObjCMethods
[i
],
2336 false/*c-functions*/);
2338 /// Clear and free the cached objc methods.
2339 for (LateParsedObjCMethodContainer::iterator
2340 I
= LateParsedObjCMethods
.begin(),
2341 E
= LateParsedObjCMethods
.end(); I
!= E
; ++I
)
2343 LateParsedObjCMethods
.clear();
2348 /// compatibility-alias-decl:
2349 /// @compatibility_alias alias-name class-name ';'
2351 Decl
*Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc
) {
2352 assert(Tok
.isObjCAtKeyword(tok::objc_compatibility_alias
) &&
2353 "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias");
2354 ConsumeToken(); // consume compatibility_alias
2355 if (expectIdentifier())
2357 IdentifierInfo
*aliasId
= Tok
.getIdentifierInfo();
2358 SourceLocation aliasLoc
= ConsumeToken(); // consume alias-name
2359 if (expectIdentifier())
2361 IdentifierInfo
*classId
= Tok
.getIdentifierInfo();
2362 SourceLocation classLoc
= ConsumeToken(); // consume class-name;
2363 ExpectAndConsume(tok::semi
, diag::err_expected_after
, "@compatibility_alias");
2364 return Actions
.ActOnCompatibilityAlias(atLoc
, aliasId
, aliasLoc
,
2368 /// property-synthesis:
2369 /// @synthesize property-ivar-list ';'
2371 /// property-ivar-list:
2373 /// property-ivar-list ',' property-ivar
2377 /// identifier '=' identifier
2379 Decl
*Parser::ParseObjCPropertySynthesize(SourceLocation atLoc
) {
2380 assert(Tok
.isObjCAtKeyword(tok::objc_synthesize
) &&
2381 "ParseObjCPropertySynthesize(): Expected '@synthesize'");
2382 ConsumeToken(); // consume synthesize
2385 if (Tok
.is(tok::code_completion
)) {
2387 Actions
.CodeCompleteObjCPropertyDefinition(getCurScope());
2391 if (Tok
.isNot(tok::identifier
)) {
2392 Diag(Tok
, diag::err_synthesized_property_name
);
2393 SkipUntil(tok::semi
);
2397 IdentifierInfo
*propertyIvar
= nullptr;
2398 IdentifierInfo
*propertyId
= Tok
.getIdentifierInfo();
2399 SourceLocation propertyLoc
= ConsumeToken(); // consume property name
2400 SourceLocation propertyIvarLoc
;
2401 if (TryConsumeToken(tok::equal
)) {
2402 // property '=' ivar-name
2403 if (Tok
.is(tok::code_completion
)) {
2405 Actions
.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId
);
2409 if (expectIdentifier())
2411 propertyIvar
= Tok
.getIdentifierInfo();
2412 propertyIvarLoc
= ConsumeToken(); // consume ivar-name
2414 Actions
.ActOnPropertyImplDecl(
2415 getCurScope(), atLoc
, propertyLoc
, true,
2416 propertyId
, propertyIvar
, propertyIvarLoc
,
2417 ObjCPropertyQueryKind::OBJC_PR_query_unknown
);
2418 if (Tok
.isNot(tok::comma
))
2420 ConsumeToken(); // consume ','
2422 ExpectAndConsume(tok::semi
, diag::err_expected_after
, "@synthesize");
2426 /// property-dynamic:
2427 /// @dynamic property-list
2431 /// property-list ',' identifier
2433 Decl
*Parser::ParseObjCPropertyDynamic(SourceLocation atLoc
) {
2434 assert(Tok
.isObjCAtKeyword(tok::objc_dynamic
) &&
2435 "ParseObjCPropertyDynamic(): Expected '@dynamic'");
2436 ConsumeToken(); // consume dynamic
2438 bool isClassProperty
= false;
2439 if (Tok
.is(tok::l_paren
)) {
2441 const IdentifierInfo
*II
= Tok
.getIdentifierInfo();
2444 Diag(Tok
, diag::err_objc_expected_property_attr
) << II
;
2445 SkipUntil(tok::r_paren
, StopAtSemi
);
2447 SourceLocation AttrName
= ConsumeToken(); // consume attribute name
2448 if (II
->isStr("class")) {
2449 isClassProperty
= true;
2450 if (Tok
.isNot(tok::r_paren
)) {
2451 Diag(Tok
, diag::err_expected
) << tok::r_paren
;
2452 SkipUntil(tok::r_paren
, StopAtSemi
);
2456 Diag(AttrName
, diag::err_objc_expected_property_attr
) << II
;
2457 SkipUntil(tok::r_paren
, StopAtSemi
);
2463 if (Tok
.is(tok::code_completion
)) {
2465 Actions
.CodeCompleteObjCPropertyDefinition(getCurScope());
2469 if (expectIdentifier()) {
2470 SkipUntil(tok::semi
);
2474 IdentifierInfo
*propertyId
= Tok
.getIdentifierInfo();
2475 SourceLocation propertyLoc
= ConsumeToken(); // consume property name
2476 Actions
.ActOnPropertyImplDecl(
2477 getCurScope(), atLoc
, propertyLoc
, false,
2478 propertyId
, nullptr, SourceLocation(),
2479 isClassProperty
? ObjCPropertyQueryKind::OBJC_PR_query_class
:
2480 ObjCPropertyQueryKind::OBJC_PR_query_unknown
);
2482 if (Tok
.isNot(tok::comma
))
2484 ConsumeToken(); // consume ','
2486 ExpectAndConsume(tok::semi
, diag::err_expected_after
, "@dynamic");
2490 /// objc-throw-statement:
2491 /// throw expression[opt];
2493 StmtResult
Parser::ParseObjCThrowStmt(SourceLocation atLoc
) {
2495 ConsumeToken(); // consume throw
2496 if (Tok
.isNot(tok::semi
)) {
2497 Res
= ParseExpression();
2498 if (Res
.isInvalid()) {
2499 SkipUntil(tok::semi
);
2504 ExpectAndConsume(tok::semi
, diag::err_expected_after
, "@throw");
2505 return Actions
.ActOnObjCAtThrowStmt(atLoc
, Res
.get(), getCurScope());
2508 /// objc-synchronized-statement:
2509 /// @synchronized '(' expression ')' compound-statement
2512 Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc
) {
2513 ConsumeToken(); // consume synchronized
2514 if (Tok
.isNot(tok::l_paren
)) {
2515 Diag(Tok
, diag::err_expected_lparen_after
) << "@synchronized";
2519 // The operand is surrounded with parentheses.
2520 ConsumeParen(); // '('
2521 ExprResult
operand(ParseExpression());
2523 if (Tok
.is(tok::r_paren
)) {
2524 ConsumeParen(); // ')'
2526 if (!operand
.isInvalid())
2527 Diag(Tok
, diag::err_expected
) << tok::r_paren
;
2529 // Skip forward until we see a left brace, but don't consume it.
2530 SkipUntil(tok::l_brace
, StopAtSemi
| StopBeforeMatch
);
2533 // Require a compound statement.
2534 if (Tok
.isNot(tok::l_brace
)) {
2535 if (!operand
.isInvalid())
2536 Diag(Tok
, diag::err_expected
) << tok::l_brace
;
2540 // Check the @synchronized operand now.
2541 if (!operand
.isInvalid())
2542 operand
= Actions
.ActOnObjCAtSynchronizedOperand(atLoc
, operand
.get());
2544 // Parse the compound statement within a new scope.
2545 ParseScope
bodyScope(this, Scope::DeclScope
| Scope::CompoundStmtScope
);
2546 StmtResult
body(ParseCompoundStatementBody());
2549 // If there was a semantic or parse error earlier with the
2550 // operand, fail now.
2551 if (operand
.isInvalid())
2554 if (body
.isInvalid())
2555 body
= Actions
.ActOnNullStmt(Tok
.getLocation());
2557 return Actions
.ActOnObjCAtSynchronizedStmt(atLoc
, operand
.get(), body
.get());
2560 /// objc-try-catch-statement:
2561 /// @try compound-statement objc-catch-list[opt]
2562 /// @try compound-statement objc-catch-list[opt] @finally compound-statement
2564 /// objc-catch-list:
2565 /// @catch ( parameter-declaration ) compound-statement
2566 /// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement
2567 /// catch-parameter-declaration:
2568 /// parameter-declaration
2571 StmtResult
Parser::ParseObjCTryStmt(SourceLocation atLoc
) {
2572 bool catch_or_finally_seen
= false;
2574 ConsumeToken(); // consume try
2575 if (Tok
.isNot(tok::l_brace
)) {
2576 Diag(Tok
, diag::err_expected
) << tok::l_brace
;
2579 StmtVector CatchStmts
;
2580 StmtResult FinallyStmt
;
2581 ParseScope
TryScope(this, Scope::DeclScope
| Scope::CompoundStmtScope
);
2582 StmtResult
TryBody(ParseCompoundStatementBody());
2584 if (TryBody
.isInvalid())
2585 TryBody
= Actions
.ActOnNullStmt(Tok
.getLocation());
2587 while (Tok
.is(tok::at
)) {
2588 // At this point, we need to lookahead to determine if this @ is the start
2589 // of an @catch or @finally. We don't want to consume the @ token if this
2590 // is an @try or @encode or something else.
2591 Token AfterAt
= GetLookAheadToken(1);
2592 if (!AfterAt
.isObjCAtKeyword(tok::objc_catch
) &&
2593 !AfterAt
.isObjCAtKeyword(tok::objc_finally
))
2596 SourceLocation AtCatchFinallyLoc
= ConsumeToken();
2597 if (Tok
.isObjCAtKeyword(tok::objc_catch
)) {
2598 Decl
*FirstPart
= nullptr;
2599 ConsumeToken(); // consume catch
2600 if (Tok
.is(tok::l_paren
)) {
2602 ParseScope
CatchScope(this, Scope::DeclScope
|
2603 Scope::CompoundStmtScope
|
2604 Scope::AtCatchScope
);
2605 if (Tok
.isNot(tok::ellipsis
)) {
2606 DeclSpec
DS(AttrFactory
);
2607 ParseDeclarationSpecifiers(DS
);
2608 Declarator
ParmDecl(DS
, ParsedAttributesView::none(),
2609 DeclaratorContext::ObjCCatch
);
2610 ParseDeclarator(ParmDecl
);
2612 // Inform the actions module about the declarator, so it
2613 // gets added to the current scope.
2614 FirstPart
= Actions
.ActOnObjCExceptionDecl(getCurScope(), ParmDecl
);
2616 ConsumeToken(); // consume '...'
2618 SourceLocation RParenLoc
;
2620 if (Tok
.is(tok::r_paren
))
2621 RParenLoc
= ConsumeParen();
2622 else // Skip over garbage, until we get to ')'. Eat the ')'.
2623 SkipUntil(tok::r_paren
, StopAtSemi
);
2625 StmtResult
CatchBody(true);
2626 if (Tok
.is(tok::l_brace
))
2627 CatchBody
= ParseCompoundStatementBody();
2629 Diag(Tok
, diag::err_expected
) << tok::l_brace
;
2630 if (CatchBody
.isInvalid())
2631 CatchBody
= Actions
.ActOnNullStmt(Tok
.getLocation());
2633 StmtResult Catch
= Actions
.ActOnObjCAtCatchStmt(AtCatchFinallyLoc
,
2637 if (!Catch
.isInvalid())
2638 CatchStmts
.push_back(Catch
.get());
2641 Diag(AtCatchFinallyLoc
, diag::err_expected_lparen_after
)
2645 catch_or_finally_seen
= true;
2647 assert(Tok
.isObjCAtKeyword(tok::objc_finally
) && "Lookahead confused?");
2648 ConsumeToken(); // consume finally
2649 ParseScope
FinallyScope(this,
2650 Scope::DeclScope
| Scope::CompoundStmtScope
);
2652 bool ShouldCapture
=
2653 getTargetInfo().getTriple().isWindowsMSVCEnvironment();
2655 Actions
.ActOnCapturedRegionStart(Tok
.getLocation(), getCurScope(),
2656 CR_ObjCAtFinally
, 1);
2658 StmtResult
FinallyBody(true);
2659 if (Tok
.is(tok::l_brace
))
2660 FinallyBody
= ParseCompoundStatementBody();
2662 Diag(Tok
, diag::err_expected
) << tok::l_brace
;
2664 if (FinallyBody
.isInvalid()) {
2665 FinallyBody
= Actions
.ActOnNullStmt(Tok
.getLocation());
2667 Actions
.ActOnCapturedRegionError();
2668 } else if (ShouldCapture
) {
2669 FinallyBody
= Actions
.ActOnCapturedRegionEnd(FinallyBody
.get());
2672 FinallyStmt
= Actions
.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc
,
2674 catch_or_finally_seen
= true;
2678 if (!catch_or_finally_seen
) {
2679 Diag(atLoc
, diag::err_missing_catch_finally
);
2683 return Actions
.ActOnObjCAtTryStmt(atLoc
, TryBody
.get(),
2688 /// objc-autoreleasepool-statement:
2689 /// @autoreleasepool compound-statement
2692 Parser::ParseObjCAutoreleasePoolStmt(SourceLocation atLoc
) {
2693 ConsumeToken(); // consume autoreleasepool
2694 if (Tok
.isNot(tok::l_brace
)) {
2695 Diag(Tok
, diag::err_expected
) << tok::l_brace
;
2698 // Enter a scope to hold everything within the compound stmt. Compound
2699 // statements can always hold declarations.
2700 ParseScope
BodyScope(this, Scope::DeclScope
| Scope::CompoundStmtScope
);
2702 StmtResult
AutoreleasePoolBody(ParseCompoundStatementBody());
2705 if (AutoreleasePoolBody
.isInvalid())
2706 AutoreleasePoolBody
= Actions
.ActOnNullStmt(Tok
.getLocation());
2707 return Actions
.ActOnObjCAutoreleasePoolStmt(atLoc
,
2708 AutoreleasePoolBody
.get());
2711 /// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them
2712 /// for later parsing.
2713 void Parser::StashAwayMethodOrFunctionBodyTokens(Decl
*MDecl
) {
2714 if (SkipFunctionBodies
&& (!MDecl
|| Actions
.canSkipFunctionBody(MDecl
)) &&
2715 trySkippingFunctionBody()) {
2716 Actions
.ActOnSkippedFunctionBody(MDecl
);
2720 LexedMethod
* LM
= new LexedMethod(this, MDecl
);
2721 CurParsedObjCImpl
->LateParsedObjCMethods
.push_back(LM
);
2722 CachedTokens
&Toks
= LM
->Toks
;
2723 // Begin by storing the '{' or 'try' or ':' token.
2724 Toks
.push_back(Tok
);
2725 if (Tok
.is(tok::kw_try
)) {
2727 if (Tok
.is(tok::colon
)) {
2728 Toks
.push_back(Tok
);
2730 while (Tok
.isNot(tok::l_brace
)) {
2731 ConsumeAndStoreUntil(tok::l_paren
, Toks
, /*StopAtSemi=*/false);
2732 ConsumeAndStoreUntil(tok::r_paren
, Toks
, /*StopAtSemi=*/false);
2735 Toks
.push_back(Tok
); // also store '{'
2737 else if (Tok
.is(tok::colon
)) {
2739 // FIXME: This is wrong, due to C++11 braced initialization.
2740 while (Tok
.isNot(tok::l_brace
)) {
2741 ConsumeAndStoreUntil(tok::l_paren
, Toks
, /*StopAtSemi=*/false);
2742 ConsumeAndStoreUntil(tok::r_paren
, Toks
, /*StopAtSemi=*/false);
2744 Toks
.push_back(Tok
); // also store '{'
2747 // Consume everything up to (and including) the matching right brace.
2748 ConsumeAndStoreUntil(tok::r_brace
, Toks
, /*StopAtSemi=*/false);
2749 while (Tok
.is(tok::kw_catch
)) {
2750 ConsumeAndStoreUntil(tok::l_brace
, Toks
, /*StopAtSemi=*/false);
2751 ConsumeAndStoreUntil(tok::r_brace
, Toks
, /*StopAtSemi=*/false);
2755 /// objc-method-def: objc-method-proto ';'[opt] '{' body '}'
2757 Decl
*Parser::ParseObjCMethodDefinition() {
2758 Decl
*MDecl
= ParseObjCMethodPrototype();
2760 PrettyDeclStackTraceEntry
CrashInfo(Actions
.Context
, MDecl
, Tok
.getLocation(),
2761 "parsing Objective-C method");
2763 // parse optional ';'
2764 if (Tok
.is(tok::semi
)) {
2765 if (CurParsedObjCImpl
) {
2766 Diag(Tok
, diag::warn_semicolon_before_method_body
)
2767 << FixItHint::CreateRemoval(Tok
.getLocation());
2772 // We should have an opening brace now.
2773 if (Tok
.isNot(tok::l_brace
)) {
2774 Diag(Tok
, diag::err_expected_method_body
);
2776 // Skip over garbage, until we get to '{'. Don't eat the '{'.
2777 SkipUntil(tok::l_brace
, StopAtSemi
| StopBeforeMatch
);
2779 // If we didn't find the '{', bail out.
2780 if (Tok
.isNot(tok::l_brace
))
2786 SkipUntil(tok::r_brace
);
2790 // Allow the rest of sema to find private method decl implementations.
2791 Actions
.AddAnyMethodToGlobalPool(MDecl
);
2792 assert (CurParsedObjCImpl
2793 && "ParseObjCMethodDefinition - Method out of @implementation");
2794 // Consume the tokens and store them for later parsing.
2795 StashAwayMethodOrFunctionBodyTokens(MDecl
);
2799 StmtResult
Parser::ParseObjCAtStatement(SourceLocation AtLoc
,
2800 ParsedStmtContext StmtCtx
) {
2801 if (Tok
.is(tok::code_completion
)) {
2803 Actions
.CodeCompleteObjCAtStatement(getCurScope());
2807 if (Tok
.isObjCAtKeyword(tok::objc_try
))
2808 return ParseObjCTryStmt(AtLoc
);
2810 if (Tok
.isObjCAtKeyword(tok::objc_throw
))
2811 return ParseObjCThrowStmt(AtLoc
);
2813 if (Tok
.isObjCAtKeyword(tok::objc_synchronized
))
2814 return ParseObjCSynchronizedStmt(AtLoc
);
2816 if (Tok
.isObjCAtKeyword(tok::objc_autoreleasepool
))
2817 return ParseObjCAutoreleasePoolStmt(AtLoc
);
2819 if (Tok
.isObjCAtKeyword(tok::objc_import
) &&
2820 getLangOpts().DebuggerSupport
) {
2821 SkipUntil(tok::semi
);
2822 return Actions
.ActOnNullStmt(Tok
.getLocation());
2825 ExprStatementTokLoc
= AtLoc
;
2826 ExprResult
Res(ParseExpressionWithLeadingAt(AtLoc
));
2827 if (Res
.isInvalid()) {
2828 // If the expression is invalid, skip ahead to the next semicolon. Not
2829 // doing this opens us up to the possibility of infinite loops if
2830 // ParseExpression does not consume any tokens.
2831 SkipUntil(tok::semi
);
2835 // Otherwise, eat the semicolon.
2836 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr
);
2837 return handleExprStmt(Res
, StmtCtx
);
2840 ExprResult
Parser::ParseObjCAtExpression(SourceLocation AtLoc
) {
2841 switch (Tok
.getKind()) {
2842 case tok::code_completion
:
2844 Actions
.CodeCompleteObjCAtExpression(getCurScope());
2849 tok::TokenKind Kind
= Tok
.getKind();
2850 SourceLocation OpLoc
= ConsumeToken();
2852 if (!Tok
.is(tok::numeric_constant
)) {
2853 const char *Symbol
= nullptr;
2855 case tok::minus
: Symbol
= "-"; break;
2856 case tok::plus
: Symbol
= "+"; break;
2857 default: llvm_unreachable("missing unary operator case");
2859 Diag(Tok
, diag::err_nsnumber_nonliteral_unary
)
2864 ExprResult
Lit(Actions
.ActOnNumericConstant(Tok
));
2865 if (Lit
.isInvalid()) {
2868 ConsumeToken(); // Consume the literal token.
2870 Lit
= Actions
.ActOnUnaryOp(getCurScope(), OpLoc
, Kind
, Lit
.get());
2871 if (Lit
.isInvalid())
2874 return ParsePostfixExpressionSuffix(
2875 Actions
.BuildObjCNumericLiteral(AtLoc
, Lit
.get()));
2878 case tok::string_literal
: // primary-expression: string-literal
2879 case tok::wide_string_literal
:
2880 return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc
));
2882 case tok::char_constant
:
2883 return ParsePostfixExpressionSuffix(ParseObjCCharacterLiteral(AtLoc
));
2885 case tok::numeric_constant
:
2886 return ParsePostfixExpressionSuffix(ParseObjCNumericLiteral(AtLoc
));
2888 case tok::kw_true
: // Objective-C++, etc.
2889 case tok::kw___objc_yes
: // c/c++/objc/objc++ __objc_yes
2890 return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc
, true));
2891 case tok::kw_false
: // Objective-C++, etc.
2892 case tok::kw___objc_no
: // c/c++/objc/objc++ __objc_no
2893 return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc
, false));
2896 // Objective-C array literal
2897 return ParsePostfixExpressionSuffix(ParseObjCArrayLiteral(AtLoc
));
2900 // Objective-C dictionary literal
2901 return ParsePostfixExpressionSuffix(ParseObjCDictionaryLiteral(AtLoc
));
2904 // Objective-C boxed expression
2905 return ParsePostfixExpressionSuffix(ParseObjCBoxedExpr(AtLoc
));
2908 if (Tok
.getIdentifierInfo() == nullptr)
2909 return ExprError(Diag(AtLoc
, diag::err_unexpected_at
));
2911 switch (Tok
.getIdentifierInfo()->getObjCKeywordID()) {
2912 case tok::objc_encode
:
2913 return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc
));
2914 case tok::objc_protocol
:
2915 return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc
));
2916 case tok::objc_selector
:
2917 return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc
));
2918 case tok::objc_available
:
2919 return ParseAvailabilityCheckExpr(AtLoc
);
2921 const char *str
= nullptr;
2922 // Only provide the @try/@finally/@autoreleasepool fixit when we're sure
2923 // that this is a proper statement where such directives could actually
2925 if (GetLookAheadToken(1).is(tok::l_brace
) &&
2926 ExprStatementTokLoc
== AtLoc
) {
2927 char ch
= Tok
.getIdentifierInfo()->getNameStart()[0];
2930 : (ch
== 'f' ? "finally"
2931 : (ch
== 'a' ? "autoreleasepool" : nullptr));
2934 SourceLocation kwLoc
= Tok
.getLocation();
2935 return ExprError(Diag(AtLoc
, diag::err_unexpected_at
) <<
2936 FixItHint::CreateReplacement(kwLoc
, str
));
2939 return ExprError(Diag(AtLoc
, diag::err_unexpected_at
));
2945 /// Parse the receiver of an Objective-C++ message send.
2947 /// This routine parses the receiver of a message send in
2948 /// Objective-C++ either as a type or as an expression. Note that this
2949 /// routine must not be called to parse a send to 'super', since it
2950 /// has no way to return such a result.
2952 /// \param IsExpr Whether the receiver was parsed as an expression.
2954 /// \param TypeOrExpr If the receiver was parsed as an expression (\c
2955 /// IsExpr is true), the parsed expression. If the receiver was parsed
2956 /// as a type (\c IsExpr is false), the parsed type.
2958 /// \returns True if an error occurred during parsing or semantic
2959 /// analysis, in which case the arguments do not have valid
2960 /// values. Otherwise, returns false for a successful parse.
2962 /// objc-receiver: [C++]
2963 /// 'super' [not parsed here]
2965 /// simple-type-specifier
2966 /// typename-specifier
2967 bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr
, void *&TypeOrExpr
) {
2968 InMessageExpressionRAIIObject
InMessage(*this, true);
2970 if (Tok
.isOneOf(tok::identifier
, tok::coloncolon
, tok::kw_typename
,
2971 tok::annot_cxxscope
))
2972 TryAnnotateTypeOrScopeToken();
2974 if (!Actions
.isSimpleTypeSpecifier(Tok
.getKind())) {
2977 // Make sure any typos in the receiver are corrected or diagnosed, so that
2978 // proper recovery can happen. FIXME: Perhaps filter the corrected expr to
2979 // only the things that are valid ObjC receivers?
2980 ExprResult Receiver
= Actions
.CorrectDelayedTyposInExpr(ParseExpression());
2981 if (Receiver
.isInvalid())
2985 TypeOrExpr
= Receiver
.get();
2990 // typename-specifier
2991 // simple-type-specifier
2992 // expression (that starts with one of the above)
2993 DeclSpec
DS(AttrFactory
);
2994 ParseCXXSimpleTypeSpecifier(DS
);
2996 if (Tok
.is(tok::l_paren
)) {
2997 // If we see an opening parentheses at this point, we are
2998 // actually parsing an expression that starts with a
2999 // function-style cast, e.g.,
3001 // postfix-expression:
3002 // simple-type-specifier ( expression-list [opt] )
3003 // typename-specifier ( expression-list [opt] )
3005 // Parse the remainder of this case, then the (optional)
3006 // postfix-expression suffix, followed by the (optional)
3007 // right-hand side of the binary expression. We have an
3009 ExprResult Receiver
= ParseCXXTypeConstructExpression(DS
);
3010 if (!Receiver
.isInvalid())
3011 Receiver
= ParsePostfixExpressionSuffix(Receiver
.get());
3012 if (!Receiver
.isInvalid())
3013 Receiver
= ParseRHSOfBinaryExpression(Receiver
.get(), prec::Comma
);
3014 if (Receiver
.isInvalid())
3018 TypeOrExpr
= Receiver
.get();
3022 // We have a class message. Turn the simple-type-specifier or
3023 // typename-specifier we parsed into a type and parse the
3024 // remainder of the class message.
3025 Declarator
DeclaratorInfo(DS
, ParsedAttributesView::none(),
3026 DeclaratorContext::TypeName
);
3027 TypeResult Type
= Actions
.ActOnTypeName(DeclaratorInfo
);
3028 if (Type
.isInvalid())
3032 TypeOrExpr
= Type
.get().getAsOpaquePtr();
3036 /// Determine whether the parser is currently referring to a an
3037 /// Objective-C message send, using a simplified heuristic to avoid overhead.
3039 /// This routine will only return true for a subset of valid message-send
3041 bool Parser::isSimpleObjCMessageExpression() {
3042 assert(Tok
.is(tok::l_square
) && getLangOpts().ObjC
&&
3043 "Incorrect start for isSimpleObjCMessageExpression");
3044 return GetLookAheadToken(1).is(tok::identifier
) &&
3045 GetLookAheadToken(2).is(tok::identifier
);
3048 bool Parser::isStartOfObjCClassMessageMissingOpenBracket() {
3049 if (!getLangOpts().ObjC
|| !NextToken().is(tok::identifier
) ||
3050 InMessageExpression
)
3055 if (Tok
.is(tok::annot_typename
))
3056 Type
= getTypeAnnotation(Tok
);
3057 else if (Tok
.is(tok::identifier
))
3058 Type
= Actions
.getTypeName(*Tok
.getIdentifierInfo(), Tok
.getLocation(),
3063 // FIXME: Should not be querying properties of types from the parser.
3064 if (Type
.isUsable() && Type
.get().get()->isObjCObjectOrInterfaceType()) {
3065 const Token
&AfterNext
= GetLookAheadToken(2);
3066 if (AfterNext
.isOneOf(tok::colon
, tok::r_square
)) {
3067 if (Tok
.is(tok::identifier
))
3068 TryAnnotateTypeOrScopeToken();
3070 return Tok
.is(tok::annot_typename
);
3077 /// objc-message-expr:
3078 /// '[' objc-receiver objc-message-args ']'
3080 /// objc-receiver: [C]
3086 ExprResult
Parser::ParseObjCMessageExpression() {
3087 assert(Tok
.is(tok::l_square
) && "'[' expected");
3088 SourceLocation LBracLoc
= ConsumeBracket(); // consume '['
3090 if (Tok
.is(tok::code_completion
)) {
3092 Actions
.CodeCompleteObjCMessageReceiver(getCurScope());
3096 InMessageExpressionRAIIObject
InMessage(*this, true);
3098 if (getLangOpts().CPlusPlus
) {
3099 // We completely separate the C and C++ cases because C++ requires
3100 // more complicated (read: slower) parsing.
3102 // Handle send to super.
3103 // FIXME: This doesn't benefit from the same typo-correction we
3104 // get in Objective-C.
3105 if (Tok
.is(tok::identifier
) && Tok
.getIdentifierInfo() == Ident_super
&&
3106 NextToken().isNot(tok::period
) && getCurScope()->isInObjcMethodScope())
3107 return ParseObjCMessageExpressionBody(LBracLoc
, ConsumeToken(), nullptr,
3110 // Parse the receiver, which is either a type or an expression.
3112 void *TypeOrExpr
= nullptr;
3113 if (ParseObjCXXMessageReceiver(IsExpr
, TypeOrExpr
)) {
3114 SkipUntil(tok::r_square
, StopAtSemi
);
3119 return ParseObjCMessageExpressionBody(LBracLoc
, SourceLocation(), nullptr,
3120 static_cast<Expr
*>(TypeOrExpr
));
3122 return ParseObjCMessageExpressionBody(LBracLoc
, SourceLocation(),
3123 ParsedType::getFromOpaquePtr(TypeOrExpr
),
3127 if (Tok
.is(tok::identifier
)) {
3128 IdentifierInfo
*Name
= Tok
.getIdentifierInfo();
3129 SourceLocation NameLoc
= Tok
.getLocation();
3130 ParsedType ReceiverType
;
3131 switch (Actions
.getObjCMessageKind(getCurScope(), Name
, NameLoc
,
3132 Name
== Ident_super
,
3133 NextToken().is(tok::period
),
3135 case Sema::ObjCSuperMessage
:
3136 return ParseObjCMessageExpressionBody(LBracLoc
, ConsumeToken(), nullptr,
3139 case Sema::ObjCClassMessage
:
3140 if (!ReceiverType
) {
3141 SkipUntil(tok::r_square
, StopAtSemi
);
3145 ConsumeToken(); // the type name
3147 // Parse type arguments and protocol qualifiers.
3148 if (Tok
.is(tok::less
)) {
3149 SourceLocation NewEndLoc
;
3150 TypeResult NewReceiverType
3151 = parseObjCTypeArgsAndProtocolQualifiers(NameLoc
, ReceiverType
,
3152 /*consumeLastToken=*/true,
3154 if (!NewReceiverType
.isUsable()) {
3155 SkipUntil(tok::r_square
, StopAtSemi
);
3159 ReceiverType
= NewReceiverType
.get();
3162 return ParseObjCMessageExpressionBody(LBracLoc
, SourceLocation(),
3163 ReceiverType
, nullptr);
3165 case Sema::ObjCInstanceMessage
:
3166 // Fall through to parse an expression.
3171 // Otherwise, an arbitrary expression can be the receiver of a send.
3172 ExprResult Res
= Actions
.CorrectDelayedTyposInExpr(ParseExpression());
3173 if (Res
.isInvalid()) {
3174 SkipUntil(tok::r_square
, StopAtSemi
);
3178 return ParseObjCMessageExpressionBody(LBracLoc
, SourceLocation(), nullptr,
3182 /// Parse the remainder of an Objective-C message following the
3183 /// '[' objc-receiver.
3185 /// This routine handles sends to super, class messages (sent to a
3186 /// class name), and instance messages (sent to an object), and the
3187 /// target is represented by \p SuperLoc, \p ReceiverType, or \p
3188 /// ReceiverExpr, respectively. Only one of these parameters may have
3191 /// \param LBracLoc The location of the opening '['.
3193 /// \param SuperLoc If this is a send to 'super', the location of the
3194 /// 'super' keyword that indicates a send to the superclass.
3196 /// \param ReceiverType If this is a class message, the type of the
3197 /// class we are sending a message to.
3199 /// \param ReceiverExpr If this is an instance message, the expression
3200 /// used to compute the receiver object.
3202 /// objc-message-args:
3204 /// objc-keywordarg-list
3206 /// objc-keywordarg-list:
3208 /// objc-keywordarg-list objc-keywordarg
3210 /// objc-keywordarg:
3211 /// selector-name[opt] ':' objc-keywordexpr
3213 /// objc-keywordexpr:
3214 /// nonempty-expr-list
3216 /// nonempty-expr-list:
3217 /// assignment-expression
3218 /// nonempty-expr-list , assignment-expression
3221 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc
,
3222 SourceLocation SuperLoc
,
3223 ParsedType ReceiverType
,
3224 Expr
*ReceiverExpr
) {
3225 InMessageExpressionRAIIObject
InMessage(*this, true);
3227 if (Tok
.is(tok::code_completion
)) {
3229 if (SuperLoc
.isValid())
3230 Actions
.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc
,
3231 std::nullopt
, false);
3232 else if (ReceiverType
)
3233 Actions
.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType
,
3234 std::nullopt
, false);
3236 Actions
.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr
,
3237 std::nullopt
, false);
3241 // Parse objc-selector
3243 IdentifierInfo
*selIdent
= ParseObjCSelectorPiece(Loc
);
3245 SmallVector
<IdentifierInfo
*, 12> KeyIdents
;
3246 SmallVector
<SourceLocation
, 12> KeyLocs
;
3247 ExprVector KeyExprs
;
3249 if (Tok
.is(tok::colon
)) {
3251 // Each iteration parses a single keyword argument.
3252 KeyIdents
.push_back(selIdent
);
3253 KeyLocs
.push_back(Loc
);
3255 if (ExpectAndConsume(tok::colon
)) {
3256 // We must manually skip to a ']', otherwise the expression skipper will
3257 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3258 // the enclosing expression.
3259 SkipUntil(tok::r_square
, StopAtSemi
);
3263 /// Parse the expression after ':'
3265 if (Tok
.is(tok::code_completion
)) {
3267 if (SuperLoc
.isValid())
3268 Actions
.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc
,
3270 /*AtArgumentExpression=*/true);
3271 else if (ReceiverType
)
3272 Actions
.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType
,
3274 /*AtArgumentExpression=*/true);
3276 Actions
.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr
,
3278 /*AtArgumentExpression=*/true);
3284 if (getLangOpts().CPlusPlus11
&& Tok
.is(tok::l_brace
)) {
3285 Diag(Tok
, diag::warn_cxx98_compat_generalized_initializer_lists
);
3286 Expr
= ParseBraceInitializer();
3288 Expr
= ParseAssignmentExpression();
3290 ExprResult
Res(Expr
);
3291 if (Res
.isInvalid()) {
3292 // We must manually skip to a ']', otherwise the expression skipper will
3293 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3294 // the enclosing expression.
3295 SkipUntil(tok::r_square
, StopAtSemi
);
3299 // We have a valid expression.
3300 KeyExprs
.push_back(Res
.get());
3302 // Code completion after each argument.
3303 if (Tok
.is(tok::code_completion
)) {
3305 if (SuperLoc
.isValid())
3306 Actions
.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc
,
3308 /*AtArgumentExpression=*/false);
3309 else if (ReceiverType
)
3310 Actions
.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType
,
3312 /*AtArgumentExpression=*/false);
3314 Actions
.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr
,
3316 /*AtArgumentExpression=*/false);
3320 // Check for another keyword selector.
3321 selIdent
= ParseObjCSelectorPiece(Loc
);
3322 if (!selIdent
&& Tok
.isNot(tok::colon
))
3324 // We have a selector or a colon, continue parsing.
3326 // Parse the, optional, argument list, comma separated.
3327 while (Tok
.is(tok::comma
)) {
3328 SourceLocation commaLoc
= ConsumeToken(); // Eat the ','.
3329 /// Parse the expression after ','
3330 ExprResult
Res(ParseAssignmentExpression());
3331 if (Tok
.is(tok::colon
))
3332 Res
= Actions
.CorrectDelayedTyposInExpr(Res
);
3333 if (Res
.isInvalid()) {
3334 if (Tok
.is(tok::colon
)) {
3335 Diag(commaLoc
, diag::note_extra_comma_message_arg
) <<
3336 FixItHint::CreateRemoval(commaLoc
);
3338 // We must manually skip to a ']', otherwise the expression skipper will
3339 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3340 // the enclosing expression.
3341 SkipUntil(tok::r_square
, StopAtSemi
);
3345 // We have a valid expression.
3346 KeyExprs
.push_back(Res
.get());
3348 } else if (!selIdent
) {
3349 Diag(Tok
, diag::err_expected
) << tok::identifier
; // missing selector name.
3351 // We must manually skip to a ']', otherwise the expression skipper will
3352 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3353 // the enclosing expression.
3354 SkipUntil(tok::r_square
, StopAtSemi
);
3358 if (Tok
.isNot(tok::r_square
)) {
3359 Diag(Tok
, diag::err_expected
)
3360 << (Tok
.is(tok::identifier
) ? tok::colon
: tok::r_square
);
3361 // We must manually skip to a ']', otherwise the expression skipper will
3362 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3363 // the enclosing expression.
3364 SkipUntil(tok::r_square
, StopAtSemi
);
3368 SourceLocation RBracLoc
= ConsumeBracket(); // consume ']'
3370 unsigned nKeys
= KeyIdents
.size();
3372 KeyIdents
.push_back(selIdent
);
3373 KeyLocs
.push_back(Loc
);
3375 Selector Sel
= PP
.getSelectorTable().getSelector(nKeys
, &KeyIdents
[0]);
3377 if (SuperLoc
.isValid())
3378 return Actions
.ActOnSuperMessage(getCurScope(), SuperLoc
, Sel
,
3379 LBracLoc
, KeyLocs
, RBracLoc
, KeyExprs
);
3380 else if (ReceiverType
)
3381 return Actions
.ActOnClassMessage(getCurScope(), ReceiverType
, Sel
,
3382 LBracLoc
, KeyLocs
, RBracLoc
, KeyExprs
);
3383 return Actions
.ActOnInstanceMessage(getCurScope(), ReceiverExpr
, Sel
,
3384 LBracLoc
, KeyLocs
, RBracLoc
, KeyExprs
);
3387 ExprResult
Parser::ParseObjCStringLiteral(SourceLocation AtLoc
) {
3388 ExprResult
Res(ParseStringLiteralExpression());
3389 if (Res
.isInvalid()) return Res
;
3391 // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string
3392 // expressions. At this point, we know that the only valid thing that starts
3393 // with '@' is an @"".
3394 SmallVector
<SourceLocation
, 4> AtLocs
;
3395 ExprVector AtStrings
;
3396 AtLocs
.push_back(AtLoc
);
3397 AtStrings
.push_back(Res
.get());
3399 while (Tok
.is(tok::at
)) {
3400 AtLocs
.push_back(ConsumeToken()); // eat the @.
3402 // Invalid unless there is a string literal.
3403 if (!isTokenStringLiteral())
3404 return ExprError(Diag(Tok
, diag::err_objc_concat_string
));
3406 ExprResult
Lit(ParseStringLiteralExpression());
3407 if (Lit
.isInvalid())
3410 AtStrings
.push_back(Lit
.get());
3413 return Actions
.ParseObjCStringLiteral(AtLocs
.data(), AtStrings
);
3416 /// ParseObjCBooleanLiteral -
3417 /// objc-scalar-literal : '@' boolean-keyword
3419 /// boolean-keyword: 'true' | 'false' | '__objc_yes' | '__objc_no'
3421 ExprResult
Parser::ParseObjCBooleanLiteral(SourceLocation AtLoc
,
3423 SourceLocation EndLoc
= ConsumeToken(); // consume the keyword.
3424 return Actions
.ActOnObjCBoolLiteral(AtLoc
, EndLoc
, ArgValue
);
3427 /// ParseObjCCharacterLiteral -
3428 /// objc-scalar-literal : '@' character-literal
3430 ExprResult
Parser::ParseObjCCharacterLiteral(SourceLocation AtLoc
) {
3431 ExprResult
Lit(Actions
.ActOnCharacterConstant(Tok
));
3432 if (Lit
.isInvalid()) {
3435 ConsumeToken(); // Consume the literal token.
3436 return Actions
.BuildObjCNumericLiteral(AtLoc
, Lit
.get());
3439 /// ParseObjCNumericLiteral -
3440 /// objc-scalar-literal : '@' scalar-literal
3442 /// scalar-literal : | numeric-constant /* any numeric constant. */
3444 ExprResult
Parser::ParseObjCNumericLiteral(SourceLocation AtLoc
) {
3445 ExprResult
Lit(Actions
.ActOnNumericConstant(Tok
));
3446 if (Lit
.isInvalid()) {
3449 ConsumeToken(); // Consume the literal token.
3450 return Actions
.BuildObjCNumericLiteral(AtLoc
, Lit
.get());
3453 /// ParseObjCBoxedExpr -
3454 /// objc-box-expression:
3455 /// @( assignment-expression )
3457 Parser::ParseObjCBoxedExpr(SourceLocation AtLoc
) {
3458 if (Tok
.isNot(tok::l_paren
))
3459 return ExprError(Diag(Tok
, diag::err_expected_lparen_after
) << "@");
3461 BalancedDelimiterTracker
T(*this, tok::l_paren
);
3463 ExprResult
ValueExpr(ParseAssignmentExpression());
3464 if (T
.consumeClose())
3467 if (ValueExpr
.isInvalid())
3470 // Wrap the sub-expression in a parenthesized expression, to distinguish
3471 // a boxed expression from a literal.
3472 SourceLocation LPLoc
= T
.getOpenLocation(), RPLoc
= T
.getCloseLocation();
3473 ValueExpr
= Actions
.ActOnParenExpr(LPLoc
, RPLoc
, ValueExpr
.get());
3474 return Actions
.BuildObjCBoxedExpr(SourceRange(AtLoc
, RPLoc
),
3478 ExprResult
Parser::ParseObjCArrayLiteral(SourceLocation AtLoc
) {
3479 ExprVector ElementExprs
; // array elements.
3480 ConsumeBracket(); // consume the l_square.
3482 bool HasInvalidEltExpr
= false;
3483 while (Tok
.isNot(tok::r_square
)) {
3484 // Parse list of array element expressions (all must be id types).
3485 ExprResult
Res(ParseAssignmentExpression());
3486 if (Res
.isInvalid()) {
3487 // We must manually skip to a ']', otherwise the expression skipper will
3488 // stop at the ']' when it skips to the ';'. We want it to skip beyond
3489 // the enclosing expression.
3490 SkipUntil(tok::r_square
, StopAtSemi
);
3494 Res
= Actions
.CorrectDelayedTyposInExpr(Res
.get());
3495 if (Res
.isInvalid())
3496 HasInvalidEltExpr
= true;
3498 // Parse the ellipsis that indicates a pack expansion.
3499 if (Tok
.is(tok::ellipsis
))
3500 Res
= Actions
.ActOnPackExpansion(Res
.get(), ConsumeToken());
3501 if (Res
.isInvalid())
3502 HasInvalidEltExpr
= true;
3504 ElementExprs
.push_back(Res
.get());
3506 if (Tok
.is(tok::comma
))
3507 ConsumeToken(); // Eat the ','.
3508 else if (Tok
.isNot(tok::r_square
))
3509 return ExprError(Diag(Tok
, diag::err_expected_either
) << tok::r_square
3512 SourceLocation EndLoc
= ConsumeBracket(); // location of ']'
3514 if (HasInvalidEltExpr
)
3517 MultiExprArg
Args(ElementExprs
);
3518 return Actions
.BuildObjCArrayLiteral(SourceRange(AtLoc
, EndLoc
), Args
);
3521 ExprResult
Parser::ParseObjCDictionaryLiteral(SourceLocation AtLoc
) {
3522 SmallVector
<ObjCDictionaryElement
, 4> Elements
; // dictionary elements.
3523 ConsumeBrace(); // consume the l_square.
3524 bool HasInvalidEltExpr
= false;
3525 while (Tok
.isNot(tok::r_brace
)) {
3526 // Parse the comma separated key : value expressions.
3529 ColonProtectionRAIIObject
X(*this);
3530 KeyExpr
= ParseAssignmentExpression();
3531 if (KeyExpr
.isInvalid()) {
3532 // We must manually skip to a '}', otherwise the expression skipper will
3533 // stop at the '}' when it skips to the ';'. We want it to skip beyond
3534 // the enclosing expression.
3535 SkipUntil(tok::r_brace
, StopAtSemi
);
3540 if (ExpectAndConsume(tok::colon
)) {
3541 SkipUntil(tok::r_brace
, StopAtSemi
);
3545 ExprResult
ValueExpr(ParseAssignmentExpression());
3546 if (ValueExpr
.isInvalid()) {
3547 // We must manually skip to a '}', otherwise the expression skipper will
3548 // stop at the '}' when it skips to the ';'. We want it to skip beyond
3549 // the enclosing expression.
3550 SkipUntil(tok::r_brace
, StopAtSemi
);
3554 // Check the key and value for possible typos
3555 KeyExpr
= Actions
.CorrectDelayedTyposInExpr(KeyExpr
.get());
3556 ValueExpr
= Actions
.CorrectDelayedTyposInExpr(ValueExpr
.get());
3557 if (KeyExpr
.isInvalid() || ValueExpr
.isInvalid())
3558 HasInvalidEltExpr
= true;
3560 // Parse the ellipsis that designates this as a pack expansion. Do not
3561 // ActOnPackExpansion here, leave it to template instantiation time where
3562 // we can get better diagnostics.
3563 SourceLocation EllipsisLoc
;
3564 if (getLangOpts().CPlusPlus
)
3565 TryConsumeToken(tok::ellipsis
, EllipsisLoc
);
3567 // We have a valid expression. Collect it in a vector so we can
3568 // build the argument list.
3569 ObjCDictionaryElement Element
= {KeyExpr
.get(), ValueExpr
.get(),
3570 EllipsisLoc
, std::nullopt
};
3571 Elements
.push_back(Element
);
3573 if (!TryConsumeToken(tok::comma
) && Tok
.isNot(tok::r_brace
))
3574 return ExprError(Diag(Tok
, diag::err_expected_either
) << tok::r_brace
3577 SourceLocation EndLoc
= ConsumeBrace();
3579 if (HasInvalidEltExpr
)
3582 // Create the ObjCDictionaryLiteral.
3583 return Actions
.BuildObjCDictionaryLiteral(SourceRange(AtLoc
, EndLoc
),
3587 /// objc-encode-expression:
3588 /// \@encode ( type-name )
3590 Parser::ParseObjCEncodeExpression(SourceLocation AtLoc
) {
3591 assert(Tok
.isObjCAtKeyword(tok::objc_encode
) && "Not an @encode expression!");
3593 SourceLocation EncLoc
= ConsumeToken();
3595 if (Tok
.isNot(tok::l_paren
))
3596 return ExprError(Diag(Tok
, diag::err_expected_lparen_after
) << "@encode");
3598 BalancedDelimiterTracker
T(*this, tok::l_paren
);
3601 TypeResult Ty
= ParseTypeName();
3608 return Actions
.ParseObjCEncodeExpression(AtLoc
, EncLoc
, T
.getOpenLocation(),
3609 Ty
.get(), T
.getCloseLocation());
3612 /// objc-protocol-expression
3613 /// \@protocol ( protocol-name )
3615 Parser::ParseObjCProtocolExpression(SourceLocation AtLoc
) {
3616 SourceLocation ProtoLoc
= ConsumeToken();
3618 if (Tok
.isNot(tok::l_paren
))
3619 return ExprError(Diag(Tok
, diag::err_expected_lparen_after
) << "@protocol");
3621 BalancedDelimiterTracker
T(*this, tok::l_paren
);
3624 if (expectIdentifier())
3627 IdentifierInfo
*protocolId
= Tok
.getIdentifierInfo();
3628 SourceLocation ProtoIdLoc
= ConsumeToken();
3632 return Actions
.ParseObjCProtocolExpression(protocolId
, AtLoc
, ProtoLoc
,
3633 T
.getOpenLocation(), ProtoIdLoc
,
3634 T
.getCloseLocation());
3637 /// objc-selector-expression
3638 /// @selector '(' '('[opt] objc-keyword-selector ')'[opt] ')'
3639 ExprResult
Parser::ParseObjCSelectorExpression(SourceLocation AtLoc
) {
3640 SourceLocation SelectorLoc
= ConsumeToken();
3642 if (Tok
.isNot(tok::l_paren
))
3643 return ExprError(Diag(Tok
, diag::err_expected_lparen_after
) << "@selector");
3645 SmallVector
<IdentifierInfo
*, 12> KeyIdents
;
3646 SourceLocation sLoc
;
3648 BalancedDelimiterTracker
T(*this, tok::l_paren
);
3650 bool HasOptionalParen
= Tok
.is(tok::l_paren
);
3651 if (HasOptionalParen
)
3654 if (Tok
.is(tok::code_completion
)) {
3656 Actions
.CodeCompleteObjCSelector(getCurScope(), KeyIdents
);
3660 IdentifierInfo
*SelIdent
= ParseObjCSelectorPiece(sLoc
);
3661 if (!SelIdent
&& // missing selector name.
3662 Tok
.isNot(tok::colon
) && Tok
.isNot(tok::coloncolon
))
3663 return ExprError(Diag(Tok
, diag::err_expected
) << tok::identifier
);
3665 KeyIdents
.push_back(SelIdent
);
3667 unsigned nColons
= 0;
3668 if (Tok
.isNot(tok::r_paren
)) {
3670 if (TryConsumeToken(tok::coloncolon
)) { // Handle :: in C++.
3672 KeyIdents
.push_back(nullptr);
3673 } else if (ExpectAndConsume(tok::colon
)) // Otherwise expect ':'.
3677 if (Tok
.is(tok::r_paren
))
3680 if (Tok
.is(tok::code_completion
)) {
3682 Actions
.CodeCompleteObjCSelector(getCurScope(), KeyIdents
);
3686 // Check for another keyword selector.
3688 SelIdent
= ParseObjCSelectorPiece(Loc
);
3689 KeyIdents
.push_back(SelIdent
);
3690 if (!SelIdent
&& Tok
.isNot(tok::colon
) && Tok
.isNot(tok::coloncolon
))
3694 if (HasOptionalParen
&& Tok
.is(tok::r_paren
))
3695 ConsumeParen(); // ')'
3697 Selector Sel
= PP
.getSelectorTable().getSelector(nColons
, &KeyIdents
[0]);
3698 return Actions
.ParseObjCSelectorExpression(Sel
, AtLoc
, SelectorLoc
,
3699 T
.getOpenLocation(),
3700 T
.getCloseLocation(),
3704 void Parser::ParseLexedObjCMethodDefs(LexedMethod
&LM
, bool parseMethod
) {
3705 // MCDecl might be null due to error in method or c-function prototype, etc.
3706 Decl
*MCDecl
= LM
.D
;
3707 bool skip
= MCDecl
&&
3708 ((parseMethod
&& !Actions
.isObjCMethodDecl(MCDecl
)) ||
3709 (!parseMethod
&& Actions
.isObjCMethodDecl(MCDecl
)));
3713 // Save the current token position.
3714 SourceLocation OrigLoc
= Tok
.getLocation();
3716 assert(!LM
.Toks
.empty() && "ParseLexedObjCMethodDef - Empty body!");
3717 // Store an artificial EOF token to ensure that we don't run off the end of
3718 // the method's body when we come to parse it.
3721 Eof
.setKind(tok::eof
);
3722 Eof
.setEofData(MCDecl
);
3723 Eof
.setLocation(OrigLoc
);
3724 LM
.Toks
.push_back(Eof
);
3725 // Append the current token at the end of the new token stream so that it
3726 // doesn't get lost.
3727 LM
.Toks
.push_back(Tok
);
3728 PP
.EnterTokenStream(LM
.Toks
, true, /*IsReinject*/true);
3730 // Consume the previously pushed token.
3731 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
3733 assert(Tok
.isOneOf(tok::l_brace
, tok::kw_try
, tok::colon
) &&
3734 "Inline objective-c method not starting with '{' or 'try' or ':'");
3735 // Enter a scope for the method or c-function body.
3736 ParseScope
BodyScope(this, (parseMethod
? Scope::ObjCMethodScope
: 0) |
3737 Scope::FnScope
| Scope::DeclScope
|
3738 Scope::CompoundStmtScope
);
3740 // Tell the actions module that we have entered a method or c-function definition
3741 // with the specified Declarator for the method/function.
3743 Actions
.ActOnStartOfObjCMethodDef(getCurScope(), MCDecl
);
3745 Actions
.ActOnStartOfFunctionDef(getCurScope(), MCDecl
);
3746 if (Tok
.is(tok::kw_try
))
3747 ParseFunctionTryBlock(MCDecl
, BodyScope
);
3749 if (Tok
.is(tok::colon
))
3750 ParseConstructorInitializer(MCDecl
);
3752 Actions
.ActOnDefaultCtorInitializers(MCDecl
);
3753 ParseFunctionStatementBody(MCDecl
, BodyScope
);
3756 if (Tok
.getLocation() != OrigLoc
) {
3757 // Due to parsing error, we either went over the cached tokens or
3758 // there are still cached tokens left. If it's the latter case skip the
3760 // Since this is an uncommon situation that should be avoided, use the
3761 // expensive isBeforeInTranslationUnit call.
3762 if (PP
.getSourceManager().isBeforeInTranslationUnit(Tok
.getLocation(),
3764 while (Tok
.getLocation() != OrigLoc
&& Tok
.isNot(tok::eof
))
3767 // Clean up the remaining EOF token, only if it's inserted by us. Otherwise
3768 // this might be code-completion token, which must be propagated to callers.
3769 if (Tok
.is(tok::eof
) && Tok
.getEofData() == MCDecl
)