1 //===--- ParseDecl.cpp - Declaration Parsing --------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Declaration portions of the Parser interfaces.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/DeclTemplate.h"
15 #include "clang/AST/PrettyDeclStackTrace.h"
16 #include "clang/Basic/AddressSpaces.h"
17 #include "clang/Basic/AttributeCommonInfo.h"
18 #include "clang/Basic/Attributes.h"
19 #include "clang/Basic/CharInfo.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "clang/Basic/TokenKinds.h"
22 #include "clang/Parse/ParseDiagnostic.h"
23 #include "clang/Parse/Parser.h"
24 #include "clang/Parse/RAIIObjectsForParser.h"
25 #include "clang/Sema/EnterExpressionEvaluationContext.h"
26 #include "clang/Sema/Lookup.h"
27 #include "clang/Sema/ParsedTemplate.h"
28 #include "clang/Sema/Scope.h"
29 #include "clang/Sema/SemaDiagnostic.h"
30 #include "llvm/ADT/SmallSet.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/ADT/StringSwitch.h"
33 #include <optional>
34
35 using namespace clang;
36
37 //===----------------------------------------------------------------------===//
38 // C99 6.7: Declarations.
39 //===----------------------------------------------------------------------===//
40
41 /// ParseTypeName
42 /// type-name: [C99 6.7.6]
43 /// specifier-qualifier-list abstract-declarator[opt]
44 ///
45 /// Called type-id in C++.
ParseTypeName(SourceRange * Range,DeclaratorContext Context,AccessSpecifier AS,Decl ** OwnedType,ParsedAttributes * Attrs)46 TypeResult Parser::ParseTypeName(SourceRange *Range, DeclaratorContext Context,
47 AccessSpecifier AS, Decl **OwnedType,
48 ParsedAttributes *Attrs) {
49 DeclSpecContext DSC = getDeclSpecContextFromDeclaratorContext(Context);
50 if (DSC == DeclSpecContext::DSC_normal)
51 DSC = DeclSpecContext::DSC_type_specifier;
52
53 // Parse the common declaration-specifiers piece.
54 DeclSpec DS(AttrFactory);
55 if (Attrs)
56 DS.addAttributes(*Attrs);
57 ParseSpecifierQualifierList(DS, AS, DSC);
58 if (OwnedType)
59 *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : nullptr;
60
61 // Move declspec attributes to ParsedAttributes
62 if (Attrs) {
63 llvm::SmallVector<ParsedAttr *, 1> ToBeMoved;
64 for (ParsedAttr &AL : DS.getAttributes()) {
65 if (AL.isDeclspecAttribute())
66 ToBeMoved.push_back(&AL);
67 }
68
69 for (ParsedAttr *AL : ToBeMoved)
70 Attrs->takeOneFrom(DS.getAttributes(), AL);
71 }
72
73 // Parse the abstract-declarator, if present.
74 Declarator DeclaratorInfo(DS, ParsedAttributesView::none(), Context);
75 ParseDeclarator(DeclaratorInfo);
76 if (Range)
77 *Range = DeclaratorInfo.getSourceRange();
78
79 if (DeclaratorInfo.isInvalidType())
80 return true;
81
82 return Actions.ActOnTypeName(DeclaratorInfo);
83 }
84
85 /// Normalizes an attribute name by dropping prefixed and suffixed __.
normalizeAttrName(StringRef Name)86 static StringRef normalizeAttrName(StringRef Name) {
87 if (Name.size() >= 4 && Name.starts_with("__") && Name.ends_with("__"))
88 return Name.drop_front(2).drop_back(2);
89 return Name;
90 }
91
92 /// isAttributeLateParsed - Return true if the attribute has arguments that
93 /// require late parsing.
isAttributeLateParsed(const IdentifierInfo & II)94 static bool isAttributeLateParsed(const IdentifierInfo &II) {
95 #define CLANG_ATTR_LATE_PARSED_LIST
96 return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
97 #include "clang/Parse/AttrParserStringSwitches.inc"
98 .Default(false);
99 #undef CLANG_ATTR_LATE_PARSED_LIST
100 }
101
102 /// Check if the a start and end source location expand to the same macro.
FindLocsWithCommonFileID(Preprocessor & PP,SourceLocation StartLoc,SourceLocation EndLoc)103 static bool FindLocsWithCommonFileID(Preprocessor &PP, SourceLocation StartLoc,
104 SourceLocation EndLoc) {
105 if (!StartLoc.isMacroID() || !EndLoc.isMacroID())
106 return false;
107
108 SourceManager &SM = PP.getSourceManager();
109 if (SM.getFileID(StartLoc) != SM.getFileID(EndLoc))
110 return false;
111
112 bool AttrStartIsInMacro =
113 Lexer::isAtStartOfMacroExpansion(StartLoc, SM, PP.getLangOpts());
114 bool AttrEndIsInMacro =
115 Lexer::isAtEndOfMacroExpansion(EndLoc, SM, PP.getLangOpts());
116 return AttrStartIsInMacro && AttrEndIsInMacro;
117 }
118
ParseAttributes(unsigned WhichAttrKinds,ParsedAttributes & Attrs,LateParsedAttrList * LateAttrs)119 void Parser::ParseAttributes(unsigned WhichAttrKinds, ParsedAttributes &Attrs,
120 LateParsedAttrList *LateAttrs) {
121 bool MoreToParse;
122 do {
123 // Assume there's nothing left to parse, but if any attributes are in fact
124 // parsed, loop to ensure all specified attribute combinations are parsed.
125 MoreToParse = false;
126 if (WhichAttrKinds & PAKM_CXX11)
127 MoreToParse |= MaybeParseCXX11Attributes(Attrs);
128 if (WhichAttrKinds & PAKM_GNU)
129 MoreToParse |= MaybeParseGNUAttributes(Attrs, LateAttrs);
130 if (WhichAttrKinds & PAKM_Declspec)
131 MoreToParse |= MaybeParseMicrosoftDeclSpecs(Attrs);
132 } while (MoreToParse);
133 }
134
135 /// ParseGNUAttributes - Parse a non-empty attributes list.
136 ///
137 /// [GNU] attributes:
138 /// attribute
139 /// attributes attribute
140 ///
141 /// [GNU] attribute:
142 /// '__attribute__' '(' '(' attribute-list ')' ')'
143 ///
144 /// [GNU] attribute-list:
145 /// attrib
146 /// attribute_list ',' attrib
147 ///
148 /// [GNU] attrib:
149 /// empty
150 /// attrib-name
151 /// attrib-name '(' identifier ')'
152 /// attrib-name '(' identifier ',' nonempty-expr-list ')'
153 /// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
154 ///
155 /// [GNU] attrib-name:
156 /// identifier
157 /// typespec
158 /// typequal
159 /// storageclass
160 ///
161 /// Whether an attribute takes an 'identifier' is determined by the
162 /// attrib-name. GCC's behavior here is not worth imitating:
163 ///
164 /// * In C mode, if the attribute argument list starts with an identifier
165 /// followed by a ',' or an ')', and the identifier doesn't resolve to
166 /// a type, it is parsed as an identifier. If the attribute actually
167 /// wanted an expression, it's out of luck (but it turns out that no
168 /// attributes work that way, because C constant expressions are very
169 /// limited).
170 /// * In C++ mode, if the attribute argument list starts with an identifier,
171 /// and the attribute *wants* an identifier, it is parsed as an identifier.
172 /// At block scope, any additional tokens between the identifier and the
173 /// ',' or ')' are ignored, otherwise they produce a parse error.
174 ///
175 /// We follow the C++ model, but don't allow junk after the identifier.
ParseGNUAttributes(ParsedAttributes & Attrs,LateParsedAttrList * LateAttrs,Declarator * D)176 void Parser::ParseGNUAttributes(ParsedAttributes &Attrs,
177 LateParsedAttrList *LateAttrs, Declarator *D) {
178 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
179
180 SourceLocation StartLoc = Tok.getLocation();
181 SourceLocation EndLoc = StartLoc;
182
183 while (Tok.is(tok::kw___attribute)) {
184 SourceLocation AttrTokLoc = ConsumeToken();
185 unsigned OldNumAttrs = Attrs.size();
186 unsigned OldNumLateAttrs = LateAttrs ? LateAttrs->size() : 0;
187
188 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
189 "attribute")) {
190 SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
191 return;
192 }
193 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
194 SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
195 return;
196 }
197 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
198 do {
199 // Eat preceeding commas to allow __attribute__((,,,foo))
200 while (TryConsumeToken(tok::comma))
201 ;
202
203 // Expect an identifier or declaration specifier (const, int, etc.)
204 if (Tok.isAnnotation())
205 break;
206 if (Tok.is(tok::code_completion)) {
207 cutOffParsing();
208 Actions.CodeCompleteAttribute(AttributeCommonInfo::Syntax::AS_GNU);
209 break;
210 }
211 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
212 if (!AttrName)
213 break;
214
215 SourceLocation AttrNameLoc = ConsumeToken();
216
217 if (Tok.isNot(tok::l_paren)) {
218 Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
219 ParsedAttr::Form::GNU());
220 continue;
221 }
222
223 // Handle "parameterized" attributes
224 if (!LateAttrs || !isAttributeLateParsed(*AttrName)) {
225 ParseGNUAttributeArgs(AttrName, AttrNameLoc, Attrs, &EndLoc, nullptr,
226 SourceLocation(), ParsedAttr::Form::GNU(), D);
227 continue;
228 }
229
230 // Handle attributes with arguments that require late parsing.
231 LateParsedAttribute *LA =
232 new LateParsedAttribute(this, *AttrName, AttrNameLoc);
233 LateAttrs->push_back(LA);
234
235 // Attributes in a class are parsed at the end of the class, along
236 // with other late-parsed declarations.
237 if (!ClassStack.empty() && !LateAttrs->parseSoon())
238 getCurrentClass().LateParsedDeclarations.push_back(LA);
239
240 // Be sure ConsumeAndStoreUntil doesn't see the start l_paren, since it
241 // recursively consumes balanced parens.
242 LA->Toks.push_back(Tok);
243 ConsumeParen();
244 // Consume everything up to and including the matching right parens.
245 ConsumeAndStoreUntil(tok::r_paren, LA->Toks, /*StopAtSemi=*/true);
246
247 Token Eof;
248 Eof.startToken();
249 Eof.setLocation(Tok.getLocation());
250 LA->Toks.push_back(Eof);
251 } while (Tok.is(tok::comma));
252
253 if (ExpectAndConsume(tok::r_paren))
254 SkipUntil(tok::r_paren, StopAtSemi);
255 SourceLocation Loc = Tok.getLocation();
256 if (ExpectAndConsume(tok::r_paren))
257 SkipUntil(tok::r_paren, StopAtSemi);
258 EndLoc = Loc;
259
260 // If this was declared in a macro, attach the macro IdentifierInfo to the
261 // parsed attribute.
262 auto &SM = PP.getSourceManager();
263 if (!SM.isWrittenInBuiltinFile(SM.getSpellingLoc(AttrTokLoc)) &&
264 FindLocsWithCommonFileID(PP, AttrTokLoc, Loc)) {
265 CharSourceRange ExpansionRange = SM.getExpansionRange(AttrTokLoc);
266 StringRef FoundName =
267 Lexer::getSourceText(ExpansionRange, SM, PP.getLangOpts());
268 IdentifierInfo *MacroII = PP.getIdentifierInfo(FoundName);
269
270 for (unsigned i = OldNumAttrs; i < Attrs.size(); ++i)
271 Attrs[i].setMacroIdentifier(MacroII, ExpansionRange.getBegin());
272
273 if (LateAttrs) {
274 for (unsigned i = OldNumLateAttrs; i < LateAttrs->size(); ++i)
275 (*LateAttrs)[i]->MacroII = MacroII;
276 }
277 }
278 }
279
280 Attrs.Range = SourceRange(StartLoc, EndLoc);
281 }
282
283 /// Determine whether the given attribute has an identifier argument.
attributeHasIdentifierArg(const IdentifierInfo & II)284 static bool attributeHasIdentifierArg(const IdentifierInfo &II) {
285 #define CLANG_ATTR_IDENTIFIER_ARG_LIST
286 return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
287 #include "clang/Parse/AttrParserStringSwitches.inc"
288 .Default(false);
289 #undef CLANG_ATTR_IDENTIFIER_ARG_LIST
290 }
291
292 /// Determine whether the given attribute has an identifier argument.
293 static ParsedAttributeArgumentsProperties
attributeStringLiteralListArg(const IdentifierInfo & II)294 attributeStringLiteralListArg(const IdentifierInfo &II) {
295 #define CLANG_ATTR_STRING_LITERAL_ARG_LIST
296 return llvm::StringSwitch<uint32_t>(normalizeAttrName(II.getName()))
297 #include "clang/Parse/AttrParserStringSwitches.inc"
298 .Default(0);
299 #undef CLANG_ATTR_STRING_LITERAL_ARG_LIST
300 }
301
302 /// Determine whether the given attribute has a variadic identifier argument.
attributeHasVariadicIdentifierArg(const IdentifierInfo & II)303 static bool attributeHasVariadicIdentifierArg(const IdentifierInfo &II) {
304 #define CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST
305 return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
306 #include "clang/Parse/AttrParserStringSwitches.inc"
307 .Default(false);
308 #undef CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST
309 }
310
311 /// Determine whether the given attribute treats kw_this as an identifier.
attributeTreatsKeywordThisAsIdentifier(const IdentifierInfo & II)312 static bool attributeTreatsKeywordThisAsIdentifier(const IdentifierInfo &II) {
313 #define CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST
314 return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
315 #include "clang/Parse/AttrParserStringSwitches.inc"
316 .Default(false);
317 #undef CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST
318 }
319
320 /// Determine if an attribute accepts parameter packs.
attributeAcceptsExprPack(const IdentifierInfo & II)321 static bool attributeAcceptsExprPack(const IdentifierInfo &II) {
322 #define CLANG_ATTR_ACCEPTS_EXPR_PACK
323 return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
324 #include "clang/Parse/AttrParserStringSwitches.inc"
325 .Default(false);
326 #undef CLANG_ATTR_ACCEPTS_EXPR_PACK
327 }
328
329 /// Determine whether the given attribute parses a type argument.
attributeIsTypeArgAttr(const IdentifierInfo & II)330 static bool attributeIsTypeArgAttr(const IdentifierInfo &II) {
331 #define CLANG_ATTR_TYPE_ARG_LIST
332 return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
333 #include "clang/Parse/AttrParserStringSwitches.inc"
334 .Default(false);
335 #undef CLANG_ATTR_TYPE_ARG_LIST
336 }
337
338 /// Determine whether the given attribute requires parsing its arguments
339 /// in an unevaluated context or not.
attributeParsedArgsUnevaluated(const IdentifierInfo & II)340 static bool attributeParsedArgsUnevaluated(const IdentifierInfo &II) {
341 #define CLANG_ATTR_ARG_CONTEXT_LIST
342 return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
343 #include "clang/Parse/AttrParserStringSwitches.inc"
344 .Default(false);
345 #undef CLANG_ATTR_ARG_CONTEXT_LIST
346 }
347
ParseIdentifierLoc()348 IdentifierLoc *Parser::ParseIdentifierLoc() {
349 assert(Tok.is(tok::identifier) && "expected an identifier");
350 IdentifierLoc *IL = IdentifierLoc::create(Actions.Context,
351 Tok.getLocation(),
352 Tok.getIdentifierInfo());
353 ConsumeToken();
354 return IL;
355 }
356
ParseAttributeWithTypeArg(IdentifierInfo & AttrName,SourceLocation AttrNameLoc,ParsedAttributes & Attrs,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form)357 void Parser::ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
358 SourceLocation AttrNameLoc,
359 ParsedAttributes &Attrs,
360 IdentifierInfo *ScopeName,
361 SourceLocation ScopeLoc,
362 ParsedAttr::Form Form) {
363 BalancedDelimiterTracker Parens(*this, tok::l_paren);
364 Parens.consumeOpen();
365
366 TypeResult T;
367 if (Tok.isNot(tok::r_paren))
368 T = ParseTypeName();
369
370 if (Parens.consumeClose())
371 return;
372
373 if (T.isInvalid())
374 return;
375
376 if (T.isUsable())
377 Attrs.addNewTypeAttr(&AttrName,
378 SourceRange(AttrNameLoc, Parens.getCloseLocation()),
379 ScopeName, ScopeLoc, T.get(), Form);
380 else
381 Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, Parens.getCloseLocation()),
382 ScopeName, ScopeLoc, nullptr, 0, Form);
383 }
384
385 ExprResult
ParseUnevaluatedStringInAttribute(const IdentifierInfo & AttrName)386 Parser::ParseUnevaluatedStringInAttribute(const IdentifierInfo &AttrName) {
387 if (Tok.is(tok::l_paren)) {
388 BalancedDelimiterTracker Paren(*this, tok::l_paren);
389 Paren.consumeOpen();
390 ExprResult Res = ParseUnevaluatedStringInAttribute(AttrName);
391 Paren.consumeClose();
392 return Res;
393 }
394 if (!isTokenStringLiteral()) {
395 Diag(Tok.getLocation(), diag::err_expected_string_literal)
396 << /*in attribute...*/ 4 << AttrName.getName();
397 return ExprError();
398 }
399 return ParseUnevaluatedStringLiteralExpression();
400 }
401
ParseAttributeArgumentList(const IdentifierInfo & AttrName,SmallVectorImpl<Expr * > & Exprs,ParsedAttributeArgumentsProperties ArgsProperties)402 bool Parser::ParseAttributeArgumentList(
403 const IdentifierInfo &AttrName, SmallVectorImpl<Expr *> &Exprs,
404 ParsedAttributeArgumentsProperties ArgsProperties) {
405 bool SawError = false;
406 unsigned Arg = 0;
407 while (true) {
408 ExprResult Expr;
409 if (ArgsProperties.isStringLiteralArg(Arg)) {
410 Expr = ParseUnevaluatedStringInAttribute(AttrName);
411 } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
412 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
413 Expr = ParseBraceInitializer();
414 } else {
415 Expr = ParseAssignmentExpression();
416 }
417 Expr = Actions.CorrectDelayedTyposInExpr(Expr);
418
419 if (Tok.is(tok::ellipsis))
420 Expr = Actions.ActOnPackExpansion(Expr.get(), ConsumeToken());
421 else if (Tok.is(tok::code_completion)) {
422 // There's nothing to suggest in here as we parsed a full expression.
423 // Instead fail and propagate the error since caller might have something
424 // the suggest, e.g. signature help in function call. Note that this is
425 // performed before pushing the \p Expr, so that signature help can report
426 // current argument correctly.
427 SawError = true;
428 cutOffParsing();
429 break;
430 }
431
432 if (Expr.isInvalid()) {
433 SawError = true;
434 break;
435 }
436
437 Exprs.push_back(Expr.get());
438
439 if (Tok.isNot(tok::comma))
440 break;
441 // Move to the next argument, remember where the comma was.
442 Token Comma = Tok;
443 ConsumeToken();
444 checkPotentialAngleBracketDelimiter(Comma);
445 Arg++;
446 }
447
448 if (SawError) {
449 // Ensure typos get diagnosed when errors were encountered while parsing the
450 // expression list.
451 for (auto &E : Exprs) {
452 ExprResult Expr = Actions.CorrectDelayedTyposInExpr(E);
453 if (Expr.isUsable())
454 E = Expr.get();
455 }
456 }
457 return SawError;
458 }
459
ParseAttributeArgsCommon(IdentifierInfo * AttrName,SourceLocation AttrNameLoc,ParsedAttributes & Attrs,SourceLocation * EndLoc,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form)460 unsigned Parser::ParseAttributeArgsCommon(
461 IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
462 ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
463 SourceLocation ScopeLoc, ParsedAttr::Form Form) {
464 // Ignore the left paren location for now.
465 ConsumeParen();
466
467 bool ChangeKWThisToIdent = attributeTreatsKeywordThisAsIdentifier(*AttrName);
468 bool AttributeIsTypeArgAttr = attributeIsTypeArgAttr(*AttrName);
469 bool AttributeHasVariadicIdentifierArg =
470 attributeHasVariadicIdentifierArg(*AttrName);
471
472 // Interpret "kw_this" as an identifier if the attributed requests it.
473 if (ChangeKWThisToIdent && Tok.is(tok::kw_this))
474 Tok.setKind(tok::identifier);
475
476 ArgsVector ArgExprs;
477 if (Tok.is(tok::identifier)) {
478 // If this attribute wants an 'identifier' argument, make it so.
479 bool IsIdentifierArg = AttributeHasVariadicIdentifierArg ||
480 attributeHasIdentifierArg(*AttrName);
481 ParsedAttr::Kind AttrKind =
482 ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
483
484 // If we don't know how to parse this attribute, but this is the only
485 // token in this argument, assume it's meant to be an identifier.
486 if (AttrKind == ParsedAttr::UnknownAttribute ||
487 AttrKind == ParsedAttr::IgnoredAttribute) {
488 const Token &Next = NextToken();
489 IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma);
490 }
491
492 if (IsIdentifierArg)
493 ArgExprs.push_back(ParseIdentifierLoc());
494 }
495
496 ParsedType TheParsedType;
497 if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) {
498 // Eat the comma.
499 if (!ArgExprs.empty())
500 ConsumeToken();
501
502 if (AttributeIsTypeArgAttr) {
503 // FIXME: Multiple type arguments are not implemented.
504 TypeResult T = ParseTypeName();
505 if (T.isInvalid()) {
506 SkipUntil(tok::r_paren, StopAtSemi);
507 return 0;
508 }
509 if (T.isUsable())
510 TheParsedType = T.get();
511 } else if (AttributeHasVariadicIdentifierArg) {
512 // Parse variadic identifier arg. This can either consume identifiers or
513 // expressions. Variadic identifier args do not support parameter packs
514 // because those are typically used for attributes with enumeration
515 // arguments, and those enumerations are not something the user could
516 // express via a pack.
517 do {
518 // Interpret "kw_this" as an identifier if the attributed requests it.
519 if (ChangeKWThisToIdent && Tok.is(tok::kw_this))
520 Tok.setKind(tok::identifier);
521
522 ExprResult ArgExpr;
523 if (Tok.is(tok::identifier)) {
524 ArgExprs.push_back(ParseIdentifierLoc());
525 } else {
526 bool Uneval = attributeParsedArgsUnevaluated(*AttrName);
527 EnterExpressionEvaluationContext Unevaluated(
528 Actions,
529 Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
530 : Sema::ExpressionEvaluationContext::ConstantEvaluated);
531
532 ExprResult ArgExpr(
533 Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression()));
534
535 if (ArgExpr.isInvalid()) {
536 SkipUntil(tok::r_paren, StopAtSemi);
537 return 0;
538 }
539 ArgExprs.push_back(ArgExpr.get());
540 }
541 // Eat the comma, move to the next argument
542 } while (TryConsumeToken(tok::comma));
543 } else {
544 // General case. Parse all available expressions.
545 bool Uneval = attributeParsedArgsUnevaluated(*AttrName);
546 EnterExpressionEvaluationContext Unevaluated(
547 Actions, Uneval
548 ? Sema::ExpressionEvaluationContext::Unevaluated
549 : Sema::ExpressionEvaluationContext::ConstantEvaluated);
550
551 ExprVector ParsedExprs;
552 ParsedAttributeArgumentsProperties ArgProperties =
553 attributeStringLiteralListArg(*AttrName);
554 if (ParseAttributeArgumentList(*AttrName, ParsedExprs, ArgProperties)) {
555 SkipUntil(tok::r_paren, StopAtSemi);
556 return 0;
557 }
558
559 // Pack expansion must currently be explicitly supported by an attribute.
560 for (size_t I = 0; I < ParsedExprs.size(); ++I) {
561 if (!isa<PackExpansionExpr>(ParsedExprs[I]))
562 continue;
563
564 if (!attributeAcceptsExprPack(*AttrName)) {
565 Diag(Tok.getLocation(),
566 diag::err_attribute_argument_parm_pack_not_supported)
567 << AttrName;
568 SkipUntil(tok::r_paren, StopAtSemi);
569 return 0;
570 }
571 }
572
573 ArgExprs.insert(ArgExprs.end(), ParsedExprs.begin(), ParsedExprs.end());
574 }
575 }
576
577 SourceLocation RParen = Tok.getLocation();
578 if (!ExpectAndConsume(tok::r_paren)) {
579 SourceLocation AttrLoc = ScopeLoc.isValid() ? ScopeLoc : AttrNameLoc;
580
581 if (AttributeIsTypeArgAttr && !TheParsedType.get().isNull()) {
582 Attrs.addNewTypeAttr(AttrName, SourceRange(AttrNameLoc, RParen),
583 ScopeName, ScopeLoc, TheParsedType, Form);
584 } else {
585 Attrs.addNew(AttrName, SourceRange(AttrLoc, RParen), ScopeName, ScopeLoc,
586 ArgExprs.data(), ArgExprs.size(), Form);
587 }
588 }
589
590 if (EndLoc)
591 *EndLoc = RParen;
592
593 return static_cast<unsigned>(ArgExprs.size() + !TheParsedType.get().isNull());
594 }
595
596 /// Parse the arguments to a parameterized GNU attribute or
597 /// a C++11 attribute in "gnu" namespace.
ParseGNUAttributeArgs(IdentifierInfo * AttrName,SourceLocation AttrNameLoc,ParsedAttributes & Attrs,SourceLocation * EndLoc,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form,Declarator * D)598 void Parser::ParseGNUAttributeArgs(
599 IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
600 ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
601 SourceLocation ScopeLoc, ParsedAttr::Form Form, Declarator *D) {
602
603 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
604
605 ParsedAttr::Kind AttrKind =
606 ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
607
608 if (AttrKind == ParsedAttr::AT_Availability) {
609 ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
610 ScopeLoc, Form);
611 return;
612 } else if (AttrKind == ParsedAttr::AT_ExternalSourceSymbol) {
613 ParseExternalSourceSymbolAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
614 ScopeName, ScopeLoc, Form);
615 return;
616 } else if (AttrKind == ParsedAttr::AT_ObjCBridgeRelated) {
617 ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
618 ScopeName, ScopeLoc, Form);
619 return;
620 } else if (AttrKind == ParsedAttr::AT_SwiftNewType) {
621 ParseSwiftNewTypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
622 ScopeLoc, Form);
623 return;
624 } else if (AttrKind == ParsedAttr::AT_TypeTagForDatatype) {
625 ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
626 ScopeName, ScopeLoc, Form);
627 return;
628 } else if (attributeIsTypeArgAttr(*AttrName)) {
629 ParseAttributeWithTypeArg(*AttrName, AttrNameLoc, Attrs, ScopeName,
630 ScopeLoc, Form);
631 return;
632 }
633
634 // These may refer to the function arguments, but need to be parsed early to
635 // participate in determining whether it's a redeclaration.
636 std::optional<ParseScope> PrototypeScope;
637 if (normalizeAttrName(AttrName->getName()) == "enable_if" &&
638 D && D->isFunctionDeclarator()) {
639 DeclaratorChunk::FunctionTypeInfo FTI = D->getFunctionTypeInfo();
640 PrototypeScope.emplace(this, Scope::FunctionPrototypeScope |
641 Scope::FunctionDeclarationScope |
642 Scope::DeclScope);
643 for (unsigned i = 0; i != FTI.NumParams; ++i) {
644 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
645 Actions.ActOnReenterCXXMethodParameter(getCurScope(), Param);
646 }
647 }
648
649 ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
650 ScopeLoc, Form);
651 }
652
ParseClangAttributeArgs(IdentifierInfo * AttrName,SourceLocation AttrNameLoc,ParsedAttributes & Attrs,SourceLocation * EndLoc,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form)653 unsigned Parser::ParseClangAttributeArgs(
654 IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
655 ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
656 SourceLocation ScopeLoc, ParsedAttr::Form Form) {
657 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
658
659 ParsedAttr::Kind AttrKind =
660 ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
661
662 switch (AttrKind) {
663 default:
664 return ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc,
665 ScopeName, ScopeLoc, Form);
666 case ParsedAttr::AT_ExternalSourceSymbol:
667 ParseExternalSourceSymbolAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
668 ScopeName, ScopeLoc, Form);
669 break;
670 case ParsedAttr::AT_Availability:
671 ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
672 ScopeLoc, Form);
673 break;
674 case ParsedAttr::AT_ObjCBridgeRelated:
675 ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
676 ScopeName, ScopeLoc, Form);
677 break;
678 case ParsedAttr::AT_SwiftNewType:
679 ParseSwiftNewTypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
680 ScopeLoc, Form);
681 break;
682 case ParsedAttr::AT_TypeTagForDatatype:
683 ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
684 ScopeName, ScopeLoc, Form);
685 break;
686 }
687 return !Attrs.empty() ? Attrs.begin()->getNumArgs() : 0;
688 }
689
ParseMicrosoftDeclSpecArgs(IdentifierInfo * AttrName,SourceLocation AttrNameLoc,ParsedAttributes & Attrs)690 bool Parser::ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,
691 SourceLocation AttrNameLoc,
692 ParsedAttributes &Attrs) {
693 unsigned ExistingAttrs = Attrs.size();
694
695 // If the attribute isn't known, we will not attempt to parse any
696 // arguments.
697 if (!hasAttribute(AttributeCommonInfo::Syntax::AS_Declspec, nullptr, AttrName,
698 getTargetInfo(), getLangOpts())) {
699 // Eat the left paren, then skip to the ending right paren.
700 ConsumeParen();
701 SkipUntil(tok::r_paren);
702 return false;
703 }
704
705 SourceLocation OpenParenLoc = Tok.getLocation();
706
707 if (AttrName->getName() == "property") {
708 // The property declspec is more complex in that it can take one or two
709 // assignment expressions as a parameter, but the lhs of the assignment
710 // must be named get or put.
711
712 BalancedDelimiterTracker T(*this, tok::l_paren);
713 T.expectAndConsume(diag::err_expected_lparen_after,
714 AttrName->getNameStart(), tok::r_paren);
715
716 enum AccessorKind {
717 AK_Invalid = -1,
718 AK_Put = 0,
719 AK_Get = 1 // indices into AccessorNames
720 };
721 IdentifierInfo *AccessorNames[] = {nullptr, nullptr};
722 bool HasInvalidAccessor = false;
723
724 // Parse the accessor specifications.
725 while (true) {
726 // Stop if this doesn't look like an accessor spec.
727 if (!Tok.is(tok::identifier)) {
728 // If the user wrote a completely empty list, use a special diagnostic.
729 if (Tok.is(tok::r_paren) && !HasInvalidAccessor &&
730 AccessorNames[AK_Put] == nullptr &&
731 AccessorNames[AK_Get] == nullptr) {
732 Diag(AttrNameLoc, diag::err_ms_property_no_getter_or_putter);
733 break;
734 }
735
736 Diag(Tok.getLocation(), diag::err_ms_property_unknown_accessor);
737 break;
738 }
739
740 AccessorKind Kind;
741 SourceLocation KindLoc = Tok.getLocation();
742 StringRef KindStr = Tok.getIdentifierInfo()->getName();
743 if (KindStr == "get") {
744 Kind = AK_Get;
745 } else if (KindStr == "put") {
746 Kind = AK_Put;
747
748 // Recover from the common mistake of using 'set' instead of 'put'.
749 } else if (KindStr == "set") {
750 Diag(KindLoc, diag::err_ms_property_has_set_accessor)
751 << FixItHint::CreateReplacement(KindLoc, "put");
752 Kind = AK_Put;
753
754 // Handle the mistake of forgetting the accessor kind by skipping
755 // this accessor.
756 } else if (NextToken().is(tok::comma) || NextToken().is(tok::r_paren)) {
757 Diag(KindLoc, diag::err_ms_property_missing_accessor_kind);
758 ConsumeToken();
759 HasInvalidAccessor = true;
760 goto next_property_accessor;
761
762 // Otherwise, complain about the unknown accessor kind.
763 } else {
764 Diag(KindLoc, diag::err_ms_property_unknown_accessor);
765 HasInvalidAccessor = true;
766 Kind = AK_Invalid;
767
768 // Try to keep parsing unless it doesn't look like an accessor spec.
769 if (!NextToken().is(tok::equal))
770 break;
771 }
772
773 // Consume the identifier.
774 ConsumeToken();
775
776 // Consume the '='.
777 if (!TryConsumeToken(tok::equal)) {
778 Diag(Tok.getLocation(), diag::err_ms_property_expected_equal)
779 << KindStr;
780 break;
781 }
782
783 // Expect the method name.
784 if (!Tok.is(tok::identifier)) {
785 Diag(Tok.getLocation(), diag::err_ms_property_expected_accessor_name);
786 break;
787 }
788
789 if (Kind == AK_Invalid) {
790 // Just drop invalid accessors.
791 } else if (AccessorNames[Kind] != nullptr) {
792 // Complain about the repeated accessor, ignore it, and keep parsing.
793 Diag(KindLoc, diag::err_ms_property_duplicate_accessor) << KindStr;
794 } else {
795 AccessorNames[Kind] = Tok.getIdentifierInfo();
796 }
797 ConsumeToken();
798
799 next_property_accessor:
800 // Keep processing accessors until we run out.
801 if (TryConsumeToken(tok::comma))
802 continue;
803
804 // If we run into the ')', stop without consuming it.
805 if (Tok.is(tok::r_paren))
806 break;
807
808 Diag(Tok.getLocation(), diag::err_ms_property_expected_comma_or_rparen);
809 break;
810 }
811
812 // Only add the property attribute if it was well-formed.
813 if (!HasInvalidAccessor)
814 Attrs.addNewPropertyAttr(AttrName, AttrNameLoc, nullptr, SourceLocation(),
815 AccessorNames[AK_Get], AccessorNames[AK_Put],
816 ParsedAttr::Form::Declspec());
817 T.skipToEnd();
818 return !HasInvalidAccessor;
819 }
820
821 unsigned NumArgs =
822 ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, nullptr, nullptr,
823 SourceLocation(), ParsedAttr::Form::Declspec());
824
825 // If this attribute's args were parsed, and it was expected to have
826 // arguments but none were provided, emit a diagnostic.
827 if (ExistingAttrs < Attrs.size() && Attrs.back().getMaxArgs() && !NumArgs) {
828 Diag(OpenParenLoc, diag::err_attribute_requires_arguments) << AttrName;
829 return false;
830 }
831 return true;
832 }
833
834 /// [MS] decl-specifier:
835 /// __declspec ( extended-decl-modifier-seq )
836 ///
837 /// [MS] extended-decl-modifier-seq:
838 /// extended-decl-modifier[opt]
839 /// extended-decl-modifier extended-decl-modifier-seq
ParseMicrosoftDeclSpecs(ParsedAttributes & Attrs)840 void Parser::ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs) {
841 assert(getLangOpts().DeclSpecKeyword && "__declspec keyword is not enabled");
842 assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
843
844 SourceLocation StartLoc = Tok.getLocation();
845 SourceLocation EndLoc = StartLoc;
846
847 while (Tok.is(tok::kw___declspec)) {
848 ConsumeToken();
849 BalancedDelimiterTracker T(*this, tok::l_paren);
850 if (T.expectAndConsume(diag::err_expected_lparen_after, "__declspec",
851 tok::r_paren))
852 return;
853
854 // An empty declspec is perfectly legal and should not warn. Additionally,
855 // you can specify multiple attributes per declspec.
856 while (Tok.isNot(tok::r_paren)) {
857 // Attribute not present.
858 if (TryConsumeToken(tok::comma))
859 continue;
860
861 if (Tok.is(tok::code_completion)) {
862 cutOffParsing();
863 Actions.CodeCompleteAttribute(AttributeCommonInfo::AS_Declspec);
864 return;
865 }
866
867 // We expect either a well-known identifier or a generic string. Anything
868 // else is a malformed declspec.
869 bool IsString = Tok.getKind() == tok::string_literal;
870 if (!IsString && Tok.getKind() != tok::identifier &&
871 Tok.getKind() != tok::kw_restrict) {
872 Diag(Tok, diag::err_ms_declspec_type);
873 T.skipToEnd();
874 return;
875 }
876
877 IdentifierInfo *AttrName;
878 SourceLocation AttrNameLoc;
879 if (IsString) {
880 SmallString<8> StrBuffer;
881 bool Invalid = false;
882 StringRef Str = PP.getSpelling(Tok, StrBuffer, &Invalid);
883 if (Invalid) {
884 T.skipToEnd();
885 return;
886 }
887 AttrName = PP.getIdentifierInfo(Str);
888 AttrNameLoc = ConsumeStringToken();
889 } else {
890 AttrName = Tok.getIdentifierInfo();
891 AttrNameLoc = ConsumeToken();
892 }
893
894 bool AttrHandled = false;
895
896 // Parse attribute arguments.
897 if (Tok.is(tok::l_paren))
898 AttrHandled = ParseMicrosoftDeclSpecArgs(AttrName, AttrNameLoc, Attrs);
899 else if (AttrName->getName() == "property")
900 // The property attribute must have an argument list.
901 Diag(Tok.getLocation(), diag::err_expected_lparen_after)
902 << AttrName->getName();
903
904 if (!AttrHandled)
905 Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
906 ParsedAttr::Form::Declspec());
907 }
908 T.consumeClose();
909 EndLoc = T.getCloseLocation();
910 }
911
912 Attrs.Range = SourceRange(StartLoc, EndLoc);
913 }
914
ParseMicrosoftTypeAttributes(ParsedAttributes & attrs)915 void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) {
916 // Treat these like attributes
917 while (true) {
918 auto Kind = Tok.getKind();
919 switch (Kind) {
920 case tok::kw___fastcall:
921 case tok::kw___stdcall:
922 case tok::kw___thiscall:
923 case tok::kw___regcall:
924 case tok::kw___cdecl:
925 case tok::kw___vectorcall:
926 case tok::kw___ptr64:
927 case tok::kw___w64:
928 case tok::kw___ptr32:
929 case tok::kw___sptr:
930 case tok::kw___uptr: {
931 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
932 SourceLocation AttrNameLoc = ConsumeToken();
933 attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
934 Kind);
935 break;
936 }
937 default:
938 return;
939 }
940 }
941 }
942
ParseWebAssemblyFuncrefTypeAttribute(ParsedAttributes & attrs)943 void Parser::ParseWebAssemblyFuncrefTypeAttribute(ParsedAttributes &attrs) {
944 assert(Tok.is(tok::kw___funcref));
945 SourceLocation StartLoc = Tok.getLocation();
946 if (!getTargetInfo().getTriple().isWasm()) {
947 ConsumeToken();
948 Diag(StartLoc, diag::err_wasm_funcref_not_wasm);
949 return;
950 }
951
952 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
953 SourceLocation AttrNameLoc = ConsumeToken();
954 attrs.addNew(AttrName, AttrNameLoc, /*ScopeName=*/nullptr,
955 /*ScopeLoc=*/SourceLocation{}, /*Args=*/nullptr, /*numArgs=*/0,
956 tok::kw___funcref);
957 }
958
DiagnoseAndSkipExtendedMicrosoftTypeAttributes()959 void Parser::DiagnoseAndSkipExtendedMicrosoftTypeAttributes() {
960 SourceLocation StartLoc = Tok.getLocation();
961 SourceLocation EndLoc = SkipExtendedMicrosoftTypeAttributes();
962
963 if (EndLoc.isValid()) {
964 SourceRange Range(StartLoc, EndLoc);
965 Diag(StartLoc, diag::warn_microsoft_qualifiers_ignored) << Range;
966 }
967 }
968
SkipExtendedMicrosoftTypeAttributes()969 SourceLocation Parser::SkipExtendedMicrosoftTypeAttributes() {
970 SourceLocation EndLoc;
971
972 while (true) {
973 switch (Tok.getKind()) {
974 case tok::kw_const:
975 case tok::kw_volatile:
976 case tok::kw___fastcall:
977 case tok::kw___stdcall:
978 case tok::kw___thiscall:
979 case tok::kw___cdecl:
980 case tok::kw___vectorcall:
981 case tok::kw___ptr32:
982 case tok::kw___ptr64:
983 case tok::kw___w64:
984 case tok::kw___unaligned:
985 case tok::kw___sptr:
986 case tok::kw___uptr:
987 EndLoc = ConsumeToken();
988 break;
989 default:
990 return EndLoc;
991 }
992 }
993 }
994
ParseBorlandTypeAttributes(ParsedAttributes & attrs)995 void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
996 // Treat these like attributes
997 while (Tok.is(tok::kw___pascal)) {
998 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
999 SourceLocation AttrNameLoc = ConsumeToken();
1000 attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1001 tok::kw___pascal);
1002 }
1003 }
1004
ParseOpenCLKernelAttributes(ParsedAttributes & attrs)1005 void Parser::ParseOpenCLKernelAttributes(ParsedAttributes &attrs) {
1006 // Treat these like attributes
1007 while (Tok.is(tok::kw___kernel)) {
1008 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1009 SourceLocation AttrNameLoc = ConsumeToken();
1010 attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1011 tok::kw___kernel);
1012 }
1013 }
1014
ParseCUDAFunctionAttributes(ParsedAttributes & attrs)1015 void Parser::ParseCUDAFunctionAttributes(ParsedAttributes &attrs) {
1016 while (Tok.is(tok::kw___noinline__)) {
1017 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1018 SourceLocation AttrNameLoc = ConsumeToken();
1019 attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1020 tok::kw___noinline__);
1021 }
1022 }
1023
ParseOpenCLQualifiers(ParsedAttributes & Attrs)1024 void Parser::ParseOpenCLQualifiers(ParsedAttributes &Attrs) {
1025 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1026 SourceLocation AttrNameLoc = Tok.getLocation();
1027 Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1028 Tok.getKind());
1029 }
1030
isHLSLQualifier(const Token & Tok) const1031 bool Parser::isHLSLQualifier(const Token &Tok) const {
1032 return Tok.is(tok::kw_groupshared);
1033 }
1034
ParseHLSLQualifiers(ParsedAttributes & Attrs)1035 void Parser::ParseHLSLQualifiers(ParsedAttributes &Attrs) {
1036 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1037 auto Kind = Tok.getKind();
1038 SourceLocation AttrNameLoc = ConsumeToken();
1039 Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0, Kind);
1040 }
1041
ParseNullabilityTypeSpecifiers(ParsedAttributes & attrs)1042 void Parser::ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs) {
1043 // Treat these like attributes, even though they're type specifiers.
1044 while (true) {
1045 auto Kind = Tok.getKind();
1046 switch (Kind) {
1047 case tok::kw__Nonnull:
1048 case tok::kw__Nullable:
1049 case tok::kw__Nullable_result:
1050 case tok::kw__Null_unspecified: {
1051 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1052 SourceLocation AttrNameLoc = ConsumeToken();
1053 if (!getLangOpts().ObjC)
1054 Diag(AttrNameLoc, diag::ext_nullability)
1055 << AttrName;
1056 attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1057 Kind);
1058 break;
1059 }
1060 default:
1061 return;
1062 }
1063 }
1064 }
1065
VersionNumberSeparator(const char Separator)1066 static bool VersionNumberSeparator(const char Separator) {
1067 return (Separator == '.' || Separator == '_');
1068 }
1069
1070 /// Parse a version number.
1071 ///
1072 /// version:
1073 /// simple-integer
1074 /// simple-integer '.' simple-integer
1075 /// simple-integer '_' simple-integer
1076 /// simple-integer '.' simple-integer '.' simple-integer
1077 /// simple-integer '_' simple-integer '_' simple-integer
ParseVersionTuple(SourceRange & Range)1078 VersionTuple Parser::ParseVersionTuple(SourceRange &Range) {
1079 Range = SourceRange(Tok.getLocation(), Tok.getEndLoc());
1080
1081 if (!Tok.is(tok::numeric_constant)) {
1082 Diag(Tok, diag::err_expected_version);
1083 SkipUntil(tok::comma, tok::r_paren,
1084 StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1085 return VersionTuple();
1086 }
1087
1088 // Parse the major (and possibly minor and subminor) versions, which
1089 // are stored in the numeric constant. We utilize a quirk of the
1090 // lexer, which is that it handles something like 1.2.3 as a single
1091 // numeric constant, rather than two separate tokens.
1092 SmallString<512> Buffer;
1093 Buffer.resize(Tok.getLength()+1);
1094 const char *ThisTokBegin = &Buffer[0];
1095
1096 // Get the spelling of the token, which eliminates trigraphs, etc.
1097 bool Invalid = false;
1098 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid);
1099 if (Invalid)
1100 return VersionTuple();
1101
1102 // Parse the major version.
1103 unsigned AfterMajor = 0;
1104 unsigned Major = 0;
1105 while (AfterMajor < ActualLength && isDigit(ThisTokBegin[AfterMajor])) {
1106 Major = Major * 10 + ThisTokBegin[AfterMajor] - '0';
1107 ++AfterMajor;
1108 }
1109
1110 if (AfterMajor == 0) {
1111 Diag(Tok, diag::err_expected_version);
1112 SkipUntil(tok::comma, tok::r_paren,
1113 StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1114 return VersionTuple();
1115 }
1116
1117 if (AfterMajor == ActualLength) {
1118 ConsumeToken();
1119
1120 // We only had a single version component.
1121 if (Major == 0) {
1122 Diag(Tok, diag::err_zero_version);
1123 return VersionTuple();
1124 }
1125
1126 return VersionTuple(Major);
1127 }
1128
1129 const char AfterMajorSeparator = ThisTokBegin[AfterMajor];
1130 if (!VersionNumberSeparator(AfterMajorSeparator)
1131 || (AfterMajor + 1 == ActualLength)) {
1132 Diag(Tok, diag::err_expected_version);
1133 SkipUntil(tok::comma, tok::r_paren,
1134 StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1135 return VersionTuple();
1136 }
1137
1138 // Parse the minor version.
1139 unsigned AfterMinor = AfterMajor + 1;
1140 unsigned Minor = 0;
1141 while (AfterMinor < ActualLength && isDigit(ThisTokBegin[AfterMinor])) {
1142 Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0';
1143 ++AfterMinor;
1144 }
1145
1146 if (AfterMinor == ActualLength) {
1147 ConsumeToken();
1148
1149 // We had major.minor.
1150 if (Major == 0 && Minor == 0) {
1151 Diag(Tok, diag::err_zero_version);
1152 return VersionTuple();
1153 }
1154
1155 return VersionTuple(Major, Minor);
1156 }
1157
1158 const char AfterMinorSeparator = ThisTokBegin[AfterMinor];
1159 // If what follows is not a '.' or '_', we have a problem.
1160 if (!VersionNumberSeparator(AfterMinorSeparator)) {
1161 Diag(Tok, diag::err_expected_version);
1162 SkipUntil(tok::comma, tok::r_paren,
1163 StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1164 return VersionTuple();
1165 }
1166
1167 // Warn if separators, be it '.' or '_', do not match.
1168 if (AfterMajorSeparator != AfterMinorSeparator)
1169 Diag(Tok, diag::warn_expected_consistent_version_separator);
1170
1171 // Parse the subminor version.
1172 unsigned AfterSubminor = AfterMinor + 1;
1173 unsigned Subminor = 0;
1174 while (AfterSubminor < ActualLength && isDigit(ThisTokBegin[AfterSubminor])) {
1175 Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0';
1176 ++AfterSubminor;
1177 }
1178
1179 if (AfterSubminor != ActualLength) {
1180 Diag(Tok, diag::err_expected_version);
1181 SkipUntil(tok::comma, tok::r_paren,
1182 StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1183 return VersionTuple();
1184 }
1185 ConsumeToken();
1186 return VersionTuple(Major, Minor, Subminor);
1187 }
1188
1189 /// Parse the contents of the "availability" attribute.
1190 ///
1191 /// availability-attribute:
1192 /// 'availability' '(' platform ',' opt-strict version-arg-list,
1193 /// opt-replacement, opt-message')'
1194 ///
1195 /// platform:
1196 /// identifier
1197 ///
1198 /// opt-strict:
1199 /// 'strict' ','
1200 ///
1201 /// version-arg-list:
1202 /// version-arg
1203 /// version-arg ',' version-arg-list
1204 ///
1205 /// version-arg:
1206 /// 'introduced' '=' version
1207 /// 'deprecated' '=' version
1208 /// 'obsoleted' = version
1209 /// 'unavailable'
1210 /// opt-replacement:
1211 /// 'replacement' '=' <string>
1212 /// opt-message:
1213 /// 'message' '=' <string>
ParseAvailabilityAttribute(IdentifierInfo & Availability,SourceLocation AvailabilityLoc,ParsedAttributes & attrs,SourceLocation * endLoc,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form)1214 void Parser::ParseAvailabilityAttribute(
1215 IdentifierInfo &Availability, SourceLocation AvailabilityLoc,
1216 ParsedAttributes &attrs, SourceLocation *endLoc, IdentifierInfo *ScopeName,
1217 SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1218 enum { Introduced, Deprecated, Obsoleted, Unknown };
1219 AvailabilityChange Changes[Unknown];
1220 ExprResult MessageExpr, ReplacementExpr;
1221
1222 // Opening '('.
1223 BalancedDelimiterTracker T(*this, tok::l_paren);
1224 if (T.consumeOpen()) {
1225 Diag(Tok, diag::err_expected) << tok::l_paren;
1226 return;
1227 }
1228
1229 // Parse the platform name.
1230 if (Tok.isNot(tok::identifier)) {
1231 Diag(Tok, diag::err_availability_expected_platform);
1232 SkipUntil(tok::r_paren, StopAtSemi);
1233 return;
1234 }
1235 IdentifierLoc *Platform = ParseIdentifierLoc();
1236 if (const IdentifierInfo *const Ident = Platform->Ident) {
1237 // Canonicalize platform name from "macosx" to "macos".
1238 if (Ident->getName() == "macosx")
1239 Platform->Ident = PP.getIdentifierInfo("macos");
1240 // Canonicalize platform name from "macosx_app_extension" to
1241 // "macos_app_extension".
1242 else if (Ident->getName() == "macosx_app_extension")
1243 Platform->Ident = PP.getIdentifierInfo("macos_app_extension");
1244 else
1245 Platform->Ident = PP.getIdentifierInfo(
1246 AvailabilityAttr::canonicalizePlatformName(Ident->getName()));
1247 }
1248
1249 // Parse the ',' following the platform name.
1250 if (ExpectAndConsume(tok::comma)) {
1251 SkipUntil(tok::r_paren, StopAtSemi);
1252 return;
1253 }
1254
1255 // If we haven't grabbed the pointers for the identifiers
1256 // "introduced", "deprecated", and "obsoleted", do so now.
1257 if (!Ident_introduced) {
1258 Ident_introduced = PP.getIdentifierInfo("introduced");
1259 Ident_deprecated = PP.getIdentifierInfo("deprecated");
1260 Ident_obsoleted = PP.getIdentifierInfo("obsoleted");
1261 Ident_unavailable = PP.getIdentifierInfo("unavailable");
1262 Ident_message = PP.getIdentifierInfo("message");
1263 Ident_strict = PP.getIdentifierInfo("strict");
1264 Ident_replacement = PP.getIdentifierInfo("replacement");
1265 }
1266
1267 // Parse the optional "strict", the optional "replacement" and the set of
1268 // introductions/deprecations/removals.
1269 SourceLocation UnavailableLoc, StrictLoc;
1270 do {
1271 if (Tok.isNot(tok::identifier)) {
1272 Diag(Tok, diag::err_availability_expected_change);
1273 SkipUntil(tok::r_paren, StopAtSemi);
1274 return;
1275 }
1276 IdentifierInfo *Keyword = Tok.getIdentifierInfo();
1277 SourceLocation KeywordLoc = ConsumeToken();
1278
1279 if (Keyword == Ident_strict) {
1280 if (StrictLoc.isValid()) {
1281 Diag(KeywordLoc, diag::err_availability_redundant)
1282 << Keyword << SourceRange(StrictLoc);
1283 }
1284 StrictLoc = KeywordLoc;
1285 continue;
1286 }
1287
1288 if (Keyword == Ident_unavailable) {
1289 if (UnavailableLoc.isValid()) {
1290 Diag(KeywordLoc, diag::err_availability_redundant)
1291 << Keyword << SourceRange(UnavailableLoc);
1292 }
1293 UnavailableLoc = KeywordLoc;
1294 continue;
1295 }
1296
1297 if (Keyword == Ident_deprecated && Platform->Ident &&
1298 Platform->Ident->isStr("swift")) {
1299 // For swift, we deprecate for all versions.
1300 if (Changes[Deprecated].KeywordLoc.isValid()) {
1301 Diag(KeywordLoc, diag::err_availability_redundant)
1302 << Keyword
1303 << SourceRange(Changes[Deprecated].KeywordLoc);
1304 }
1305
1306 Changes[Deprecated].KeywordLoc = KeywordLoc;
1307 // Use a fake version here.
1308 Changes[Deprecated].Version = VersionTuple(1);
1309 continue;
1310 }
1311
1312 if (Tok.isNot(tok::equal)) {
1313 Diag(Tok, diag::err_expected_after) << Keyword << tok::equal;
1314 SkipUntil(tok::r_paren, StopAtSemi);
1315 return;
1316 }
1317 ConsumeToken();
1318 if (Keyword == Ident_message || Keyword == Ident_replacement) {
1319 if (!isTokenStringLiteral()) {
1320 Diag(Tok, diag::err_expected_string_literal)
1321 << /*Source='availability attribute'*/2;
1322 SkipUntil(tok::r_paren, StopAtSemi);
1323 return;
1324 }
1325 if (Keyword == Ident_message) {
1326 MessageExpr = ParseUnevaluatedStringLiteralExpression();
1327 break;
1328 } else {
1329 ReplacementExpr = ParseUnevaluatedStringLiteralExpression();
1330 continue;
1331 }
1332 }
1333
1334 // Special handling of 'NA' only when applied to introduced or
1335 // deprecated.
1336 if ((Keyword == Ident_introduced || Keyword == Ident_deprecated) &&
1337 Tok.is(tok::identifier)) {
1338 IdentifierInfo *NA = Tok.getIdentifierInfo();
1339 if (NA->getName() == "NA") {
1340 ConsumeToken();
1341 if (Keyword == Ident_introduced)
1342 UnavailableLoc = KeywordLoc;
1343 continue;
1344 }
1345 }
1346
1347 SourceRange VersionRange;
1348 VersionTuple Version = ParseVersionTuple(VersionRange);
1349
1350 if (Version.empty()) {
1351 SkipUntil(tok::r_paren, StopAtSemi);
1352 return;
1353 }
1354
1355 unsigned Index;
1356 if (Keyword == Ident_introduced)
1357 Index = Introduced;
1358 else if (Keyword == Ident_deprecated)
1359 Index = Deprecated;
1360 else if (Keyword == Ident_obsoleted)
1361 Index = Obsoleted;
1362 else
1363 Index = Unknown;
1364
1365 if (Index < Unknown) {
1366 if (!Changes[Index].KeywordLoc.isInvalid()) {
1367 Diag(KeywordLoc, diag::err_availability_redundant)
1368 << Keyword
1369 << SourceRange(Changes[Index].KeywordLoc,
1370 Changes[Index].VersionRange.getEnd());
1371 }
1372
1373 Changes[Index].KeywordLoc = KeywordLoc;
1374 Changes[Index].Version = Version;
1375 Changes[Index].VersionRange = VersionRange;
1376 } else {
1377 Diag(KeywordLoc, diag::err_availability_unknown_change)
1378 << Keyword << VersionRange;
1379 }
1380
1381 } while (TryConsumeToken(tok::comma));
1382
1383 // Closing ')'.
1384 if (T.consumeClose())
1385 return;
1386
1387 if (endLoc)
1388 *endLoc = T.getCloseLocation();
1389
1390 // The 'unavailable' availability cannot be combined with any other
1391 // availability changes. Make sure that hasn't happened.
1392 if (UnavailableLoc.isValid()) {
1393 bool Complained = false;
1394 for (unsigned Index = Introduced; Index != Unknown; ++Index) {
1395 if (Changes[Index].KeywordLoc.isValid()) {
1396 if (!Complained) {
1397 Diag(UnavailableLoc, diag::warn_availability_and_unavailable)
1398 << SourceRange(Changes[Index].KeywordLoc,
1399 Changes[Index].VersionRange.getEnd());
1400 Complained = true;
1401 }
1402
1403 // Clear out the availability.
1404 Changes[Index] = AvailabilityChange();
1405 }
1406 }
1407 }
1408
1409 // Record this attribute
1410 attrs.addNew(&Availability,
1411 SourceRange(AvailabilityLoc, T.getCloseLocation()), ScopeName,
1412 ScopeLoc, Platform, Changes[Introduced], Changes[Deprecated],
1413 Changes[Obsoleted], UnavailableLoc, MessageExpr.get(), Form,
1414 StrictLoc, ReplacementExpr.get());
1415 }
1416
1417 /// Parse the contents of the "external_source_symbol" attribute.
1418 ///
1419 /// external-source-symbol-attribute:
1420 /// 'external_source_symbol' '(' keyword-arg-list ')'
1421 ///
1422 /// keyword-arg-list:
1423 /// keyword-arg
1424 /// keyword-arg ',' keyword-arg-list
1425 ///
1426 /// keyword-arg:
1427 /// 'language' '=' <string>
1428 /// 'defined_in' '=' <string>
1429 /// 'USR' '=' <string>
1430 /// 'generated_declaration'
ParseExternalSourceSymbolAttribute(IdentifierInfo & ExternalSourceSymbol,SourceLocation Loc,ParsedAttributes & Attrs,SourceLocation * EndLoc,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form)1431 void Parser::ParseExternalSourceSymbolAttribute(
1432 IdentifierInfo &ExternalSourceSymbol, SourceLocation Loc,
1433 ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
1434 SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1435 // Opening '('.
1436 BalancedDelimiterTracker T(*this, tok::l_paren);
1437 if (T.expectAndConsume())
1438 return;
1439
1440 // Initialize the pointers for the keyword identifiers when required.
1441 if (!Ident_language) {
1442 Ident_language = PP.getIdentifierInfo("language");
1443 Ident_defined_in = PP.getIdentifierInfo("defined_in");
1444 Ident_generated_declaration = PP.getIdentifierInfo("generated_declaration");
1445 Ident_USR = PP.getIdentifierInfo("USR");
1446 }
1447
1448 ExprResult Language;
1449 bool HasLanguage = false;
1450 ExprResult DefinedInExpr;
1451 bool HasDefinedIn = false;
1452 IdentifierLoc *GeneratedDeclaration = nullptr;
1453 ExprResult USR;
1454 bool HasUSR = false;
1455
1456 // Parse the language/defined_in/generated_declaration keywords
1457 do {
1458 if (Tok.isNot(tok::identifier)) {
1459 Diag(Tok, diag::err_external_source_symbol_expected_keyword);
1460 SkipUntil(tok::r_paren, StopAtSemi);
1461 return;
1462 }
1463
1464 SourceLocation KeywordLoc = Tok.getLocation();
1465 IdentifierInfo *Keyword = Tok.getIdentifierInfo();
1466 if (Keyword == Ident_generated_declaration) {
1467 if (GeneratedDeclaration) {
1468 Diag(Tok, diag::err_external_source_symbol_duplicate_clause) << Keyword;
1469 SkipUntil(tok::r_paren, StopAtSemi);
1470 return;
1471 }
1472 GeneratedDeclaration = ParseIdentifierLoc();
1473 continue;
1474 }
1475
1476 if (Keyword != Ident_language && Keyword != Ident_defined_in &&
1477 Keyword != Ident_USR) {
1478 Diag(Tok, diag::err_external_source_symbol_expected_keyword);
1479 SkipUntil(tok::r_paren, StopAtSemi);
1480 return;
1481 }
1482
1483 ConsumeToken();
1484 if (ExpectAndConsume(tok::equal, diag::err_expected_after,
1485 Keyword->getName())) {
1486 SkipUntil(tok::r_paren, StopAtSemi);
1487 return;
1488 }
1489
1490 bool HadLanguage = HasLanguage, HadDefinedIn = HasDefinedIn,
1491 HadUSR = HasUSR;
1492 if (Keyword == Ident_language)
1493 HasLanguage = true;
1494 else if (Keyword == Ident_USR)
1495 HasUSR = true;
1496 else
1497 HasDefinedIn = true;
1498
1499 if (!isTokenStringLiteral()) {
1500 Diag(Tok, diag::err_expected_string_literal)
1501 << /*Source='external_source_symbol attribute'*/ 3
1502 << /*language | source container | USR*/ (
1503 Keyword == Ident_language
1504 ? 0
1505 : (Keyword == Ident_defined_in ? 1 : 2));
1506 SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch);
1507 continue;
1508 }
1509 if (Keyword == Ident_language) {
1510 if (HadLanguage) {
1511 Diag(KeywordLoc, diag::err_external_source_symbol_duplicate_clause)
1512 << Keyword;
1513 ParseUnevaluatedStringLiteralExpression();
1514 continue;
1515 }
1516 Language = ParseUnevaluatedStringLiteralExpression();
1517 } else if (Keyword == Ident_USR) {
1518 if (HadUSR) {
1519 Diag(KeywordLoc, diag::err_external_source_symbol_duplicate_clause)
1520 << Keyword;
1521 ParseUnevaluatedStringLiteralExpression();
1522 continue;
1523 }
1524 USR = ParseUnevaluatedStringLiteralExpression();
1525 } else {
1526 assert(Keyword == Ident_defined_in && "Invalid clause keyword!");
1527 if (HadDefinedIn) {
1528 Diag(KeywordLoc, diag::err_external_source_symbol_duplicate_clause)
1529 << Keyword;
1530 ParseUnevaluatedStringLiteralExpression();
1531 continue;
1532 }
1533 DefinedInExpr = ParseUnevaluatedStringLiteralExpression();
1534 }
1535 } while (TryConsumeToken(tok::comma));
1536
1537 // Closing ')'.
1538 if (T.consumeClose())
1539 return;
1540 if (EndLoc)
1541 *EndLoc = T.getCloseLocation();
1542
1543 ArgsUnion Args[] = {Language.get(), DefinedInExpr.get(), GeneratedDeclaration,
1544 USR.get()};
1545 Attrs.addNew(&ExternalSourceSymbol, SourceRange(Loc, T.getCloseLocation()),
1546 ScopeName, ScopeLoc, Args, std::size(Args), Form);
1547 }
1548
1549 /// Parse the contents of the "objc_bridge_related" attribute.
1550 /// objc_bridge_related '(' related_class ',' opt-class_method ',' opt-instance_method ')'
1551 /// related_class:
1552 /// Identifier
1553 ///
1554 /// opt-class_method:
1555 /// Identifier: | <empty>
1556 ///
1557 /// opt-instance_method:
1558 /// Identifier | <empty>
1559 ///
ParseObjCBridgeRelatedAttribute(IdentifierInfo & ObjCBridgeRelated,SourceLocation ObjCBridgeRelatedLoc,ParsedAttributes & Attrs,SourceLocation * EndLoc,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form)1560 void Parser::ParseObjCBridgeRelatedAttribute(
1561 IdentifierInfo &ObjCBridgeRelated, SourceLocation ObjCBridgeRelatedLoc,
1562 ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
1563 SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1564 // Opening '('.
1565 BalancedDelimiterTracker T(*this, tok::l_paren);
1566 if (T.consumeOpen()) {
1567 Diag(Tok, diag::err_expected) << tok::l_paren;
1568 return;
1569 }
1570
1571 // Parse the related class name.
1572 if (Tok.isNot(tok::identifier)) {
1573 Diag(Tok, diag::err_objcbridge_related_expected_related_class);
1574 SkipUntil(tok::r_paren, StopAtSemi);
1575 return;
1576 }
1577 IdentifierLoc *RelatedClass = ParseIdentifierLoc();
1578 if (ExpectAndConsume(tok::comma)) {
1579 SkipUntil(tok::r_paren, StopAtSemi);
1580 return;
1581 }
1582
1583 // Parse class method name. It's non-optional in the sense that a trailing
1584 // comma is required, but it can be the empty string, and then we record a
1585 // nullptr.
1586 IdentifierLoc *ClassMethod = nullptr;
1587 if (Tok.is(tok::identifier)) {
1588 ClassMethod = ParseIdentifierLoc();
1589 if (!TryConsumeToken(tok::colon)) {
1590 Diag(Tok, diag::err_objcbridge_related_selector_name);
1591 SkipUntil(tok::r_paren, StopAtSemi);
1592 return;
1593 }
1594 }
1595 if (!TryConsumeToken(tok::comma)) {
1596 if (Tok.is(tok::colon))
1597 Diag(Tok, diag::err_objcbridge_related_selector_name);
1598 else
1599 Diag(Tok, diag::err_expected) << tok::comma;
1600 SkipUntil(tok::r_paren, StopAtSemi);
1601 return;
1602 }
1603
1604 // Parse instance method name. Also non-optional but empty string is
1605 // permitted.
1606 IdentifierLoc *InstanceMethod = nullptr;
1607 if (Tok.is(tok::identifier))
1608 InstanceMethod = ParseIdentifierLoc();
1609 else if (Tok.isNot(tok::r_paren)) {
1610 Diag(Tok, diag::err_expected) << tok::r_paren;
1611 SkipUntil(tok::r_paren, StopAtSemi);
1612 return;
1613 }
1614
1615 // Closing ')'.
1616 if (T.consumeClose())
1617 return;
1618
1619 if (EndLoc)
1620 *EndLoc = T.getCloseLocation();
1621
1622 // Record this attribute
1623 Attrs.addNew(&ObjCBridgeRelated,
1624 SourceRange(ObjCBridgeRelatedLoc, T.getCloseLocation()),
1625 ScopeName, ScopeLoc, RelatedClass, ClassMethod, InstanceMethod,
1626 Form);
1627 }
1628
ParseSwiftNewTypeAttribute(IdentifierInfo & AttrName,SourceLocation AttrNameLoc,ParsedAttributes & Attrs,SourceLocation * EndLoc,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form)1629 void Parser::ParseSwiftNewTypeAttribute(
1630 IdentifierInfo &AttrName, SourceLocation AttrNameLoc,
1631 ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
1632 SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1633 BalancedDelimiterTracker T(*this, tok::l_paren);
1634
1635 // Opening '('
1636 if (T.consumeOpen()) {
1637 Diag(Tok, diag::err_expected) << tok::l_paren;
1638 return;
1639 }
1640
1641 if (Tok.is(tok::r_paren)) {
1642 Diag(Tok.getLocation(), diag::err_argument_required_after_attribute);
1643 T.consumeClose();
1644 return;
1645 }
1646 if (Tok.isNot(tok::kw_struct) && Tok.isNot(tok::kw_enum)) {
1647 Diag(Tok, diag::warn_attribute_type_not_supported)
1648 << &AttrName << Tok.getIdentifierInfo();
1649 if (!isTokenSpecial())
1650 ConsumeToken();
1651 T.consumeClose();
1652 return;
1653 }
1654
1655 auto *SwiftType = IdentifierLoc::create(Actions.Context, Tok.getLocation(),
1656 Tok.getIdentifierInfo());
1657 ConsumeToken();
1658
1659 // Closing ')'
1660 if (T.consumeClose())
1661 return;
1662 if (EndLoc)
1663 *EndLoc = T.getCloseLocation();
1664
1665 ArgsUnion Args[] = {SwiftType};
1666 Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, T.getCloseLocation()),
1667 ScopeName, ScopeLoc, Args, std::size(Args), Form);
1668 }
1669
ParseTypeTagForDatatypeAttribute(IdentifierInfo & AttrName,SourceLocation AttrNameLoc,ParsedAttributes & Attrs,SourceLocation * EndLoc,IdentifierInfo * ScopeName,SourceLocation ScopeLoc,ParsedAttr::Form Form)1670 void Parser::ParseTypeTagForDatatypeAttribute(
1671 IdentifierInfo &AttrName, SourceLocation AttrNameLoc,
1672 ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
1673 SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1674 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
1675
1676 BalancedDelimiterTracker T(*this, tok::l_paren);
1677 T.consumeOpen();
1678
1679 if (Tok.isNot(tok::identifier)) {
1680 Diag(Tok, diag::err_expected) << tok::identifier;
1681 T.skipToEnd();
1682 return;
1683 }
1684 IdentifierLoc *ArgumentKind = ParseIdentifierLoc();
1685
1686 if (ExpectAndConsume(tok::comma)) {
1687 T.skipToEnd();
1688 return;
1689 }
1690
1691 SourceRange MatchingCTypeRange;
1692 TypeResult MatchingCType = ParseTypeName(&MatchingCTypeRange);
1693 if (MatchingCType.isInvalid()) {
1694 T.skipToEnd();
1695 return;
1696 }
1697
1698 bool LayoutCompatible = false;
1699 bool MustBeNull = false;
1700 while (TryConsumeToken(tok::comma)) {
1701 if (Tok.isNot(tok::identifier)) {
1702 Diag(Tok, diag::err_expected) << tok::identifier;
1703 T.skipToEnd();
1704 return;
1705 }
1706 IdentifierInfo *Flag = Tok.getIdentifierInfo();
1707 if (Flag->isStr("layout_compatible"))
1708 LayoutCompatible = true;
1709 else if (Flag->isStr("must_be_null"))
1710 MustBeNull = true;
1711 else {
1712 Diag(Tok, diag::err_type_safety_unknown_flag) << Flag;
1713 T.skipToEnd();
1714 return;
1715 }
1716 ConsumeToken(); // consume flag
1717 }
1718
1719 if (!T.consumeClose()) {
1720 Attrs.addNewTypeTagForDatatype(&AttrName, AttrNameLoc, ScopeName, ScopeLoc,
1721 ArgumentKind, MatchingCType.get(),
1722 LayoutCompatible, MustBeNull, Form);
1723 }
1724
1725 if (EndLoc)
1726 *EndLoc = T.getCloseLocation();
1727 }
1728
1729 /// DiagnoseProhibitedCXX11Attribute - We have found the opening square brackets
1730 /// of a C++11 attribute-specifier in a location where an attribute is not
1731 /// permitted. By C++11 [dcl.attr.grammar]p6, this is ill-formed. Diagnose this
1732 /// situation.
1733 ///
1734 /// \return \c true if we skipped an attribute-like chunk of tokens, \c false if
1735 /// this doesn't appear to actually be an attribute-specifier, and the caller
1736 /// should try to parse it.
DiagnoseProhibitedCXX11Attribute()1737 bool Parser::DiagnoseProhibitedCXX11Attribute() {
1738 assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square));
1739
1740 switch (isCXX11AttributeSpecifier(/*Disambiguate*/true)) {
1741 case CAK_NotAttributeSpecifier:
1742 // No diagnostic: we're in Obj-C++11 and this is not actually an attribute.
1743 return false;
1744
1745 case CAK_InvalidAttributeSpecifier:
1746 Diag(Tok.getLocation(), diag::err_l_square_l_square_not_attribute);
1747 return false;
1748
1749 case CAK_AttributeSpecifier:
1750 // Parse and discard the attributes.
1751 SourceLocation BeginLoc = ConsumeBracket();
1752 ConsumeBracket();
1753 SkipUntil(tok::r_square);
1754 assert(Tok.is(tok::r_square) && "isCXX11AttributeSpecifier lied");
1755 SourceLocation EndLoc = ConsumeBracket();
1756 Diag(BeginLoc, diag::err_attributes_not_allowed)
1757 << SourceRange(BeginLoc, EndLoc);
1758 return true;
1759 }
1760 llvm_unreachable("All cases handled above.");
1761 }
1762
1763 /// We have found the opening square brackets of a C++11
1764 /// attribute-specifier in a location where an attribute is not permitted, but
1765 /// we know where the attributes ought to be written. Parse them anyway, and
1766 /// provide a fixit moving them to the right place.
DiagnoseMisplacedCXX11Attribute(ParsedAttributes & Attrs,SourceLocation CorrectLocation)1767 void Parser::DiagnoseMisplacedCXX11Attribute(ParsedAttributes &Attrs,
1768 SourceLocation CorrectLocation) {
1769 assert((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) ||
1770 Tok.is(tok::kw_alignas) || Tok.isRegularKeywordAttribute());
1771
1772 // Consume the attributes.
1773 auto Keyword =
1774 Tok.isRegularKeywordAttribute() ? Tok.getIdentifierInfo() : nullptr;
1775 SourceLocation Loc = Tok.getLocation();
1776 ParseCXX11Attributes(Attrs);
1777 CharSourceRange AttrRange(SourceRange(Loc, Attrs.Range.getEnd()), true);
1778 // FIXME: use err_attributes_misplaced
1779 (Keyword ? Diag(Loc, diag::err_keyword_not_allowed) << Keyword
1780 : Diag(Loc, diag::err_attributes_not_allowed))
1781 << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
1782 << FixItHint::CreateRemoval(AttrRange);
1783 }
1784
DiagnoseProhibitedAttributes(const ParsedAttributesView & Attrs,const SourceLocation CorrectLocation)1785 void Parser::DiagnoseProhibitedAttributes(
1786 const ParsedAttributesView &Attrs, const SourceLocation CorrectLocation) {
1787 auto *FirstAttr = Attrs.empty() ? nullptr : &Attrs.front();
1788 if (CorrectLocation.isValid()) {
1789 CharSourceRange AttrRange(Attrs.Range, true);
1790 (FirstAttr && FirstAttr->isRegularKeywordAttribute()
1791 ? Diag(CorrectLocation, diag::err_keyword_misplaced) << FirstAttr
1792 : Diag(CorrectLocation, diag::err_attributes_misplaced))
1793 << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
1794 << FixItHint::CreateRemoval(AttrRange);
1795 } else {
1796 const SourceRange &Range = Attrs.Range;
1797 (FirstAttr && FirstAttr->isRegularKeywordAttribute()
1798 ? Diag(Range.getBegin(), diag::err_keyword_not_allowed) << FirstAttr
1799 : Diag(Range.getBegin(), diag::err_attributes_not_allowed))
1800 << Range;
1801 }
1802 }
1803
ProhibitCXX11Attributes(ParsedAttributes & Attrs,unsigned AttrDiagID,unsigned KeywordDiagID,bool DiagnoseEmptyAttrs,bool WarnOnUnknownAttrs)1804 void Parser::ProhibitCXX11Attributes(ParsedAttributes &Attrs,
1805 unsigned AttrDiagID,
1806 unsigned KeywordDiagID,
1807 bool DiagnoseEmptyAttrs,
1808 bool WarnOnUnknownAttrs) {
1809
1810 if (DiagnoseEmptyAttrs && Attrs.empty() && Attrs.Range.isValid()) {
1811 // An attribute list has been parsed, but it was empty.
1812 // This is the case for [[]].
1813 const auto &LangOpts = getLangOpts();
1814 auto &SM = PP.getSourceManager();
1815 Token FirstLSquare;
1816 Lexer::getRawToken(Attrs.Range.getBegin(), FirstLSquare, SM, LangOpts);
1817
1818 if (FirstLSquare.is(tok::l_square)) {
1819 std::optional<Token> SecondLSquare =
1820 Lexer::findNextToken(FirstLSquare.getLocation(), SM, LangOpts);
1821
1822 if (SecondLSquare && SecondLSquare->is(tok::l_square)) {
1823 // The attribute range starts with [[, but is empty. So this must
1824 // be [[]], which we are supposed to diagnose because
1825 // DiagnoseEmptyAttrs is true.
1826 Diag(Attrs.Range.getBegin(), AttrDiagID) << Attrs.Range;
1827 return;
1828 }
1829 }
1830 }
1831
1832 for (const ParsedAttr &AL : Attrs) {
1833 if (AL.isRegularKeywordAttribute()) {
1834 Diag(AL.getLoc(), KeywordDiagID) << AL;
1835 AL.setInvalid();
1836 continue;
1837 }
1838 if (!AL.isStandardAttributeSyntax())
1839 continue;
1840 if (AL.getKind() == ParsedAttr::UnknownAttribute) {
1841 if (WarnOnUnknownAttrs)
1842 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
1843 << AL << AL.getRange();
1844 } else {
1845 Diag(AL.getLoc(), AttrDiagID) << AL;
1846 AL.setInvalid();
1847 }
1848 }
1849 }
1850
DiagnoseCXX11AttributeExtension(ParsedAttributes & Attrs)1851 void Parser::DiagnoseCXX11AttributeExtension(ParsedAttributes &Attrs) {
1852 for (const ParsedAttr &PA : Attrs) {
1853 if (PA.isStandardAttributeSyntax() || PA.isRegularKeywordAttribute())
1854 Diag(PA.getLoc(), diag::ext_cxx11_attr_placement)
1855 << PA << PA.isRegularKeywordAttribute() << PA.getRange();
1856 }
1857 }
1858
1859 // Usually, `__attribute__((attrib)) class Foo {} var` means that attribute
1860 // applies to var, not the type Foo.
1861 // As an exception to the rule, __declspec(align(...)) before the
1862 // class-key affects the type instead of the variable.
1863 // Also, Microsoft-style [attributes] seem to affect the type instead of the
1864 // variable.
1865 // This function moves attributes that should apply to the type off DS to Attrs.
stripTypeAttributesOffDeclSpec(ParsedAttributes & Attrs,DeclSpec & DS,Sema::TagUseKind TUK)1866 void Parser::stripTypeAttributesOffDeclSpec(ParsedAttributes &Attrs,
1867 DeclSpec &DS,
1868 Sema::TagUseKind TUK) {
1869 if (TUK == Sema::TUK_Reference)
1870 return;
1871
1872 llvm::SmallVector<ParsedAttr *, 1> ToBeMoved;
1873
1874 for (ParsedAttr &AL : DS.getAttributes()) {
1875 if ((AL.getKind() == ParsedAttr::AT_Aligned &&
1876 AL.isDeclspecAttribute()) ||
1877 AL.isMicrosoftAttribute())
1878 ToBeMoved.push_back(&AL);
1879 }
1880
1881 for (ParsedAttr *AL : ToBeMoved) {
1882 DS.getAttributes().remove(AL);
1883 Attrs.addAtEnd(AL);
1884 }
1885 }
1886
1887 /// ParseDeclaration - Parse a full 'declaration', which consists of
1888 /// declaration-specifiers, some number of declarators, and a semicolon.
1889 /// 'Context' should be a DeclaratorContext value. This returns the
1890 /// location of the semicolon in DeclEnd.
1891 ///
1892 /// declaration: [C99 6.7]
1893 /// block-declaration ->
1894 /// simple-declaration
1895 /// others [FIXME]
1896 /// [C++] template-declaration
1897 /// [C++] namespace-definition
1898 /// [C++] using-directive
1899 /// [C++] using-declaration
1900 /// [C++11/C11] static_assert-declaration
1901 /// others... [FIXME]
1902 ///
ParseDeclaration(DeclaratorContext Context,SourceLocation & DeclEnd,ParsedAttributes & DeclAttrs,ParsedAttributes & DeclSpecAttrs,SourceLocation * DeclSpecStart)1903 Parser::DeclGroupPtrTy Parser::ParseDeclaration(DeclaratorContext Context,
1904 SourceLocation &DeclEnd,
1905 ParsedAttributes &DeclAttrs,
1906 ParsedAttributes &DeclSpecAttrs,
1907 SourceLocation *DeclSpecStart) {
1908 ParenBraceBracketBalancer BalancerRAIIObj(*this);
1909 // Must temporarily exit the objective-c container scope for
1910 // parsing c none objective-c decls.
1911 ObjCDeclContextSwitch ObjCDC(*this);
1912
1913 Decl *SingleDecl = nullptr;
1914 switch (Tok.getKind()) {
1915 case tok::kw_template:
1916 case tok::kw_export:
1917 ProhibitAttributes(DeclAttrs);
1918 ProhibitAttributes(DeclSpecAttrs);
1919 SingleDecl =
1920 ParseDeclarationStartingWithTemplate(Context, DeclEnd, DeclAttrs);
1921 break;
1922 case tok::kw_inline:
1923 // Could be the start of an inline namespace. Allowed as an ext in C++03.
1924 if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
1925 ProhibitAttributes(DeclAttrs);
1926 ProhibitAttributes(DeclSpecAttrs);
1927 SourceLocation InlineLoc = ConsumeToken();
1928 return ParseNamespace(Context, DeclEnd, InlineLoc);
1929 }
1930 return ParseSimpleDeclaration(Context, DeclEnd, DeclAttrs, DeclSpecAttrs,
1931 true, nullptr, DeclSpecStart);
1932
1933 case tok::kw_cbuffer:
1934 case tok::kw_tbuffer:
1935 SingleDecl = ParseHLSLBuffer(DeclEnd);
1936 break;
1937 case tok::kw_namespace:
1938 ProhibitAttributes(DeclAttrs);
1939 ProhibitAttributes(DeclSpecAttrs);
1940 return ParseNamespace(Context, DeclEnd);
1941 case tok::kw_using: {
1942 ParsedAttributes Attrs(AttrFactory);
1943 takeAndConcatenateAttrs(DeclAttrs, DeclSpecAttrs, Attrs);
1944 return ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
1945 DeclEnd, Attrs);
1946 }
1947 case tok::kw_static_assert:
1948 case tok::kw__Static_assert:
1949 ProhibitAttributes(DeclAttrs);
1950 ProhibitAttributes(DeclSpecAttrs);
1951 SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
1952 break;
1953 default:
1954 return ParseSimpleDeclaration(Context, DeclEnd, DeclAttrs, DeclSpecAttrs,
1955 true, nullptr, DeclSpecStart);
1956 }
1957
1958 // This routine returns a DeclGroup, if the thing we parsed only contains a
1959 // single decl, convert it now.
1960 return Actions.ConvertDeclToDeclGroup(SingleDecl);
1961 }
1962
1963 /// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
1964 /// declaration-specifiers init-declarator-list[opt] ';'
1965 /// [C++11] attribute-specifier-seq decl-specifier-seq[opt]
1966 /// init-declarator-list ';'
1967 ///[C90/C++]init-declarator-list ';' [TODO]
1968 /// [OMP] threadprivate-directive
1969 /// [OMP] allocate-directive [TODO]
1970 ///
1971 /// for-range-declaration: [C++11 6.5p1: stmt.ranged]
1972 /// attribute-specifier-seq[opt] type-specifier-seq declarator
1973 ///
1974 /// If RequireSemi is false, this does not check for a ';' at the end of the
1975 /// declaration. If it is true, it checks for and eats it.
1976 ///
1977 /// If FRI is non-null, we might be parsing a for-range-declaration instead
1978 /// of a simple-declaration. If we find that we are, we also parse the
1979 /// for-range-initializer, and place it here.
1980 ///
1981 /// DeclSpecStart is used when decl-specifiers are parsed before parsing
1982 /// the Declaration. The SourceLocation for this Decl is set to
1983 /// DeclSpecStart if DeclSpecStart is non-null.
ParseSimpleDeclaration(DeclaratorContext Context,SourceLocation & DeclEnd,ParsedAttributes & DeclAttrs,ParsedAttributes & DeclSpecAttrs,bool RequireSemi,ForRangeInit * FRI,SourceLocation * DeclSpecStart)1984 Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(
1985 DeclaratorContext Context, SourceLocation &DeclEnd,
1986 ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs,
1987 bool RequireSemi, ForRangeInit *FRI, SourceLocation *DeclSpecStart) {
1988 // Need to retain these for diagnostics before we add them to the DeclSepc.
1989 ParsedAttributesView OriginalDeclSpecAttrs;
1990 OriginalDeclSpecAttrs.addAll(DeclSpecAttrs.begin(), DeclSpecAttrs.end());
1991 OriginalDeclSpecAttrs.Range = DeclSpecAttrs.Range;
1992
1993 // Parse the common declaration-specifiers piece.
1994 ParsingDeclSpec DS(*this);
1995 DS.takeAttributesFrom(DeclSpecAttrs);
1996
1997 DeclSpecContext DSContext = getDeclSpecContextFromDeclaratorContext(Context);
1998 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, DSContext);
1999
2000 // If we had a free-standing type definition with a missing semicolon, we
2001 // may get this far before the problem becomes obvious.
2002 if (DS.hasTagDefinition() &&
2003 DiagnoseMissingSemiAfterTagDefinition(DS, AS_none, DSContext))
2004 return nullptr;
2005
2006 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
2007 // declaration-specifiers init-declarator-list[opt] ';'
2008 if (Tok.is(tok::semi)) {
2009 ProhibitAttributes(DeclAttrs);
2010 DeclEnd = Tok.getLocation();
2011 if (RequireSemi) ConsumeToken();
2012 RecordDecl *AnonRecord = nullptr;
2013 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
2014 getCurScope(), AS_none, DS, ParsedAttributesView::none(), AnonRecord);
2015 Actions.ActOnDefinedDeclarationSpecifier(TheDecl);
2016 DS.complete(TheDecl);
2017 if (AnonRecord) {
2018 Decl* decls[] = {AnonRecord, TheDecl};
2019 return Actions.BuildDeclaratorGroup(decls);
2020 }
2021 return Actions.ConvertDeclToDeclGroup(TheDecl);
2022 }
2023
2024 if (DS.hasTagDefinition())
2025 Actions.ActOnDefinedDeclarationSpecifier(DS.getRepAsDecl());
2026
2027 if (DeclSpecStart)
2028 DS.SetRangeStart(*DeclSpecStart);
2029
2030 return ParseDeclGroup(DS, Context, DeclAttrs, &DeclEnd, FRI);
2031 }
2032
2033 /// Returns true if this might be the start of a declarator, or a common typo
2034 /// for a declarator.
MightBeDeclarator(DeclaratorContext Context)2035 bool Parser::MightBeDeclarator(DeclaratorContext Context) {
2036 switch (Tok.getKind()) {
2037 case tok::annot_cxxscope:
2038 case tok::annot_template_id:
2039 case tok::caret:
2040 case tok::code_completion:
2041 case tok::coloncolon:
2042 case tok::ellipsis:
2043 case tok::kw___attribute:
2044 case tok::kw_operator:
2045 case tok::l_paren:
2046 case tok::star:
2047 return true;
2048
2049 case tok::amp:
2050 case tok::ampamp:
2051 return getLangOpts().CPlusPlus;
2052
2053 case tok::l_square: // Might be an attribute on an unnamed bit-field.
2054 return Context == DeclaratorContext::Member && getLangOpts().CPlusPlus11 &&
2055 NextToken().is(tok::l_square);
2056
2057 case tok::colon: // Might be a typo for '::' or an unnamed bit-field.
2058 return Context == DeclaratorContext::Member || getLangOpts().CPlusPlus;
2059
2060 case tok::identifier:
2061 switch (NextToken().getKind()) {
2062 case tok::code_completion:
2063 case tok::coloncolon:
2064 case tok::comma:
2065 case tok::equal:
2066 case tok::equalequal: // Might be a typo for '='.
2067 case tok::kw_alignas:
2068 case tok::kw_asm:
2069 case tok::kw___attribute:
2070 case tok::l_brace:
2071 case tok::l_paren:
2072 case tok::l_square:
2073 case tok::less:
2074 case tok::r_brace:
2075 case tok::r_paren:
2076 case tok::r_square:
2077 case tok::semi:
2078 return true;
2079
2080 case tok::colon:
2081 // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
2082 // and in block scope it's probably a label. Inside a class definition,
2083 // this is a bit-field.
2084 return Context == DeclaratorContext::Member ||
2085 (getLangOpts().CPlusPlus && Context == DeclaratorContext::File);
2086
2087 case tok::identifier: // Possible virt-specifier.
2088 return getLangOpts().CPlusPlus11 && isCXX11VirtSpecifier(NextToken());
2089
2090 default:
2091 return Tok.isRegularKeywordAttribute();
2092 }
2093
2094 default:
2095 return Tok.isRegularKeywordAttribute();
2096 }
2097 }
2098
2099 /// Skip until we reach something which seems like a sensible place to pick
2100 /// up parsing after a malformed declaration. This will sometimes stop sooner
2101 /// than SkipUntil(tok::r_brace) would, but will never stop later.
SkipMalformedDecl()2102 void Parser::SkipMalformedDecl() {
2103 while (true) {
2104 switch (Tok.getKind()) {
2105 case tok::l_brace:
2106 // Skip until matching }, then stop. We've probably skipped over
2107 // a malformed class or function definition or similar.
2108 ConsumeBrace();
2109 SkipUntil(tok::r_brace);
2110 if (Tok.isOneOf(tok::comma, tok::l_brace, tok::kw_try)) {
2111 // This declaration isn't over yet. Keep skipping.
2112 continue;
2113 }
2114 TryConsumeToken(tok::semi);
2115 return;
2116
2117 case tok::l_square:
2118 ConsumeBracket();
2119 SkipUntil(tok::r_square);
2120 continue;
2121
2122 case tok::l_paren:
2123 ConsumeParen();
2124 SkipUntil(tok::r_paren);
2125 continue;
2126
2127 case tok::r_brace:
2128 return;
2129
2130 case tok::semi:
2131 ConsumeToken();
2132 return;
2133
2134 case tok::kw_inline:
2135 // 'inline namespace' at the start of a line is almost certainly
2136 // a good place to pick back up parsing, except in an Objective-C
2137 // @interface context.
2138 if (Tok.isAtStartOfLine() && NextToken().is(tok::kw_namespace) &&
2139 (!ParsingInObjCContainer || CurParsedObjCImpl))
2140 return;
2141 break;
2142
2143 case tok::kw_namespace:
2144 // 'namespace' at the start of a line is almost certainly a good
2145 // place to pick back up parsing, except in an Objective-C
2146 // @interface context.
2147 if (Tok.isAtStartOfLine() &&
2148 (!ParsingInObjCContainer || CurParsedObjCImpl))
2149 return;
2150 break;
2151
2152 case tok::at:
2153 // @end is very much like } in Objective-C contexts.
2154 if (NextToken().isObjCAtKeyword(tok::objc_end) &&
2155 ParsingInObjCContainer)
2156 return;
2157 break;
2158
2159 case tok::minus:
2160 case tok::plus:
2161 // - and + probably start new method declarations in Objective-C contexts.
2162 if (Tok.isAtStartOfLine() && ParsingInObjCContainer)
2163 return;
2164 break;
2165
2166 case tok::eof:
2167 case tok::annot_module_begin:
2168 case tok::annot_module_end:
2169 case tok::annot_module_include:
2170 case tok::annot_repl_input_end:
2171 return;
2172
2173 default:
2174 break;
2175 }
2176
2177 ConsumeAnyToken();
2178 }
2179 }
2180
2181 /// ParseDeclGroup - Having concluded that this is either a function
2182 /// definition or a group of object declarations, actually parse the
2183 /// result.
ParseDeclGroup(ParsingDeclSpec & DS,DeclaratorContext Context,ParsedAttributes & Attrs,SourceLocation * DeclEnd,ForRangeInit * FRI)2184 Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
2185 DeclaratorContext Context,
2186 ParsedAttributes &Attrs,
2187 SourceLocation *DeclEnd,
2188 ForRangeInit *FRI) {
2189 // Parse the first declarator.
2190 // Consume all of the attributes from `Attrs` by moving them to our own local
2191 // list. This ensures that we will not attempt to interpret them as statement
2192 // attributes higher up the callchain.
2193 ParsedAttributes LocalAttrs(AttrFactory);
2194 LocalAttrs.takeAllFrom(Attrs);
2195 ParsingDeclarator D(*this, DS, LocalAttrs, Context);
2196 ParseDeclarator(D);
2197
2198 // Bail out if the first declarator didn't seem well-formed.
2199 if (!D.hasName() && !D.mayOmitIdentifier()) {
2200 SkipMalformedDecl();
2201 return nullptr;
2202 }
2203
2204 if (getLangOpts().HLSL)
2205 MaybeParseHLSLSemantics(D);
2206
2207 if (Tok.is(tok::kw_requires))
2208 ParseTrailingRequiresClause(D);
2209
2210 // Save late-parsed attributes for now; they need to be parsed in the
2211 // appropriate function scope after the function Decl has been constructed.
2212 // These will be parsed in ParseFunctionDefinition or ParseLexedAttrList.
2213 LateParsedAttrList LateParsedAttrs(true);
2214 if (D.isFunctionDeclarator()) {
2215 MaybeParseGNUAttributes(D, &LateParsedAttrs);
2216
2217 // The _Noreturn keyword can't appear here, unlike the GNU noreturn
2218 // attribute. If we find the keyword here, tell the user to put it
2219 // at the start instead.
2220 if (Tok.is(tok::kw__Noreturn)) {
2221 SourceLocation Loc = ConsumeToken();
2222 const char *PrevSpec;
2223 unsigned DiagID;
2224
2225 // We can offer a fixit if it's valid to mark this function as _Noreturn
2226 // and we don't have any other declarators in this declaration.
2227 bool Fixit = !DS.setFunctionSpecNoreturn(Loc, PrevSpec, DiagID);
2228 MaybeParseGNUAttributes(D, &LateParsedAttrs);
2229 Fixit &= Tok.isOneOf(tok::semi, tok::l_brace, tok::kw_try);
2230
2231 Diag(Loc, diag::err_c11_noreturn_misplaced)
2232 << (Fixit ? FixItHint::CreateRemoval(Loc) : FixItHint())
2233 << (Fixit ? FixItHint::CreateInsertion(D.getBeginLoc(), "_Noreturn ")
2234 : FixItHint());
2235 }
2236
2237 // Check to see if we have a function *definition* which must have a body.
2238 if (Tok.is(tok::equal) && NextToken().is(tok::code_completion)) {
2239 cutOffParsing();
2240 Actions.CodeCompleteAfterFunctionEquals(D);
2241 return nullptr;
2242 }
2243 // We're at the point where the parsing of function declarator is finished.
2244 //
2245 // A common error is that users accidently add a virtual specifier
2246 // (e.g. override) in an out-line method definition.
2247 // We attempt to recover by stripping all these specifiers coming after
2248 // the declarator.
2249 while (auto Specifier = isCXX11VirtSpecifier()) {
2250 Diag(Tok, diag::err_virt_specifier_outside_class)
2251 << VirtSpecifiers::getSpecifierName(Specifier)
2252 << FixItHint::CreateRemoval(Tok.getLocation());
2253 ConsumeToken();
2254 }
2255 // Look at the next token to make sure that this isn't a function
2256 // declaration. We have to check this because __attribute__ might be the
2257 // start of a function definition in GCC-extended K&R C.
2258 if (!isDeclarationAfterDeclarator()) {
2259
2260 // Function definitions are only allowed at file scope and in C++ classes.
2261 // The C++ inline method definition case is handled elsewhere, so we only
2262 // need to handle the file scope definition case.
2263 if (Context == DeclaratorContext::File) {
2264 if (isStartOfFunctionDefinition(D)) {
2265 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
2266 Diag(Tok, diag::err_function_declared_typedef);
2267
2268 // Recover by treating the 'typedef' as spurious.
2269 DS.ClearStorageClassSpecs();
2270 }
2271
2272 Decl *TheDecl = ParseFunctionDefinition(D, ParsedTemplateInfo(),
2273 &LateParsedAttrs);
2274 return Actions.ConvertDeclToDeclGroup(TheDecl);
2275 }
2276
2277 if (isDeclarationSpecifier(ImplicitTypenameContext::No) ||
2278 Tok.is(tok::kw_namespace)) {
2279 // If there is an invalid declaration specifier or a namespace
2280 // definition right after the function prototype, then we must be in a
2281 // missing semicolon case where this isn't actually a body. Just fall
2282 // through into the code that handles it as a prototype, and let the
2283 // top-level code handle the erroneous declspec where it would
2284 // otherwise expect a comma or semicolon. Note that
2285 // isDeclarationSpecifier already covers 'inline namespace', since
2286 // 'inline' can be a declaration specifier.
2287 } else {
2288 Diag(Tok, diag::err_expected_fn_body);
2289 SkipUntil(tok::semi);
2290 return nullptr;
2291 }
2292 } else {
2293 if (Tok.is(tok::l_brace)) {
2294 Diag(Tok, diag::err_function_definition_not_allowed);
2295 SkipMalformedDecl();
2296 return nullptr;
2297 }
2298 }
2299 }
2300 }
2301
2302 if (ParseAsmAttributesAfterDeclarator(D))
2303 return nullptr;
2304
2305 // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we
2306 // must parse and analyze the for-range-initializer before the declaration is
2307 // analyzed.
2308 //
2309 // Handle the Objective-C for-in loop variable similarly, although we
2310 // don't need to parse the container in advance.
2311 if (FRI && (Tok.is(tok::colon) || isTokIdentifier_in())) {
2312 bool IsForRangeLoop = false;
2313 if (TryConsumeToken(tok::colon, FRI->ColonLoc)) {
2314 IsForRangeLoop = true;
2315 if (getLangOpts().OpenMP)
2316 Actions.startOpenMPCXXRangeFor();
2317 if (Tok.is(tok::l_brace))
2318 FRI->RangeExpr = ParseBraceInitializer();
2319 else
2320 FRI->RangeExpr = ParseExpression();
2321 }
2322
2323 Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
2324 if (IsForRangeLoop) {
2325 Actions.ActOnCXXForRangeDecl(ThisDecl);
2326 } else {
2327 // Obj-C for loop
2328 if (auto *VD = dyn_cast_or_null<VarDecl>(ThisDecl))
2329 VD->setObjCForDecl(true);
2330 }
2331 Actions.FinalizeDeclaration(ThisDecl);
2332 D.complete(ThisDecl);
2333 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, ThisDecl);
2334 }
2335
2336 SmallVector<Decl *, 8> DeclsInGroup;
2337 Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(
2338 D, ParsedTemplateInfo(), FRI);
2339 if (LateParsedAttrs.size() > 0)
2340 ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false);
2341 D.complete(FirstDecl);
2342 if (FirstDecl)
2343 DeclsInGroup.push_back(FirstDecl);
2344
2345 bool ExpectSemi = Context != DeclaratorContext::ForInit;
2346
2347 // If we don't have a comma, it is either the end of the list (a ';') or an
2348 // error, bail out.
2349 SourceLocation CommaLoc;
2350 while (TryConsumeToken(tok::comma, CommaLoc)) {
2351 if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) {
2352 // This comma was followed by a line-break and something which can't be
2353 // the start of a declarator. The comma was probably a typo for a
2354 // semicolon.
2355 Diag(CommaLoc, diag::err_expected_semi_declaration)
2356 << FixItHint::CreateReplacement(CommaLoc, ";");
2357 ExpectSemi = false;
2358 break;
2359 }
2360
2361 // Parse the next declarator.
2362 D.clear();
2363 D.setCommaLoc(CommaLoc);
2364
2365 // Accept attributes in an init-declarator. In the first declarator in a
2366 // declaration, these would be part of the declspec. In subsequent
2367 // declarators, they become part of the declarator itself, so that they
2368 // don't apply to declarators after *this* one. Examples:
2369 // short __attribute__((common)) var; -> declspec
2370 // short var __attribute__((common)); -> declarator
2371 // short x, __attribute__((common)) var; -> declarator
2372 MaybeParseGNUAttributes(D);
2373
2374 // MSVC parses but ignores qualifiers after the comma as an extension.
2375 if (getLangOpts().MicrosoftExt)
2376 DiagnoseAndSkipExtendedMicrosoftTypeAttributes();
2377
2378 ParseDeclarator(D);
2379
2380 if (getLangOpts().HLSL)
2381 MaybeParseHLSLSemantics(D);
2382
2383 if (!D.isInvalidType()) {
2384 // C++2a [dcl.decl]p1
2385 // init-declarator:
2386 // declarator initializer[opt]
2387 // declarator requires-clause
2388 if (Tok.is(tok::kw_requires))
2389 ParseTrailingRequiresClause(D);
2390 Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
2391 D.complete(ThisDecl);
2392 if (ThisDecl)
2393 DeclsInGroup.push_back(ThisDecl);
2394 }
2395 }
2396
2397 if (DeclEnd)
2398 *DeclEnd = Tok.getLocation();
2399
2400 if (ExpectSemi && ExpectAndConsumeSemi(
2401 Context == DeclaratorContext::File
2402 ? diag::err_invalid_token_after_toplevel_declarator
2403 : diag::err_expected_semi_declaration)) {
2404 // Okay, there was no semicolon and one was expected. If we see a
2405 // declaration specifier, just assume it was missing and continue parsing.
2406 // Otherwise things are very confused and we skip to recover.
2407 if (!isDeclarationSpecifier(ImplicitTypenameContext::No))
2408 SkipMalformedDecl();
2409 }
2410
2411 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup);
2412 }
2413
2414 /// Parse an optional simple-asm-expr and attributes, and attach them to a
2415 /// declarator. Returns true on an error.
ParseAsmAttributesAfterDeclarator(Declarator & D)2416 bool Parser::ParseAsmAttributesAfterDeclarator(Declarator &D) {
2417 // If a simple-asm-expr is present, parse it.
2418 if (Tok.is(tok::kw_asm)) {
2419 SourceLocation Loc;
2420 ExprResult AsmLabel(ParseSimpleAsm(/*ForAsmLabel*/ true, &Loc));
2421 if (AsmLabel.isInvalid()) {
2422 SkipUntil(tok::semi, StopBeforeMatch);
2423 return true;
2424 }
2425
2426 D.setAsmLabel(AsmLabel.get());
2427 D.SetRangeEnd(Loc);
2428 }
2429
2430 MaybeParseGNUAttributes(D);
2431 return false;
2432 }
2433
2434 /// Parse 'declaration' after parsing 'declaration-specifiers
2435 /// declarator'. This method parses the remainder of the declaration
2436 /// (including any attributes or initializer, among other things) and
2437 /// finalizes the declaration.
2438 ///
2439 /// init-declarator: [C99 6.7]
2440 /// declarator
2441 /// declarator '=' initializer
2442 /// [GNU] declarator simple-asm-expr[opt] attributes[opt]
2443 /// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer
2444 /// [C++] declarator initializer[opt]
2445 ///
2446 /// [C++] initializer:
2447 /// [C++] '=' initializer-clause
2448 /// [C++] '(' expression-list ')'
2449 /// [C++0x] '=' 'default' [TODO]
2450 /// [C++0x] '=' 'delete'
2451 /// [C++0x] braced-init-list
2452 ///
2453 /// According to the standard grammar, =default and =delete are function
2454 /// definitions, but that definitely doesn't fit with the parser here.
2455 ///
ParseDeclarationAfterDeclarator(Declarator & D,const ParsedTemplateInfo & TemplateInfo)2456 Decl *Parser::ParseDeclarationAfterDeclarator(
2457 Declarator &D, const ParsedTemplateInfo &TemplateInfo) {
2458 if (ParseAsmAttributesAfterDeclarator(D))
2459 return nullptr;
2460
2461 return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
2462 }
2463
ParseDeclarationAfterDeclaratorAndAttributes(Declarator & D,const ParsedTemplateInfo & TemplateInfo,ForRangeInit * FRI)2464 Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
2465 Declarator &D, const ParsedTemplateInfo &TemplateInfo, ForRangeInit *FRI) {
2466 // RAII type used to track whether we're inside an initializer.
2467 struct InitializerScopeRAII {
2468 Parser &P;
2469 Declarator &D;
2470 Decl *ThisDecl;
2471
2472 InitializerScopeRAII(Parser &P, Declarator &D, Decl *ThisDecl)
2473 : P(P), D(D), ThisDecl(ThisDecl) {
2474 if (ThisDecl && P.getLangOpts().CPlusPlus) {
2475 Scope *S = nullptr;
2476 if (D.getCXXScopeSpec().isSet()) {
2477 P.EnterScope(0);
2478 S = P.getCurScope();
2479 }
2480 P.Actions.ActOnCXXEnterDeclInitializer(S, ThisDecl);
2481 }
2482 }
2483 ~InitializerScopeRAII() { pop(); }
2484 void pop() {
2485 if (ThisDecl && P.getLangOpts().CPlusPlus) {
2486 Scope *S = nullptr;
2487 if (D.getCXXScopeSpec().isSet())
2488 S = P.getCurScope();
2489 P.Actions.ActOnCXXExitDeclInitializer(S, ThisDecl);
2490 if (S)
2491 P.ExitScope();
2492 }
2493 ThisDecl = nullptr;
2494 }
2495 };
2496
2497 enum class InitKind { Uninitialized, Equal, CXXDirect, CXXBraced };
2498 InitKind TheInitKind;
2499 // If a '==' or '+=' is found, suggest a fixit to '='.
2500 if (isTokenEqualOrEqualTypo())
2501 TheInitKind = InitKind::Equal;
2502 else if (Tok.is(tok::l_paren))
2503 TheInitKind = InitKind::CXXDirect;
2504 else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace) &&
2505 (!CurParsedObjCImpl || !D.isFunctionDeclarator()))
2506 TheInitKind = InitKind::CXXBraced;
2507 else
2508 TheInitKind = InitKind::Uninitialized;
2509 if (TheInitKind != InitKind::Uninitialized)
2510 D.setHasInitializer();
2511
2512 // Inform Sema that we just parsed this declarator.
2513 Decl *ThisDecl = nullptr;
2514 Decl *OuterDecl = nullptr;
2515 switch (TemplateInfo.Kind) {
2516 case ParsedTemplateInfo::NonTemplate:
2517 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
2518 break;
2519
2520 case ParsedTemplateInfo::Template:
2521 case ParsedTemplateInfo::ExplicitSpecialization: {
2522 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
2523 *TemplateInfo.TemplateParams,
2524 D);
2525 if (VarTemplateDecl *VT = dyn_cast_or_null<VarTemplateDecl>(ThisDecl)) {
2526 // Re-direct this decl to refer to the templated decl so that we can
2527 // initialize it.
2528 ThisDecl = VT->getTemplatedDecl();
2529 OuterDecl = VT;
2530 }
2531 break;
2532 }
2533 case ParsedTemplateInfo::ExplicitInstantiation: {
2534 if (Tok.is(tok::semi)) {
2535 DeclResult ThisRes = Actions.ActOnExplicitInstantiation(
2536 getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc, D);
2537 if (ThisRes.isInvalid()) {
2538 SkipUntil(tok::semi, StopBeforeMatch);
2539 return nullptr;
2540 }
2541 ThisDecl = ThisRes.get();
2542 } else {
2543 // FIXME: This check should be for a variable template instantiation only.
2544
2545 // Check that this is a valid instantiation
2546 if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
2547 // If the declarator-id is not a template-id, issue a diagnostic and
2548 // recover by ignoring the 'template' keyword.
2549 Diag(Tok, diag::err_template_defn_explicit_instantiation)
2550 << 2 << FixItHint::CreateRemoval(TemplateInfo.TemplateLoc);
2551 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
2552 } else {
2553 SourceLocation LAngleLoc =
2554 PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
2555 Diag(D.getIdentifierLoc(),
2556 diag::err_explicit_instantiation_with_definition)
2557 << SourceRange(TemplateInfo.TemplateLoc)
2558 << FixItHint::CreateInsertion(LAngleLoc, "<>");
2559
2560 // Recover as if it were an explicit specialization.
2561 TemplateParameterLists FakedParamLists;
2562 FakedParamLists.push_back(Actions.ActOnTemplateParameterList(
2563 0, SourceLocation(), TemplateInfo.TemplateLoc, LAngleLoc,
2564 std::nullopt, LAngleLoc, nullptr));
2565
2566 ThisDecl =
2567 Actions.ActOnTemplateDeclarator(getCurScope(), FakedParamLists, D);
2568 }
2569 }
2570 break;
2571 }
2572 }
2573
2574 Sema::CUDATargetContextRAII X(Actions, Sema::CTCK_InitGlobalVar, ThisDecl);
2575 switch (TheInitKind) {
2576 // Parse declarator '=' initializer.
2577 case InitKind::Equal: {
2578 SourceLocation EqualLoc = ConsumeToken();
2579
2580 if (Tok.is(tok::kw_delete)) {
2581 if (D.isFunctionDeclarator())
2582 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
2583 << 1 /* delete */;
2584 else
2585 Diag(ConsumeToken(), diag::err_deleted_non_function);
2586 } else if (Tok.is(tok::kw_default)) {
2587 if (D.isFunctionDeclarator())
2588 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
2589 << 0 /* default */;
2590 else
2591 Diag(ConsumeToken(), diag::err_default_special_members)
2592 << getLangOpts().CPlusPlus20;
2593 } else {
2594 InitializerScopeRAII InitScope(*this, D, ThisDecl);
2595
2596 if (Tok.is(tok::code_completion)) {
2597 cutOffParsing();
2598 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
2599 Actions.FinalizeDeclaration(ThisDecl);
2600 return nullptr;
2601 }
2602
2603 PreferredType.enterVariableInit(Tok.getLocation(), ThisDecl);
2604 ExprResult Init = ParseInitializer();
2605
2606 // If this is the only decl in (possibly) range based for statement,
2607 // our best guess is that the user meant ':' instead of '='.
2608 if (Tok.is(tok::r_paren) && FRI && D.isFirstDeclarator()) {
2609 Diag(EqualLoc, diag::err_single_decl_assign_in_for_range)
2610 << FixItHint::CreateReplacement(EqualLoc, ":");
2611 // We are trying to stop parser from looking for ';' in this for
2612 // statement, therefore preventing spurious errors to be issued.
2613 FRI->ColonLoc = EqualLoc;
2614 Init = ExprError();
2615 FRI->RangeExpr = Init;
2616 }
2617
2618 InitScope.pop();
2619
2620 if (Init.isInvalid()) {
2621 SmallVector<tok::TokenKind, 2> StopTokens;
2622 StopTokens.push_back(tok::comma);
2623 if (D.getContext() == DeclaratorContext::ForInit ||
2624 D.getContext() == DeclaratorContext::SelectionInit)
2625 StopTokens.push_back(tok::r_paren);
2626 SkipUntil(StopTokens, StopAtSemi | StopBeforeMatch);
2627 Actions.ActOnInitializerError(ThisDecl);
2628 } else
2629 Actions.AddInitializerToDecl(ThisDecl, Init.get(),
2630 /*DirectInit=*/false);
2631 }
2632 break;
2633 }
2634 case InitKind::CXXDirect: {
2635 // Parse C++ direct initializer: '(' expression-list ')'
2636 BalancedDelimiterTracker T(*this, tok::l_paren);
2637 T.consumeOpen();
2638
2639 ExprVector Exprs;
2640
2641 InitializerScopeRAII InitScope(*this, D, ThisDecl);
2642
2643 auto ThisVarDecl = dyn_cast_or_null<VarDecl>(ThisDecl);
2644 auto RunSignatureHelp = [&]() {
2645 QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
2646 ThisVarDecl->getType()->getCanonicalTypeInternal(),
2647 ThisDecl->getLocation(), Exprs, T.getOpenLocation(),
2648 /*Braced=*/false);
2649 CalledSignatureHelp = true;
2650 return PreferredType;
2651 };
2652 auto SetPreferredType = [&] {
2653 PreferredType.enterFunctionArgument(Tok.getLocation(), RunSignatureHelp);
2654 };
2655
2656 llvm::function_ref<void()> ExpressionStarts;
2657 if (ThisVarDecl) {
2658 // ParseExpressionList can sometimes succeed even when ThisDecl is not
2659 // VarDecl. This is an error and it is reported in a call to
2660 // Actions.ActOnInitializerError(). However, we call
2661 // ProduceConstructorSignatureHelp only on VarDecls.
2662 ExpressionStarts = SetPreferredType;
2663 }
2664
2665 bool SawError = ParseExpressionList(Exprs, ExpressionStarts);
2666
2667 InitScope.pop();
2668
2669 if (SawError) {
2670 if (ThisVarDecl && PP.isCodeCompletionReached() && !CalledSignatureHelp) {
2671 Actions.ProduceConstructorSignatureHelp(
2672 ThisVarDecl->getType()->getCanonicalTypeInternal(),
2673 ThisDecl->getLocation(), Exprs, T.getOpenLocation(),
2674 /*Braced=*/false);
2675 CalledSignatureHelp = true;
2676 }
2677 Actions.ActOnInitializerError(ThisDecl);
2678 SkipUntil(tok::r_paren, StopAtSemi);
2679 } else {
2680 // Match the ')'.
2681 T.consumeClose();
2682
2683 ExprResult Initializer = Actions.ActOnParenListExpr(T.getOpenLocation(),
2684 T.getCloseLocation(),
2685 Exprs);
2686 Actions.AddInitializerToDecl(ThisDecl, Initializer.get(),
2687 /*DirectInit=*/true);
2688 }
2689 break;
2690 }
2691 case InitKind::CXXBraced: {
2692 // Parse C++0x braced-init-list.
2693 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
2694
2695 InitializerScopeRAII InitScope(*this, D, ThisDecl);
2696
2697 PreferredType.enterVariableInit(Tok.getLocation(), ThisDecl);
2698 ExprResult Init(ParseBraceInitializer());
2699
2700 InitScope.pop();
2701
2702 if (Init.isInvalid()) {
2703 Actions.ActOnInitializerError(ThisDecl);
2704 } else
2705 Actions.AddInitializerToDecl(ThisDecl, Init.get(), /*DirectInit=*/true);
2706 break;
2707 }
2708 case InitKind::Uninitialized: {
2709 Actions.ActOnUninitializedDecl(ThisDecl);
2710 break;
2711 }
2712 }
2713
2714 Actions.FinalizeDeclaration(ThisDecl);
2715 return OuterDecl ? OuterDecl : ThisDecl;
2716 }
2717
2718 /// ParseSpecifierQualifierList
2719 /// specifier-qualifier-list:
2720 /// type-specifier specifier-qualifier-list[opt]
2721 /// type-qualifier specifier-qualifier-list[opt]
2722 /// [GNU] attributes specifier-qualifier-list[opt]
2723 ///
ParseSpecifierQualifierList(DeclSpec & DS,ImplicitTypenameContext AllowImplicitTypename,AccessSpecifier AS,DeclSpecContext DSC)2724 void Parser::ParseSpecifierQualifierList(
2725 DeclSpec &DS, ImplicitTypenameContext AllowImplicitTypename,
2726 AccessSpecifier AS, DeclSpecContext DSC) {
2727 /// specifier-qualifier-list is a subset of declaration-specifiers. Just
2728 /// parse declaration-specifiers and complain about extra stuff.
2729 /// TODO: diagnose attribute-specifiers and alignment-specifiers.
2730 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC, nullptr,
2731 AllowImplicitTypename);
2732
2733 // Validate declspec for type-name.
2734 unsigned Specs = DS.getParsedSpecifiers();
2735 if (isTypeSpecifier(DSC) && !DS.hasTypeSpecifier()) {
2736 Diag(Tok, diag::err_expected_type);
2737 DS.SetTypeSpecError();
2738 } else if (Specs == DeclSpec::PQ_None && !DS.hasAttributes()) {
2739 Diag(Tok, diag::err_typename_requires_specqual);
2740 if (!DS.hasTypeSpecifier())
2741 DS.SetTypeSpecError();
2742 }
2743
2744 // Issue diagnostic and remove storage class if present.
2745 if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
2746 if (DS.getStorageClassSpecLoc().isValid())
2747 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
2748 else
2749 Diag(DS.getThreadStorageClassSpecLoc(),
2750 diag::err_typename_invalid_storageclass);
2751 DS.ClearStorageClassSpecs();
2752 }
2753
2754 // Issue diagnostic and remove function specifier if present.
2755 if (Specs & DeclSpec::PQ_FunctionSpecifier) {
2756 if (DS.isInlineSpecified())
2757 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
2758 if (DS.isVirtualSpecified())
2759 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
2760 if (DS.hasExplicitSpecifier())
2761 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
2762 if (DS.isNoreturnSpecified())
2763 Diag(DS.getNoreturnSpecLoc(), diag::err_typename_invalid_functionspec);
2764 DS.ClearFunctionSpecs();
2765 }
2766
2767 // Issue diagnostic and remove constexpr specifier if present.
2768 if (DS.hasConstexprSpecifier() && DSC != DeclSpecContext::DSC_condition) {
2769 Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr)
2770 << static_cast<int>(DS.getConstexprSpecifier());
2771 DS.ClearConstexprSpec();
2772 }
2773 }
2774
2775 /// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
2776 /// specified token is valid after the identifier in a declarator which
2777 /// immediately follows the declspec. For example, these things are valid:
2778 ///
2779 /// int x [ 4]; // direct-declarator
2780 /// int x ( int y); // direct-declarator
2781 /// int(int x ) // direct-declarator
2782 /// int x ; // simple-declaration
2783 /// int x = 17; // init-declarator-list
2784 /// int x , y; // init-declarator-list
2785 /// int x __asm__ ("foo"); // init-declarator-list
2786 /// int x : 4; // struct-declarator
2787 /// int x { 5}; // C++'0x unified initializers
2788 ///
2789 /// This is not, because 'x' does not immediately follow the declspec (though
2790 /// ')' happens to be valid anyway).
2791 /// int (x)
2792 ///
isValidAfterIdentifierInDeclarator(const Token & T)2793 static bool isValidAfterIdentifierInDeclarator(const Token &T) {
2794 return T.isOneOf(tok::l_square, tok::l_paren, tok::r_paren, tok::semi,
2795 tok::comma, tok::equal, tok::kw_asm, tok::l_brace,
2796 tok::colon);
2797 }
2798
2799 /// ParseImplicitInt - This method is called when we have an non-typename
2800 /// identifier in a declspec (which normally terminates the decl spec) when
2801 /// the declspec has no type specifier. In this case, the declspec is either
2802 /// malformed or is "implicit int" (in K&R and C89).
2803 ///
2804 /// This method handles diagnosing this prettily and returns false if the
2805 /// declspec is done being processed. If it recovers and thinks there may be
2806 /// other pieces of declspec after it, it returns true.
2807 ///
ParseImplicitInt(DeclSpec & DS,CXXScopeSpec * SS,const ParsedTemplateInfo & TemplateInfo,AccessSpecifier AS,DeclSpecContext DSC,ParsedAttributes & Attrs)2808 bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
2809 const ParsedTemplateInfo &TemplateInfo,
2810 AccessSpecifier AS, DeclSpecContext DSC,
2811 ParsedAttributes &Attrs) {
2812 assert(Tok.is(tok::identifier) && "should have identifier");
2813
2814 SourceLocation Loc = Tok.getLocation();
2815 // If we see an identifier that is not a type name, we normally would
2816 // parse it as the identifier being declared. However, when a typename
2817 // is typo'd or the definition is not included, this will incorrectly
2818 // parse the typename as the identifier name and fall over misparsing
2819 // later parts of the diagnostic.
2820 //
2821 // As such, we try to do some look-ahead in cases where this would
2822 // otherwise be an "implicit-int" case to see if this is invalid. For
2823 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as
2824 // an identifier with implicit int, we'd get a parse error because the
2825 // next token is obviously invalid for a type. Parse these as a case
2826 // with an invalid type specifier.
2827 assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
2828
2829 // Since we know that this either implicit int (which is rare) or an
2830 // error, do lookahead to try to do better recovery. This never applies
2831 // within a type specifier. Outside of C++, we allow this even if the
2832 // language doesn't "officially" support implicit int -- we support
2833 // implicit int as an extension in some language modes.
2834 if (!isTypeSpecifier(DSC) && getLangOpts().isImplicitIntAllowed() &&
2835 isValidAfterIdentifierInDeclarator(NextToken())) {
2836 // If this token is valid for implicit int, e.g. "static x = 4", then
2837 // we just avoid eating the identifier, so it will be parsed as the
2838 // identifier in the declarator.
2839 return false;
2840 }
2841
2842 // Early exit as Sema has a dedicated missing_actual_pipe_type diagnostic
2843 // for incomplete declarations such as `pipe p`.
2844 if (getLangOpts().OpenCLCPlusPlus && DS.isTypeSpecPipe())
2845 return false;
2846
2847 if (getLangOpts().CPlusPlus &&
2848 DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
2849 // Don't require a type specifier if we have the 'auto' storage class
2850 // specifier in C++98 -- we'll promote it to a type specifier.
2851 if (SS)
2852 AnnotateScopeToken(*SS, /*IsNewAnnotation*/false);
2853 return false;
2854 }
2855
2856 if (getLangOpts().CPlusPlus && (!SS || SS->isEmpty()) &&
2857 getLangOpts().MSVCCompat) {
2858 // Lookup of an unqualified type name has failed in MSVC compatibility mode.
2859 // Give Sema a chance to recover if we are in a template with dependent base
2860 // classes.
2861 if (ParsedType T = Actions.ActOnMSVCUnknownTypeName(
2862 *Tok.getIdentifierInfo(), Tok.getLocation(),
2863 DSC == DeclSpecContext::DSC_template_type_arg)) {
2864 const char *PrevSpec;
2865 unsigned DiagID;
2866 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T,
2867 Actions.getASTContext().getPrintingPolicy());
2868 DS.SetRangeEnd(Tok.getLocation());
2869 ConsumeToken();
2870 return false;
2871 }
2872 }
2873
2874 // Otherwise, if we don't consume this token, we are going to emit an
2875 // error anyway. Try to recover from various common problems. Check
2876 // to see if this was a reference to a tag name without a tag specified.
2877 // This is a common problem in C (saying 'foo' instead of 'struct foo').
2878 //
2879 // C++ doesn't need this, and isTagName doesn't take SS.
2880 if (SS == nullptr) {
2881 const char *TagName = nullptr, *FixitTagName = nullptr;
2882 tok::TokenKind TagKind = tok::unknown;
2883
2884 switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) {
2885 default: break;
2886 case DeclSpec::TST_enum:
2887 TagName="enum" ; FixitTagName = "enum " ; TagKind=tok::kw_enum ;break;
2888 case DeclSpec::TST_union:
2889 TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break;
2890 case DeclSpec::TST_struct:
2891 TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break;
2892 case DeclSpec::TST_interface:
2893 TagName="__interface"; FixitTagName = "__interface ";
2894 TagKind=tok::kw___interface;break;
2895 case DeclSpec::TST_class:
2896 TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break;
2897 }
2898
2899 if (TagName) {
2900 IdentifierInfo *TokenName = Tok.getIdentifierInfo();
2901 LookupResult R(Actions, TokenName, SourceLocation(),
2902 Sema::LookupOrdinaryName);
2903
2904 Diag(Loc, diag::err_use_of_tag_name_without_tag)
2905 << TokenName << TagName << getLangOpts().CPlusPlus
2906 << FixItHint::CreateInsertion(Tok.getLocation(), FixitTagName);
2907
2908 if (Actions.LookupParsedName(R, getCurScope(), SS)) {
2909 for (LookupResult::iterator I = R.begin(), IEnd = R.end();
2910 I != IEnd; ++I)
2911 Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
2912 << TokenName << TagName;
2913 }
2914
2915 // Parse this as a tag as if the missing tag were present.
2916 if (TagKind == tok::kw_enum)
2917 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS,
2918 DeclSpecContext::DSC_normal);
2919 else
2920 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS,
2921 /*EnteringContext*/ false,
2922 DeclSpecContext::DSC_normal, Attrs);
2923 return true;
2924 }
2925 }
2926
2927 // Determine whether this identifier could plausibly be the name of something
2928 // being declared (with a missing type).
2929 if (!isTypeSpecifier(DSC) && (!SS || DSC == DeclSpecContext::DSC_top_level ||
2930 DSC == DeclSpecContext::DSC_class)) {
2931 // Look ahead to the next token to try to figure out what this declaration
2932 // was supposed to be.
2933 switch (NextToken().getKind()) {
2934 case tok::l_paren: {
2935 // static x(4); // 'x' is not a type
2936 // x(int n); // 'x' is not a type
2937 // x (*p)[]; // 'x' is a type
2938 //
2939 // Since we're in an error case, we can afford to perform a tentative
2940 // parse to determine which case we're in.
2941 TentativeParsingAction PA(*this);
2942 ConsumeToken();
2943 TPResult TPR = TryParseDeclarator(/*mayBeAbstract*/false);
2944 PA.Revert();
2945
2946 if (TPR != TPResult::False) {
2947 // The identifier is followed by a parenthesized declarator.
2948 // It's supposed to be a type.
2949 break;
2950 }
2951
2952 // If we're in a context where we could be declaring a constructor,
2953 // check whether this is a constructor declaration with a bogus name.
2954 if (DSC == DeclSpecContext::DSC_class ||
2955 (DSC == DeclSpecContext::DSC_top_level && SS)) {
2956 IdentifierInfo *II = Tok.getIdentifierInfo();
2957 if (Actions.isCurrentClassNameTypo(II, SS)) {
2958 Diag(Loc, diag::err_constructor_bad_name)
2959 << Tok.getIdentifierInfo() << II
2960 << FixItHint::CreateReplacement(Tok.getLocation(), II->getName());
2961 Tok.setIdentifierInfo(II);
2962 }
2963 }
2964 // Fall through.
2965 [[fallthrough]];
2966 }
2967 case tok::comma:
2968 case tok::equal:
2969 case tok::kw_asm:
2970 case tok::l_brace:
2971 case tok::l_square:
2972 case tok::semi:
2973 // This looks like a variable or function declaration. The type is
2974 // probably missing. We're done parsing decl-specifiers.
2975 // But only if we are not in a function prototype scope.
2976 if (getCurScope()->isFunctionPrototypeScope())
2977 break;
2978 if (SS)
2979 AnnotateScopeToken(*SS, /*IsNewAnnotation*/false);
2980 return false;
2981
2982 default:
2983 // This is probably supposed to be a type. This includes cases like:
2984 // int f(itn);
2985 // struct S { unsigned : 4; };
2986 break;
2987 }
2988 }
2989
2990 // This is almost certainly an invalid type name. Let Sema emit a diagnostic
2991 // and attempt to recover.
2992 ParsedType T;
2993 IdentifierInfo *II = Tok.getIdentifierInfo();
2994 bool IsTemplateName = getLangOpts().CPlusPlus && NextToken().is(tok::less);
2995 Actions.DiagnoseUnknownTypeName(II, Loc, getCurScope(), SS, T,
2996 IsTemplateName);
2997 if (T) {
2998 // The action has suggested that the type T could be used. Set that as
2999 // the type in the declaration specifiers, consume the would-be type
3000 // name token, and we're done.
3001 const char *PrevSpec;
3002 unsigned DiagID;
3003 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T,
3004 Actions.getASTContext().getPrintingPolicy());
3005 DS.SetRangeEnd(Tok.getLocation());
3006 ConsumeToken();
3007 // There may be other declaration specifiers after this.
3008 return true;
3009 } else if (II != Tok.getIdentifierInfo()) {
3010 // If no type was suggested, the correction is to a keyword
3011 Tok.setKind(II->getTokenID());
3012 // There may be other declaration specifiers after this.
3013 return true;
3014 }
3015
3016 // Otherwise, the action had no suggestion for us. Mark this as an error.
3017 DS.SetTypeSpecError();
3018 DS.SetRangeEnd(Tok.getLocation());
3019 ConsumeToken();
3020
3021 // Eat any following template arguments.
3022 if (IsTemplateName) {
3023 SourceLocation LAngle, RAngle;
3024 TemplateArgList Args;
3025 ParseTemplateIdAfterTemplateName(true, LAngle, Args, RAngle);
3026 }
3027
3028 // TODO: Could inject an invalid typedef decl in an enclosing scope to
3029 // avoid rippling error messages on subsequent uses of the same type,
3030 // could be useful if #include was forgotten.
3031 return true;
3032 }
3033
3034 /// Determine the declaration specifier context from the declarator
3035 /// context.
3036 ///
3037 /// \param Context the declarator context, which is one of the
3038 /// DeclaratorContext enumerator values.
3039 Parser::DeclSpecContext
getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context)3040 Parser::getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context) {
3041 switch (Context) {
3042 case DeclaratorContext::Member:
3043 return DeclSpecContext::DSC_class;
3044 case DeclaratorContext::File:
3045 return DeclSpecContext::DSC_top_level;
3046 case DeclaratorContext::TemplateParam:
3047 return DeclSpecContext::DSC_template_param;
3048 case DeclaratorContext::TemplateArg:
3049 return DeclSpecContext::DSC_template_arg;
3050 case DeclaratorContext::TemplateTypeArg:
3051 return DeclSpecContext::DSC_template_type_arg;
3052 case DeclaratorContext::TrailingReturn:
3053 case DeclaratorContext::TrailingReturnVar:
3054 return DeclSpecContext::DSC_trailing;
3055 case DeclaratorContext::AliasDecl:
3056 case DeclaratorContext::AliasTemplate:
3057 return DeclSpecContext::DSC_alias_declaration;
3058 case DeclaratorContext::Association:
3059 return DeclSpecContext::DSC_association;
3060 case DeclaratorContext::TypeName:
3061 return DeclSpecContext::DSC_type_specifier;
3062 case DeclaratorContext::Condition:
3063 return DeclSpecContext::DSC_condition;
3064 case DeclaratorContext::ConversionId:
3065 return DeclSpecContext::DSC_conv_operator;
3066 case DeclaratorContext::CXXNew:
3067 return DeclSpecContext::DSC_new;
3068 case DeclaratorContext::Prototype:
3069 case DeclaratorContext::ObjCResult:
3070 case DeclaratorContext::ObjCParameter:
3071 case DeclaratorContext::KNRTypeList:
3072 case DeclaratorContext::FunctionalCast:
3073 case DeclaratorContext::Block:
3074 case DeclaratorContext::ForInit:
3075 case DeclaratorContext::SelectionInit:
3076 case DeclaratorContext::CXXCatch:
3077 case DeclaratorContext::ObjCCatch:
3078 case DeclaratorContext::BlockLiteral:
3079 case DeclaratorContext::LambdaExpr:
3080 case DeclaratorContext::LambdaExprParameter:
3081 case DeclaratorContext::RequiresExpr:
3082 return DeclSpecContext::DSC_normal;
3083 }
3084
3085 llvm_unreachable("Missing DeclaratorContext case");
3086 }
3087
3088 /// ParseAlignArgument - Parse the argument to an alignment-specifier.
3089 ///
3090 /// [C11] type-id
3091 /// [C11] constant-expression
3092 /// [C++0x] type-id ...[opt]
3093 /// [C++0x] assignment-expression ...[opt]
ParseAlignArgument(StringRef KWName,SourceLocation Start,SourceLocation & EllipsisLoc,bool & IsType,ParsedType & TypeResult)3094 ExprResult Parser::ParseAlignArgument(StringRef KWName, SourceLocation Start,
3095 SourceLocation &EllipsisLoc, bool &IsType,
3096 ParsedType &TypeResult) {
3097 ExprResult ER;
3098 if (isTypeIdInParens()) {
3099 SourceLocation TypeLoc = Tok.getLocation();
3100 ParsedType Ty = ParseTypeName().get();
3101 SourceRange TypeRange(Start, Tok.getLocation());
3102 if (Actions.ActOnAlignasTypeArgument(KWName, Ty, TypeLoc, TypeRange))
3103 return ExprError();
3104 TypeResult = Ty;
3105 IsType = true;
3106 } else {
3107 ER = ParseConstantExpression();
3108 IsType = false;
3109 }
3110
3111 if (getLangOpts().CPlusPlus11)
3112 TryConsumeToken(tok::ellipsis, EllipsisLoc);
3113
3114 return ER;
3115 }
3116
3117 /// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
3118 /// attribute to Attrs.
3119 ///
3120 /// alignment-specifier:
3121 /// [C11] '_Alignas' '(' type-id ')'
3122 /// [C11] '_Alignas' '(' constant-expression ')'
3123 /// [C++11] 'alignas' '(' type-id ...[opt] ')'
3124 /// [C++11] 'alignas' '(' assignment-expression ...[opt] ')'
ParseAlignmentSpecifier(ParsedAttributes & Attrs,SourceLocation * EndLoc)3125 void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
3126 SourceLocation *EndLoc) {
3127 assert(Tok.isOneOf(tok::kw_alignas, tok::kw__Alignas) &&
3128 "Not an alignment-specifier!");
3129 Token KWTok = Tok;
3130 IdentifierInfo *KWName = KWTok.getIdentifierInfo();
3131 auto Kind = KWTok.getKind();
3132 SourceLocation KWLoc = ConsumeToken();
3133
3134 BalancedDelimiterTracker T(*this, tok::l_paren);
3135 if (T.expectAndConsume())
3136 return;
3137
3138 bool IsType;
3139 ParsedType TypeResult;
3140 SourceLocation EllipsisLoc;
3141 ExprResult ArgExpr =
3142 ParseAlignArgument(PP.getSpelling(KWTok), T.getOpenLocation(),
3143 EllipsisLoc, IsType, TypeResult);
3144 if (ArgExpr.isInvalid()) {
3145 T.skipToEnd();
3146 return;
3147 }
3148
3149 T.consumeClose();
3150 if (EndLoc)
3151 *EndLoc = T.getCloseLocation();
3152
3153 if (IsType) {
3154 Attrs.addNewTypeAttr(KWName, KWLoc, nullptr, KWLoc, TypeResult, Kind,
3155 EllipsisLoc);
3156 } else {
3157 ArgsVector ArgExprs;
3158 ArgExprs.push_back(ArgExpr.get());
3159 Attrs.addNew(KWName, KWLoc, nullptr, KWLoc, ArgExprs.data(), 1, Kind,
3160 EllipsisLoc);
3161 }
3162 }
3163
ParseExtIntegerArgument()3164 ExprResult Parser::ParseExtIntegerArgument() {
3165 assert(Tok.isOneOf(tok::kw__ExtInt, tok::kw__BitInt) &&
3166 "Not an extended int type");
3167 ConsumeToken();
3168
3169 BalancedDelimiterTracker T(*this, tok::l_paren);
3170 if (T.expectAndConsume())
3171 return ExprError();
3172
3173 ExprResult ER = ParseConstantExpression();
3174 if (ER.isInvalid()) {
3175 T.skipToEnd();
3176 return ExprError();
3177 }
3178
3179 if(T.consumeClose())
3180 return ExprError();
3181 return ER;
3182 }
3183
3184 /// Determine whether we're looking at something that might be a declarator
3185 /// in a simple-declaration. If it can't possibly be a declarator, maybe
3186 /// diagnose a missing semicolon after a prior tag definition in the decl
3187 /// specifier.
3188 ///
3189 /// \return \c true if an error occurred and this can't be any kind of
3190 /// declaration.
3191 bool
DiagnoseMissingSemiAfterTagDefinition(DeclSpec & DS,AccessSpecifier AS,DeclSpecContext DSContext,LateParsedAttrList * LateAttrs)3192 Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS,
3193 DeclSpecContext DSContext,
3194 LateParsedAttrList *LateAttrs) {
3195 assert(DS.hasTagDefinition() && "shouldn't call this");
3196
3197 bool EnteringContext = (DSContext == DeclSpecContext::DSC_class ||
3198 DSContext == DeclSpecContext::DSC_top_level);
3199
3200 if (getLangOpts().CPlusPlus &&
3201 Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype,
3202 tok::annot_template_id) &&
3203 TryAnnotateCXXScopeToken(EnteringContext)) {
3204 SkipMalformedDecl();
3205 return true;
3206 }
3207
3208 bool HasScope = Tok.is(tok::annot_cxxscope);
3209 // Make a copy in case GetLookAheadToken invalidates the result of NextToken.
3210 Token AfterScope = HasScope ? NextToken() : Tok;
3211
3212 // Determine whether the following tokens could possibly be a
3213 // declarator.
3214 bool MightBeDeclarator = true;
3215 if (Tok.isOneOf(tok::kw_typename, tok::annot_typename)) {
3216 // A declarator-id can't start with 'typename'.
3217 MightBeDeclarator = false;
3218 } else if (AfterScope.is(tok::annot_template_id)) {
3219 // If we have a type expressed as a template-id, this cannot be a
3220 // declarator-id (such a type cannot be redeclared in a simple-declaration).
3221 TemplateIdAnnotation *Annot =
3222 static_cast<TemplateIdAnnotation *>(AfterScope.getAnnotationValue());
3223 if (Annot->Kind == TNK_Type_template)
3224 MightBeDeclarator = false;
3225 } else if (AfterScope.is(tok::identifier)) {
3226 const Token &Next = HasScope ? GetLookAheadToken(2) : NextToken();
3227
3228 // These tokens cannot come after the declarator-id in a
3229 // simple-declaration, and are likely to come after a type-specifier.
3230 if (Next.isOneOf(tok::star, tok::amp, tok::ampamp, tok::identifier,
3231 tok::annot_cxxscope, tok::coloncolon)) {
3232 // Missing a semicolon.
3233 MightBeDeclarator = false;
3234 } else if (HasScope) {
3235 // If the declarator-id has a scope specifier, it must redeclare a
3236 // previously-declared entity. If that's a type (and this is not a
3237 // typedef), that's an error.
3238 CXXScopeSpec SS;
3239 Actions.RestoreNestedNameSpecifierAnnotation(
3240 Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
3241 IdentifierInfo *Name = AfterScope.getIdentifierInfo();
3242 Sema::NameClassification Classification = Actions.ClassifyName(
3243 getCurScope(), SS, Name, AfterScope.getLocation(), Next,
3244 /*CCC=*/nullptr);
3245 switch (Classification.getKind()) {
3246 case Sema::NC_Error:
3247 SkipMalformedDecl();
3248 return true;
3249
3250 case Sema::NC_Keyword:
3251 llvm_unreachable("typo correction is not possible here");
3252
3253 case Sema::NC_Type:
3254 case Sema::NC_TypeTemplate:
3255 case Sema::NC_UndeclaredNonType:
3256 case Sema::NC_UndeclaredTemplate:
3257 // Not a previously-declared non-type entity.
3258 MightBeDeclarator = false;
3259 break;
3260
3261 case Sema::NC_Unknown:
3262 case Sema::NC_NonType:
3263 case Sema::NC_DependentNonType:
3264 case Sema::NC_OverloadSet:
3265 case Sema::NC_VarTemplate:
3266 case Sema::NC_FunctionTemplate:
3267 case Sema::NC_Concept:
3268 // Might be a redeclaration of a prior entity.
3269 break;
3270 }
3271 }
3272 }
3273
3274 if (MightBeDeclarator)
3275 return false;
3276
3277 const PrintingPolicy &PPol = Actions.getASTContext().getPrintingPolicy();
3278 Diag(PP.getLocForEndOfToken(DS.getRepAsDecl()->getEndLoc()),
3279 diag::err_expected_after)
3280 << DeclSpec::getSpecifierName(DS.getTypeSpecType(), PPol) << tok::semi;
3281
3282 // Try to recover from the typo, by dropping the tag definition and parsing
3283 // the problematic tokens as a type.
3284 //
3285 // FIXME: Split the DeclSpec into pieces for the standalone
3286 // declaration and pieces for the following declaration, instead
3287 // of assuming that all the other pieces attach to new declaration,
3288 // and call ParsedFreeStandingDeclSpec as appropriate.
3289 DS.ClearTypeSpecType();
3290 ParsedTemplateInfo NotATemplate;
3291 ParseDeclarationSpecifiers(DS, NotATemplate, AS, DSContext, LateAttrs);
3292 return false;
3293 }
3294
3295 /// ParseDeclarationSpecifiers
3296 /// declaration-specifiers: [C99 6.7]
3297 /// storage-class-specifier declaration-specifiers[opt]
3298 /// type-specifier declaration-specifiers[opt]
3299 /// [C99] function-specifier declaration-specifiers[opt]
3300 /// [C11] alignment-specifier declaration-specifiers[opt]
3301 /// [GNU] attributes declaration-specifiers[opt]
3302 /// [Clang] '__module_private__' declaration-specifiers[opt]
3303 /// [ObjC1] '__kindof' declaration-specifiers[opt]
3304 ///
3305 /// storage-class-specifier: [C99 6.7.1]
3306 /// 'typedef'
3307 /// 'extern'
3308 /// 'static'
3309 /// 'auto'
3310 /// 'register'
3311 /// [C++] 'mutable'
3312 /// [C++11] 'thread_local'
3313 /// [C11] '_Thread_local'
3314 /// [GNU] '__thread'
3315 /// function-specifier: [C99 6.7.4]
3316 /// [C99] 'inline'
3317 /// [C++] 'virtual'
3318 /// [C++] 'explicit'
3319 /// [OpenCL] '__kernel'
3320 /// 'friend': [C++ dcl.friend]
3321 /// 'constexpr': [C++0x dcl.constexpr]
ParseDeclarationSpecifiers(DeclSpec & DS,const ParsedTemplateInfo & TemplateInfo,AccessSpecifier AS,DeclSpecContext DSContext,LateParsedAttrList * LateAttrs,ImplicitTypenameContext AllowImplicitTypename)3322 void Parser::ParseDeclarationSpecifiers(
3323 DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS,
3324 DeclSpecContext DSContext, LateParsedAttrList *LateAttrs,
3325 ImplicitTypenameContext AllowImplicitTypename) {
3326 if (DS.getSourceRange().isInvalid()) {
3327 // Start the range at the current token but make the end of the range
3328 // invalid. This will make the entire range invalid unless we successfully
3329 // consume a token.
3330 DS.SetRangeStart(Tok.getLocation());
3331 DS.SetRangeEnd(SourceLocation());
3332 }
3333
3334 // If we are in a operator context, convert it back into a type specifier
3335 // context for better error handling later on.
3336 if (DSContext == DeclSpecContext::DSC_conv_operator) {
3337 // No implicit typename here.
3338 AllowImplicitTypename = ImplicitTypenameContext::No;
3339 DSContext = DeclSpecContext::DSC_type_specifier;
3340 }
3341
3342 bool EnteringContext = (DSContext == DeclSpecContext::DSC_class ||
3343 DSContext == DeclSpecContext::DSC_top_level);
3344 bool AttrsLastTime = false;
3345 ParsedAttributes attrs(AttrFactory);
3346 // We use Sema's policy to get bool macros right.
3347 PrintingPolicy Policy = Actions.getPrintingPolicy();
3348 while (true) {
3349 bool isInvalid = false;
3350 bool isStorageClass = false;
3351 const char *PrevSpec = nullptr;
3352 unsigned DiagID = 0;
3353
3354 // This value needs to be set to the location of the last token if the last
3355 // token of the specifier is already consumed.
3356 SourceLocation ConsumedEnd;
3357
3358 // HACK: MSVC doesn't consider _Atomic to be a keyword and its STL
3359 // implementation for VS2013 uses _Atomic as an identifier for one of the
3360 // classes in <atomic>.
3361 //
3362 // A typedef declaration containing _Atomic<...> is among the places where
3363 // the class is used. If we are currently parsing such a declaration, treat
3364 // the token as an identifier.
3365 if (getLangOpts().MSVCCompat && Tok.is(tok::kw__Atomic) &&
3366 DS.getStorageClassSpec() == clang::DeclSpec::SCS_typedef &&
3367 !DS.hasTypeSpecifier() && GetLookAheadToken(1).is(tok::less))
3368 Tok.setKind(tok::identifier);
3369
3370 SourceLocation Loc = Tok.getLocation();
3371
3372 // Helper for image types in OpenCL.
3373 auto handleOpenCLImageKW = [&] (StringRef Ext, TypeSpecifierType ImageTypeSpec) {
3374 // Check if the image type is supported and otherwise turn the keyword into an identifier
3375 // because image types from extensions are not reserved identifiers.
3376 if (!StringRef(Ext).empty() && !getActions().getOpenCLOptions().isSupported(Ext, getLangOpts())) {
3377 Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
3378 Tok.setKind(tok::identifier);
3379 return false;
3380 }
3381 isInvalid = DS.SetTypeSpecType(ImageTypeSpec, Loc, PrevSpec, DiagID, Policy);
3382 return true;
3383 };
3384
3385 // Turn off usual access checking for template specializations and
3386 // instantiations.
3387 bool IsTemplateSpecOrInst =
3388 (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
3389 TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
3390
3391 switch (Tok.getKind()) {
3392 default:
3393 if (Tok.isRegularKeywordAttribute())
3394 goto Attribute;
3395
3396 DoneWithDeclSpec:
3397 if (!AttrsLastTime)
3398 ProhibitAttributes(attrs);
3399 else {
3400 // Reject C++11 / C23 attributes that aren't type attributes.
3401 for (const ParsedAttr &PA : attrs) {
3402 if (!PA.isCXX11Attribute() && !PA.isC23Attribute() &&
3403 !PA.isRegularKeywordAttribute())
3404 continue;
3405 if (PA.getKind() == ParsedAttr::UnknownAttribute)
3406 // We will warn about the unknown attribute elsewhere (in
3407 // SemaDeclAttr.cpp)
3408 continue;
3409 // GCC ignores this attribute when placed on the DeclSpec in [[]]
3410 // syntax, so we do the same.
3411 if (PA.getKind() == ParsedAttr::AT_VectorSize) {
3412 Diag(PA.getLoc(), diag::warn_attribute_ignored) << PA;
3413 PA.setInvalid();
3414 continue;
3415 }
3416 // We reject AT_LifetimeBound and AT_AnyX86NoCfCheck, even though they
3417 // are type attributes, because we historically haven't allowed these
3418 // to be used as type attributes in C++11 / C23 syntax.
3419 if (PA.isTypeAttr() && PA.getKind() != ParsedAttr::AT_LifetimeBound &&
3420 PA.getKind() != ParsedAttr::AT_AnyX86NoCfCheck)
3421 continue;
3422 Diag(PA.getLoc(), diag::err_attribute_not_type_attr)
3423 << PA << PA.isRegularKeywordAttribute();
3424 PA.setInvalid();
3425 }
3426
3427 DS.takeAttributesFrom(attrs);
3428 }
3429
3430 // If this is not a declaration specifier token, we're done reading decl
3431 // specifiers. First verify that DeclSpec's are consistent.
3432 DS.Finish(Actions, Policy);
3433 return;
3434
3435 case tok::l_square:
3436 case tok::kw_alignas:
3437 if (!isAllowedCXX11AttributeSpecifier())
3438 goto DoneWithDeclSpec;
3439
3440 Attribute:
3441 ProhibitAttributes(attrs);
3442 // FIXME: It would be good to recover by accepting the attributes,
3443 // but attempting to do that now would cause serious
3444 // madness in terms of diagnostics.
3445 attrs.clear();
3446 attrs.Range = SourceRange();
3447
3448 ParseCXX11Attributes(attrs);
3449 AttrsLastTime = true;
3450 continue;
3451
3452 case tok::code_completion: {
3453 Sema::ParserCompletionContext CCC = Sema::PCC_Namespace;
3454 if (DS.hasTypeSpecifier()) {
3455 bool AllowNonIdentifiers
3456 = (getCurScope()->getFlags() & (Scope::ControlScope |
3457 Scope::BlockScope |
3458 Scope::TemplateParamScope |
3459 Scope::FunctionPrototypeScope |
3460 Scope::AtCatchScope)) == 0;
3461 bool AllowNestedNameSpecifiers
3462 = DSContext == DeclSpecContext::DSC_top_level ||
3463 (DSContext == DeclSpecContext::DSC_class && DS.isFriendSpecified());
3464
3465 cutOffParsing();
3466 Actions.CodeCompleteDeclSpec(getCurScope(), DS,
3467 AllowNonIdentifiers,
3468 AllowNestedNameSpecifiers);
3469 return;
3470 }
3471
3472 // Class context can appear inside a function/block, so prioritise that.
3473 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
3474 CCC = DSContext == DeclSpecContext::DSC_class ? Sema::PCC_MemberTemplate
3475 : Sema::PCC_Template;
3476 else if (DSContext == DeclSpecContext::DSC_class)
3477 CCC = Sema::PCC_Class;
3478 else if (getCurScope()->getFnParent() || getCurScope()->getBlockParent())
3479 CCC = Sema::PCC_LocalDeclarationSpecifiers;
3480 else if (CurParsedObjCImpl)
3481 CCC = Sema::PCC_ObjCImplementation;
3482
3483 cutOffParsing();
3484 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
3485 return;
3486 }
3487
3488 case tok::coloncolon: // ::foo::bar
3489 // C++ scope specifier. Annotate and loop, or bail out on error.
3490 if (getLangOpts().CPlusPlus &&
3491 TryAnnotateCXXScopeToken(EnteringContext)) {
3492 if (!DS.hasTypeSpecifier())
3493 DS.SetTypeSpecError();
3494 goto DoneWithDeclSpec;
3495 }
3496 if (Tok.is(tok::coloncolon)) // ::new or ::delete
3497 goto DoneWithDeclSpec;
3498 continue;
3499
3500 case tok::annot_cxxscope: {
3501 if (DS.hasTypeSpecifier() || DS.isTypeAltiVecVector())
3502 goto DoneWithDeclSpec;
3503
3504 CXXScopeSpec SS;
3505 if (TemplateInfo.TemplateParams)
3506 SS.setTemplateParamLists(*TemplateInfo.TemplateParams);
3507 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
3508 Tok.getAnnotationRange(),
3509 SS);
3510
3511 // We are looking for a qualified typename.
3512 Token Next = NextToken();
3513
3514 TemplateIdAnnotation *TemplateId = Next.is(tok::annot_template_id)
3515 ? takeTemplateIdAnnotation(Next)
3516 : nullptr;
3517 if (TemplateId && TemplateId->hasInvalidName()) {
3518 // We found something like 'T::U<Args> x', but U is not a template.
3519 // Assume it was supposed to be a type.
3520 DS.SetTypeSpecError();
3521 ConsumeAnnotationToken();
3522 break;
3523 }
3524
3525 if (TemplateId && TemplateId->Kind == TNK_Type_template) {
3526 // We have a qualified template-id, e.g., N::A<int>
3527
3528 // If this would be a valid constructor declaration with template
3529 // arguments, we will reject the attempt to form an invalid type-id
3530 // referring to the injected-class-name when we annotate the token,
3531 // per C++ [class.qual]p2.
3532 //
3533 // To improve diagnostics for this case, parse the declaration as a
3534 // constructor (and reject the extra template arguments later).
3535 if ((DSContext == DeclSpecContext::DSC_top_level ||
3536 DSContext == DeclSpecContext::DSC_class) &&
3537 TemplateId->Name &&
3538 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS) &&
3539 isConstructorDeclarator(/*Unqualified=*/false,
3540 /*DeductionGuide=*/false,
3541 DS.isFriendSpecified())) {
3542 // The user meant this to be an out-of-line constructor
3543 // definition, but template arguments are not allowed
3544 // there. Just allow this as a constructor; we'll
3545 // complain about it later.
3546 goto DoneWithDeclSpec;
3547 }
3548
3549 DS.getTypeSpecScope() = SS;
3550 ConsumeAnnotationToken(); // The C++ scope.
3551 assert(Tok.is(tok::annot_template_id) &&
3552 "ParseOptionalCXXScopeSpecifier not working");
3553 AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
3554 continue;
3555 }
3556
3557 if (TemplateId && TemplateId->Kind == TNK_Concept_template) {
3558 DS.getTypeSpecScope() = SS;
3559 // This is probably a qualified placeholder-specifier, e.g., ::C<int>
3560 // auto ... Consume the scope annotation and continue to consume the
3561 // template-id as a placeholder-specifier. Let the next iteration
3562 // diagnose a missing auto.
3563 ConsumeAnnotationToken();
3564 continue;
3565 }
3566
3567 if (Next.is(tok::annot_typename)) {
3568 DS.getTypeSpecScope() = SS;
3569 ConsumeAnnotationToken(); // The C++ scope.
3570 TypeResult T = getTypeAnnotation(Tok);
3571 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
3572 Tok.getAnnotationEndLoc(),
3573 PrevSpec, DiagID, T, Policy);
3574 if (isInvalid)
3575 break;
3576 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
3577 ConsumeAnnotationToken(); // The typename
3578 }
3579
3580 if (AllowImplicitTypename == ImplicitTypenameContext::Yes &&
3581 Next.is(tok::annot_template_id) &&
3582 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
3583 ->Kind == TNK_Dependent_template_name) {
3584 DS.getTypeSpecScope() = SS;
3585 ConsumeAnnotationToken(); // The C++ scope.
3586 AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
3587 continue;
3588 }
3589
3590 if (Next.isNot(tok::identifier))
3591 goto DoneWithDeclSpec;
3592
3593 // Check whether this is a constructor declaration. If we're in a
3594 // context where the identifier could be a class name, and it has the
3595 // shape of a constructor declaration, process it as one.
3596 if ((DSContext == DeclSpecContext::DSC_top_level ||
3597 DSContext == DeclSpecContext::DSC_class) &&
3598 Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
3599 &SS) &&
3600 isConstructorDeclarator(/*Unqualified=*/false,
3601 /*DeductionGuide=*/false,
3602 DS.isFriendSpecified(),
3603 &TemplateInfo))
3604 goto DoneWithDeclSpec;
3605
3606 // C++20 [temp.spec] 13.9/6.
3607 // This disables the access checking rules for function template explicit
3608 // instantiation and explicit specialization:
3609 // - `return type`.
3610 SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst);
3611
3612 ParsedType TypeRep = Actions.getTypeName(
3613 *Next.getIdentifierInfo(), Next.getLocation(), getCurScope(), &SS,
3614 false, false, nullptr,
3615 /*IsCtorOrDtorName=*/false,
3616 /*WantNontrivialTypeSourceInfo=*/true,
3617 isClassTemplateDeductionContext(DSContext), AllowImplicitTypename);
3618
3619 if (IsTemplateSpecOrInst)
3620 SAC.done();
3621
3622 // If the referenced identifier is not a type, then this declspec is
3623 // erroneous: We already checked about that it has no type specifier, and
3624 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the
3625 // typename.
3626 if (!TypeRep) {
3627 if (TryAnnotateTypeConstraint())
3628 goto DoneWithDeclSpec;
3629 if (Tok.isNot(tok::annot_cxxscope) ||
3630 NextToken().isNot(tok::identifier))
3631 continue;
3632 // Eat the scope spec so the identifier is current.
3633 ConsumeAnnotationToken();
3634 ParsedAttributes Attrs(AttrFactory);
3635 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS, DSContext, Attrs)) {
3636 if (!Attrs.empty()) {
3637 AttrsLastTime = true;
3638 attrs.takeAllFrom(Attrs);
3639 }
3640 continue;
3641 }
3642 goto DoneWithDeclSpec;
3643 }
3644
3645 DS.getTypeSpecScope() = SS;
3646 ConsumeAnnotationToken(); // The C++ scope.
3647
3648 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3649 DiagID, TypeRep, Policy);
3650 if (isInvalid)
3651 break;
3652
3653 DS.SetRangeEnd(Tok.getLocation());
3654 ConsumeToken(); // The typename.
3655
3656 continue;
3657 }
3658
3659 case tok::annot_typename: {
3660 // If we've previously seen a tag definition, we were almost surely
3661 // missing a semicolon after it.
3662 if (DS.hasTypeSpecifier() && DS.hasTagDefinition())
3663 goto DoneWithDeclSpec;
3664
3665 TypeResult T = getTypeAnnotation(Tok);
3666 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3667 DiagID, T, Policy);
3668 if (isInvalid)
3669 break;
3670
3671 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
3672 ConsumeAnnotationToken(); // The typename
3673
3674 continue;
3675 }
3676
3677 case tok::kw___is_signed:
3678 // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang
3679 // typically treats it as a trait. If we see __is_signed as it appears
3680 // in libstdc++, e.g.,
3681 //
3682 // static const bool __is_signed;
3683 //
3684 // then treat __is_signed as an identifier rather than as a keyword.
3685 if (DS.getTypeSpecType() == TST_bool &&
3686 DS.getTypeQualifiers() == DeclSpec::TQ_const &&
3687 DS.getStorageClassSpec() == DeclSpec::SCS_static)
3688 TryKeywordIdentFallback(true);
3689
3690 // We're done with the declaration-specifiers.
3691 goto DoneWithDeclSpec;
3692
3693 // typedef-name
3694 case tok::kw___super:
3695 case tok::kw_decltype:
3696 case tok::identifier:
3697 ParseIdentifier: {
3698 // This identifier can only be a typedef name if we haven't already seen
3699 // a type-specifier. Without this check we misparse:
3700 // typedef int X; struct Y { short X; }; as 'short int'.
3701 if (DS.hasTypeSpecifier())
3702 goto DoneWithDeclSpec;
3703
3704 // If the token is an identifier named "__declspec" and Microsoft
3705 // extensions are not enabled, it is likely that there will be cascading
3706 // parse errors if this really is a __declspec attribute. Attempt to
3707 // recognize that scenario and recover gracefully.
3708 if (!getLangOpts().DeclSpecKeyword && Tok.is(tok::identifier) &&
3709 Tok.getIdentifierInfo()->getName().equals("__declspec")) {
3710 Diag(Loc, diag::err_ms_attributes_not_enabled);
3711
3712 // The next token should be an open paren. If it is, eat the entire
3713 // attribute declaration and continue.
3714 if (NextToken().is(tok::l_paren)) {
3715 // Consume the __declspec identifier.
3716 ConsumeToken();
3717
3718 // Eat the parens and everything between them.
3719 BalancedDelimiterTracker T(*this, tok::l_paren);
3720 if (T.consumeOpen()) {
3721 assert(false && "Not a left paren?");
3722 return;
3723 }
3724 T.skipToEnd();
3725 continue;
3726 }
3727 }
3728
3729 // In C++, check to see if this is a scope specifier like foo::bar::, if
3730 // so handle it as such. This is important for ctor parsing.
3731 if (getLangOpts().CPlusPlus) {
3732 // C++20 [temp.spec] 13.9/6.
3733 // This disables the access checking rules for function template
3734 // explicit instantiation and explicit specialization:
3735 // - `return type`.
3736 SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst);
3737
3738 const bool Success = TryAnnotateCXXScopeToken(EnteringContext);
3739
3740 if (IsTemplateSpecOrInst)
3741 SAC.done();
3742
3743 if (Success) {
3744 if (IsTemplateSpecOrInst)
3745 SAC.redelay();
3746 DS.SetTypeSpecError();
3747 goto DoneWithDeclSpec;
3748 }
3749
3750 if (!Tok.is(tok::identifier))
3751 continue;
3752 }
3753
3754 // Check for need to substitute AltiVec keyword tokens.
3755 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
3756 break;
3757
3758 // [AltiVec] 2.2: [If the 'vector' specifier is used] The syntax does not
3759 // allow the use of a typedef name as a type specifier.
3760 if (DS.isTypeAltiVecVector())
3761 goto DoneWithDeclSpec;
3762
3763 if (DSContext == DeclSpecContext::DSC_objc_method_result &&
3764 isObjCInstancetype()) {
3765 ParsedType TypeRep = Actions.ActOnObjCInstanceType(Loc);
3766 assert(TypeRep);
3767 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3768 DiagID, TypeRep, Policy);
3769 if (isInvalid)
3770 break;
3771
3772 DS.SetRangeEnd(Loc);
3773 ConsumeToken();
3774 continue;
3775 }
3776
3777 // If we're in a context where the identifier could be a class name,
3778 // check whether this is a constructor declaration.
3779 if (getLangOpts().CPlusPlus && DSContext == DeclSpecContext::DSC_class &&
3780 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) &&
3781 isConstructorDeclarator(/*Unqualified=*/true,
3782 /*DeductionGuide=*/false,
3783 DS.isFriendSpecified()))
3784 goto DoneWithDeclSpec;
3785
3786 ParsedType TypeRep = Actions.getTypeName(
3787 *Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope(), nullptr,
3788 false, false, nullptr, false, false,
3789 isClassTemplateDeductionContext(DSContext));
3790
3791 // If this is not a typedef name, don't parse it as part of the declspec,
3792 // it must be an implicit int or an error.
3793 if (!TypeRep) {
3794 if (TryAnnotateTypeConstraint())
3795 goto DoneWithDeclSpec;
3796 if (Tok.isNot(tok::identifier))
3797 continue;
3798 ParsedAttributes Attrs(AttrFactory);
3799 if (ParseImplicitInt(DS, nullptr, TemplateInfo, AS, DSContext, Attrs)) {
3800 if (!Attrs.empty()) {
3801 AttrsLastTime = true;
3802 attrs.takeAllFrom(Attrs);
3803 }
3804 continue;
3805 }
3806 goto DoneWithDeclSpec;
3807 }
3808
3809 // Likewise, if this is a context where the identifier could be a template
3810 // name, check whether this is a deduction guide declaration.
3811 CXXScopeSpec SS;
3812 if (getLangOpts().CPlusPlus17 &&
3813 (DSContext == DeclSpecContext::DSC_class ||
3814 DSContext == DeclSpecContext::DSC_top_level) &&
3815 Actions.isDeductionGuideName(getCurScope(), *Tok.getIdentifierInfo(),
3816 Tok.getLocation(), SS) &&
3817 isConstructorDeclarator(/*Unqualified*/ true,
3818 /*DeductionGuide*/ true))
3819 goto DoneWithDeclSpec;
3820
3821 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3822 DiagID, TypeRep, Policy);
3823 if (isInvalid)
3824 break;
3825
3826 DS.SetRangeEnd(Tok.getLocation());
3827 ConsumeToken(); // The identifier
3828
3829 // Objective-C supports type arguments and protocol references
3830 // following an Objective-C object or object pointer
3831 // type. Handle either one of them.
3832 if (Tok.is(tok::less) && getLangOpts().ObjC) {
3833 SourceLocation NewEndLoc;
3834 TypeResult NewTypeRep = parseObjCTypeArgsAndProtocolQualifiers(
3835 Loc, TypeRep, /*consumeLastToken=*/true,
3836 NewEndLoc);
3837 if (NewTypeRep.isUsable()) {
3838 DS.UpdateTypeRep(NewTypeRep.get());
3839 DS.SetRangeEnd(NewEndLoc);
3840 }
3841 }
3842
3843 // Need to support trailing type qualifiers (e.g. "id<p> const").
3844 // If a type specifier follows, it will be diagnosed elsewhere.
3845 continue;
3846 }
3847
3848 // type-name or placeholder-specifier
3849 case tok::annot_template_id: {
3850 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
3851
3852 if (TemplateId->hasInvalidName()) {
3853 DS.SetTypeSpecError();
3854 break;
3855 }
3856
3857 if (TemplateId->Kind == TNK_Concept_template) {
3858 // If we've already diagnosed that this type-constraint has invalid
3859 // arguments, drop it and just form 'auto' or 'decltype(auto)'.
3860 if (TemplateId->hasInvalidArgs())
3861 TemplateId = nullptr;
3862
3863 // Any of the following tokens are likely the start of the user
3864 // forgetting 'auto' or 'decltype(auto)', so diagnose.
3865 // Note: if updating this list, please make sure we update
3866 // isCXXDeclarationSpecifier's check for IsPlaceholderSpecifier to have
3867 // a matching list.
3868 if (NextToken().isOneOf(tok::identifier, tok::kw_const,
3869 tok::kw_volatile, tok::kw_restrict, tok::amp,
3870 tok::ampamp)) {
3871 Diag(Loc, diag::err_placeholder_expected_auto_or_decltype_auto)
3872 << FixItHint::CreateInsertion(NextToken().getLocation(), "auto");
3873 // Attempt to continue as if 'auto' was placed here.
3874 isInvalid = DS.SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID,
3875 TemplateId, Policy);
3876 break;
3877 }
3878 if (!NextToken().isOneOf(tok::kw_auto, tok::kw_decltype))
3879 goto DoneWithDeclSpec;
3880
3881 if (TemplateId && !isInvalid && Actions.CheckTypeConstraint(TemplateId))
3882 TemplateId = nullptr;
3883
3884 ConsumeAnnotationToken();
3885 SourceLocation AutoLoc = Tok.getLocation();
3886 if (TryConsumeToken(tok::kw_decltype)) {
3887 BalancedDelimiterTracker Tracker(*this, tok::l_paren);
3888 if (Tracker.consumeOpen()) {
3889 // Something like `void foo(Iterator decltype i)`
3890 Diag(Tok, diag::err_expected) << tok::l_paren;
3891 } else {
3892 if (!TryConsumeToken(tok::kw_auto)) {
3893 // Something like `void foo(Iterator decltype(int) i)`
3894 Tracker.skipToEnd();
3895 Diag(Tok, diag::err_placeholder_expected_auto_or_decltype_auto)
3896 << FixItHint::CreateReplacement(SourceRange(AutoLoc,
3897 Tok.getLocation()),
3898 "auto");
3899 } else {
3900 Tracker.consumeClose();
3901 }
3902 }
3903 ConsumedEnd = Tok.getLocation();
3904 DS.setTypeArgumentRange(Tracker.getRange());
3905 // Even if something went wrong above, continue as if we've seen
3906 // `decltype(auto)`.
3907 isInvalid = DS.SetTypeSpecType(TST_decltype_auto, Loc, PrevSpec,
3908 DiagID, TemplateId, Policy);
3909 } else {
3910 isInvalid = DS.SetTypeSpecType(TST_auto, AutoLoc, PrevSpec, DiagID,
3911 TemplateId, Policy);
3912 }
3913 break;
3914 }
3915
3916 if (TemplateId->Kind != TNK_Type_template &&
3917 TemplateId->Kind != TNK_Undeclared_template) {
3918 // This template-id does not refer to a type name, so we're
3919 // done with the type-specifiers.
3920 goto DoneWithDeclSpec;
3921 }
3922
3923 // If we're in a context where the template-id could be a
3924 // constructor name or specialization, check whether this is a
3925 // constructor declaration.
3926 if (getLangOpts().CPlusPlus && DSContext == DeclSpecContext::DSC_class &&
3927 Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) &&
3928 isConstructorDeclarator(/*Unqualified=*/true,
3929 /*DeductionGuide=*/false,
3930 DS.isFriendSpecified()))
3931 goto DoneWithDeclSpec;
3932
3933 // Turn the template-id annotation token into a type annotation
3934 // token, then try again to parse it as a type-specifier.
3935 CXXScopeSpec SS;
3936 AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
3937 continue;
3938 }
3939
3940 // Attributes support.
3941 case tok::kw___attribute:
3942 case tok::kw___declspec:
3943 ParseAttributes(PAKM_GNU | PAKM_Declspec, DS.getAttributes(), LateAttrs);
3944 continue;
3945
3946 // Microsoft single token adornments.
3947 case tok::kw___forceinline: {
3948 isInvalid = DS.setFunctionSpecForceInline(Loc, PrevSpec, DiagID);
3949 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
3950 SourceLocation AttrNameLoc = Tok.getLocation();
3951 DS.getAttributes().addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc,
3952 nullptr, 0, tok::kw___forceinline);
3953 break;
3954 }
3955
3956 case tok::kw___unaligned:
3957 isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
3958 getLangOpts());
3959 break;
3960
3961 case tok::kw___sptr:
3962 case tok::kw___uptr:
3963 case tok::kw___ptr64:
3964 case tok::kw___ptr32:
3965 case tok::kw___w64:
3966 case tok::kw___cdecl:
3967 case tok::kw___stdcall:
3968 case tok::kw___fastcall:
3969 case tok::kw___thiscall:
3970 case tok::kw___regcall:
3971 case tok::kw___vectorcall:
3972 ParseMicrosoftTypeAttributes(DS.getAttributes());
3973 continue;
3974
3975 case tok::kw___funcref:
3976 ParseWebAssemblyFuncrefTypeAttribute(DS.getAttributes());
3977 continue;
3978
3979 // Borland single token adornments.
3980 case tok::kw___pascal:
3981 ParseBorlandTypeAttributes(DS.getAttributes());
3982 continue;
3983
3984 // OpenCL single token adornments.
3985 case tok::kw___kernel:
3986 ParseOpenCLKernelAttributes(DS.getAttributes());
3987 continue;
3988
3989 // CUDA/HIP single token adornments.
3990 case tok::kw___noinline__:
3991 ParseCUDAFunctionAttributes(DS.getAttributes());
3992 continue;
3993
3994 // Nullability type specifiers.
3995 case tok::kw__Nonnull:
3996 case tok::kw__Nullable:
3997 case tok::kw__Nullable_result:
3998 case tok::kw__Null_unspecified:
3999 ParseNullabilityTypeSpecifiers(DS.getAttributes());
4000 continue;
4001
4002 // Objective-C 'kindof' types.
4003 case tok::kw___kindof:
4004 DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
4005 nullptr, 0, tok::kw___kindof);
4006 (void)ConsumeToken();
4007 continue;
4008
4009 // storage-class-specifier
4010 case tok::kw_typedef:
4011 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc,
4012 PrevSpec, DiagID, Policy);
4013 isStorageClass = true;
4014 break;
4015 case tok::kw_extern:
4016 if (DS.getThreadStorageClassSpec() == DeclSpec::TSCS___thread)
4017 Diag(Tok, diag::ext_thread_before) << "extern";
4018 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc,
4019 PrevSpec, DiagID, Policy);
4020 isStorageClass = true;
4021 break;
4022 case tok::kw___private_extern__:
4023 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern,
4024 Loc, PrevSpec, DiagID, Policy);
4025 isStorageClass = true;
4026 break;
4027 case tok::kw_static:
4028 if (DS.getThreadStorageClassSpec() == DeclSpec::TSCS___thread)
4029 Diag(Tok, diag::ext_thread_before) << "static";
4030 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc,
4031 PrevSpec, DiagID, Policy);
4032 isStorageClass = true;
4033 break;
4034 case tok::kw_auto:
4035 if (getLangOpts().CPlusPlus11 || getLangOpts().C23) {
4036 if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
4037 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
4038 PrevSpec, DiagID, Policy);
4039 if (!isInvalid && !getLangOpts().C23)
4040 Diag(Tok, diag::ext_auto_storage_class)
4041 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
4042 } else
4043 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
4044 DiagID, Policy);
4045 } else
4046 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
4047 PrevSpec, DiagID, Policy);
4048 isStorageClass = true;
4049 break;
4050 case tok::kw___auto_type:
4051 Diag(Tok, diag::ext_auto_type);
4052 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto_type, Loc, PrevSpec,
4053 DiagID, Policy);
4054 break;
4055 case tok::kw_register:
4056 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc,
4057 PrevSpec, DiagID, Policy);
4058 isStorageClass = true;
4059 break;
4060 case tok::kw_mutable:
4061 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc,
4062 PrevSpec, DiagID, Policy);
4063 isStorageClass = true;
4064 break;
4065 case tok::kw___thread:
4066 isInvalid = DS.SetStorageClassSpecThread(DeclSpec::TSCS___thread, Loc,
4067 PrevSpec, DiagID);
4068 isStorageClass = true;
4069 break;
4070 case tok::kw_thread_local:
4071 if (getLangOpts().C23)
4072 Diag(Tok, diag::warn_c23_compat_keyword) << Tok.getName();
4073 // We map thread_local to _Thread_local in C23 mode so it retains the C
4074 // semantics rather than getting the C++ semantics.
4075 // FIXME: diagnostics will show _Thread_local when the user wrote
4076 // thread_local in source in C23 mode; we need some general way to
4077 // identify which way the user spelled the keyword in source.
4078 isInvalid = DS.SetStorageClassSpecThread(
4079 getLangOpts().C23 ? DeclSpec::TSCS__Thread_local
4080 : DeclSpec::TSCS_thread_local,
4081 Loc, PrevSpec, DiagID);
4082 isStorageClass = true;
4083 break;
4084 case tok::kw__Thread_local:
4085 if (!getLangOpts().C11)
4086 Diag(Tok, diag::ext_c11_feature) << Tok.getName();
4087 isInvalid = DS.SetStorageClassSpecThread(DeclSpec::TSCS__Thread_local,
4088 Loc, PrevSpec, DiagID);
4089 isStorageClass = true;
4090 break;
4091
4092 // function-specifier
4093 case tok::kw_inline:
4094 isInvalid = DS.setFunctionSpecInline(Loc, PrevSpec, DiagID);
4095 break;
4096 case tok::kw_virtual:
4097 // C++ for OpenCL does not allow virtual function qualifier, to avoid
4098 // function pointers restricted in OpenCL v2.0 s6.9.a.
4099 if (getLangOpts().OpenCLCPlusPlus &&
4100 !getActions().getOpenCLOptions().isAvailableOption(
4101 "__cl_clang_function_pointers", getLangOpts())) {
4102 DiagID = diag::err_openclcxx_virtual_function;
4103 PrevSpec = Tok.getIdentifierInfo()->getNameStart();
4104 isInvalid = true;
4105 } else {
4106 isInvalid = DS.setFunctionSpecVirtual(Loc, PrevSpec, DiagID);
4107 }
4108 break;
4109 case tok::kw_explicit: {
4110 SourceLocation ExplicitLoc = Loc;
4111 SourceLocation CloseParenLoc;
4112 ExplicitSpecifier ExplicitSpec(nullptr, ExplicitSpecKind::ResolvedTrue);
4113 ConsumedEnd = ExplicitLoc;
4114 ConsumeToken(); // kw_explicit
4115 if (Tok.is(tok::l_paren)) {
4116 if (getLangOpts().CPlusPlus20 || isExplicitBool() == TPResult::True) {
4117 Diag(Tok.getLocation(), getLangOpts().CPlusPlus20
4118 ? diag::warn_cxx17_compat_explicit_bool
4119 : diag::ext_explicit_bool);
4120
4121 ExprResult ExplicitExpr(static_cast<Expr *>(nullptr));
4122 BalancedDelimiterTracker Tracker(*this, tok::l_paren);
4123 Tracker.consumeOpen();
4124
4125 EnterExpressionEvaluationContext ConstantEvaluated(
4126 Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
4127
4128 ExplicitExpr = ParseConstantExpressionInExprEvalContext();
4129 ConsumedEnd = Tok.getLocation();
4130 if (ExplicitExpr.isUsable()) {
4131 CloseParenLoc = Tok.getLocation();
4132 Tracker.consumeClose();
4133 ExplicitSpec =
4134 Actions.ActOnExplicitBoolSpecifier(ExplicitExpr.get());
4135 } else
4136 Tracker.skipToEnd();
4137 } else {
4138 Diag(Tok.getLocation(), diag::warn_cxx20_compat_explicit_bool);
4139 }
4140 }
4141 isInvalid = DS.setFunctionSpecExplicit(ExplicitLoc, PrevSpec, DiagID,
4142 ExplicitSpec, CloseParenLoc);
4143 break;
4144 }
4145 case tok::kw__Noreturn:
4146 if (!getLangOpts().C11)
4147 Diag(Tok, diag::ext_c11_feature) << Tok.getName();
4148 isInvalid = DS.setFunctionSpecNoreturn(Loc, PrevSpec, DiagID);
4149 break;
4150
4151 // alignment-specifier
4152 case tok::kw__Alignas:
4153 if (!getLangOpts().C11)
4154 Diag(Tok, diag::ext_c11_feature) << Tok.getName();
4155 ParseAlignmentSpecifier(DS.getAttributes());
4156 continue;
4157
4158 // friend
4159 case tok::kw_friend:
4160 if (DSContext == DeclSpecContext::DSC_class)
4161 isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID);
4162 else {
4163 PrevSpec = ""; // not actually used by the diagnostic
4164 DiagID = diag::err_friend_invalid_in_context;
4165 isInvalid = true;
4166 }
4167 break;
4168
4169 // Modules
4170 case tok::kw___module_private__:
4171 isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
4172 break;
4173
4174 // constexpr, consteval, constinit specifiers
4175 case tok::kw_constexpr:
4176 isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Constexpr, Loc,
4177 PrevSpec, DiagID);
4178 break;
4179 case tok::kw_consteval:
4180 isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Consteval, Loc,
4181 PrevSpec, DiagID);
4182 break;
4183 case tok::kw_constinit:
4184 isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Constinit, Loc,
4185 PrevSpec, DiagID);
4186 break;
4187
4188 // type-specifier
4189 case tok::kw_short:
4190 isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::Short, Loc, PrevSpec,
4191 DiagID, Policy);
4192 break;
4193 case tok::kw_long:
4194 if (DS.getTypeSpecWidth() != TypeSpecifierWidth::Long)
4195 isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::Long, Loc, PrevSpec,
4196 DiagID, Policy);
4197 else
4198 isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc,
4199 PrevSpec, DiagID, Policy);
4200 break;
4201 case tok::kw___int64:
4202 isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc,
4203 PrevSpec, DiagID, Policy);
4204 break;
4205 case tok::kw_signed:
4206 isInvalid =
4207 DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID);
4208 break;
4209 case tok::kw_unsigned:
4210 isInvalid = DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec,
4211 DiagID);
4212 break;
4213 case tok::kw__Complex:
4214 if (!getLangOpts().C99)
4215 Diag(Tok, diag::ext_c99_feature) << Tok.getName();
4216 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
4217 DiagID);
4218 break;
4219 case tok::kw__Imaginary:
4220 if (!getLangOpts().C99)
4221 Diag(Tok, diag::ext_c99_feature) << Tok.getName();
4222 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
4223 DiagID);
4224 break;
4225 case tok::kw_void:
4226 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
4227 DiagID, Policy);
4228 break;
4229 case tok::kw_char:
4230 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
4231 DiagID, Policy);
4232 break;
4233 case tok::kw_int:
4234 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
4235 DiagID, Policy);
4236 break;
4237 case tok::kw__ExtInt:
4238 case tok::kw__BitInt: {
4239 DiagnoseBitIntUse(Tok);
4240 ExprResult ER = ParseExtIntegerArgument();
4241 if (ER.isInvalid())
4242 continue;
4243 isInvalid = DS.SetBitIntType(Loc, ER.get(), PrevSpec, DiagID, Policy);
4244 ConsumedEnd = PrevTokLocation;
4245 break;
4246 }
4247 case tok::kw___int128:
4248 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec,
4249 DiagID, Policy);
4250 break;
4251 case tok::kw_half:
4252 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
4253 DiagID, Policy);
4254 break;
4255 case tok::kw___bf16:
4256 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec,
4257 DiagID, Policy);
4258 break;
4259 case tok::kw_float:
4260 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
4261 DiagID, Policy);
4262 break;
4263 case tok::kw_double:
4264 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
4265 DiagID, Policy);
4266 break;
4267 case tok::kw__Float16:
4268 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec,
4269 DiagID, Policy);
4270 break;
4271 case tok::kw__Accum:
4272 assert(getLangOpts().FixedPoint &&
4273 "This keyword is only used when fixed point types are enabled "
4274 "with `-ffixed-point`");
4275 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_accum, Loc, PrevSpec, DiagID,
4276 Policy);
4277 break;
4278 case tok::kw__Fract:
4279 assert(getLangOpts().FixedPoint &&
4280 "This keyword is only used when fixed point types are enabled "
4281 "with `-ffixed-point`");
4282 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_fract, Loc, PrevSpec, DiagID,
4283 Policy);
4284 break;
4285 case tok::kw__Sat:
4286 assert(getLangOpts().FixedPoint &&
4287 "This keyword is only used when fixed point types are enabled "
4288 "with `-ffixed-point`");
4289 isInvalid = DS.SetTypeSpecSat(Loc, PrevSpec, DiagID);
4290 break;
4291 case tok::kw___float128:
4292 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec,
4293 DiagID, Policy);
4294 break;
4295 case tok::kw___ibm128:
4296 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_ibm128, Loc, PrevSpec,
4297 DiagID, Policy);
4298 break;
4299 case tok::kw_wchar_t:
4300 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
4301 DiagID, Policy);
4302 break;
4303 case tok::kw_char8_t:
4304 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec,
4305 DiagID, Policy);
4306 break;
4307 case tok::kw_char16_t:
4308 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
4309 DiagID, Policy);
4310 break;
4311 case tok::kw_char32_t:
4312 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
4313 DiagID, Policy);
4314 break;
4315 case tok::kw_bool:
4316 if (getLangOpts().C23)
4317 Diag(Tok, diag::warn_c23_compat_keyword) << Tok.getName();
4318 [[fallthrough]];
4319 case tok::kw__Bool:
4320 if (Tok.is(tok::kw__Bool) && !getLangOpts().C99)
4321 Diag(Tok, diag::ext_c99_feature) << Tok.getName();
4322
4323 if (Tok.is(tok::kw_bool) &&
4324 DS.getTypeSpecType() != DeclSpec::TST_unspecified &&
4325 DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
4326 PrevSpec = ""; // Not used by the diagnostic.
4327 DiagID = diag::err_bool_redeclaration;
4328 // For better error recovery.
4329 Tok.setKind(tok::identifier);
4330 isInvalid = true;
4331 } else {
4332 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
4333 DiagID, Policy);
4334 }
4335 break;
4336 case tok::kw__Decimal32:
4337 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
4338 DiagID, Policy);
4339 break;
4340 case tok::kw__Decimal64:
4341 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
4342 DiagID, Policy);
4343 break;
4344 case tok::kw__Decimal128:
4345 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
4346 DiagID, Policy);
4347 break;
4348 case tok::kw___vector:
4349 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
4350 break;
4351 case tok::kw___pixel:
4352 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
4353 break;
4354 case tok::kw___bool:
4355 isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
4356 break;
4357 case tok::kw_pipe:
4358 if (!getLangOpts().OpenCL ||
4359 getLangOpts().getOpenCLCompatibleVersion() < 200) {
4360 // OpenCL 2.0 and later define this keyword. OpenCL 1.2 and earlier
4361 // should support the "pipe" word as identifier.
4362 Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
4363 Tok.setKind(tok::identifier);
4364 goto DoneWithDeclSpec;
4365 } else if (!getLangOpts().OpenCLPipes) {
4366 DiagID = diag::err_opencl_unknown_type_specifier;
4367 PrevSpec = Tok.getIdentifierInfo()->getNameStart();
4368 isInvalid = true;
4369 } else
4370 isInvalid = DS.SetTypePipe(true, Loc, PrevSpec, DiagID, Policy);
4371 break;
4372 // We only need to enumerate each image type once.
4373 #define IMAGE_READ_WRITE_TYPE(Type, Id, Ext)
4374 #define IMAGE_WRITE_TYPE(Type, Id, Ext)
4375 #define IMAGE_READ_TYPE(ImgType, Id, Ext) \
4376 case tok::kw_##ImgType##_t: \
4377 if (!handleOpenCLImageKW(Ext, DeclSpec::TST_##ImgType##_t)) \
4378 goto DoneWithDeclSpec; \
4379 break;
4380 #include "clang/Basic/OpenCLImageTypes.def"
4381 case tok::kw___unknown_anytype:
4382 isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
4383 PrevSpec, DiagID, Policy);
4384 break;
4385
4386 // class-specifier:
4387 case tok::kw_class:
4388 case tok::kw_struct:
4389 case tok::kw___interface:
4390 case tok::kw_union: {
4391 tok::TokenKind Kind = Tok.getKind();
4392 ConsumeToken();
4393
4394 // These are attributes following class specifiers.
4395 // To produce better diagnostic, we parse them when
4396 // parsing class specifier.
4397 ParsedAttributes Attributes(AttrFactory);
4398 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS,
4399 EnteringContext, DSContext, Attributes);
4400
4401 // If there are attributes following class specifier,
4402 // take them over and handle them here.
4403 if (!Attributes.empty()) {
4404 AttrsLastTime = true;
4405 attrs.takeAllFrom(Attributes);
4406 }
4407 continue;
4408 }
4409
4410 // enum-specifier:
4411 case tok::kw_enum:
4412 ConsumeToken();
4413 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSContext);
4414 continue;
4415
4416 // cv-qualifier:
4417 case tok::kw_const:
4418 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
4419 getLangOpts());
4420 break;
4421 case tok::kw_volatile:
4422 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
4423 getLangOpts());
4424 break;
4425 case tok::kw_restrict:
4426 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
4427 getLangOpts());
4428 break;
4429
4430 // C++ typename-specifier:
4431 case tok::kw_typename:
4432 if (TryAnnotateTypeOrScopeToken()) {
4433 DS.SetTypeSpecError();
4434 goto DoneWithDeclSpec;
4435 }
4436 if (!Tok.is(tok::kw_typename))
4437 continue;
4438 break;
4439
4440 // C23/GNU typeof support.
4441 case tok::kw_typeof:
4442 case tok::kw_typeof_unqual:
4443 ParseTypeofSpecifier(DS);
4444 continue;
4445
4446 case tok::annot_decltype:
4447 ParseDecltypeSpecifier(DS);
4448 continue;
4449
4450 case tok::annot_pragma_pack:
4451 HandlePragmaPack();
4452 continue;
4453
4454 case tok::annot_pragma_ms_pragma:
4455 HandlePragmaMSPragma();
4456 continue;
4457
4458 case tok::annot_pragma_ms_vtordisp:
4459 HandlePragmaMSVtorDisp();
4460 continue;
4461
4462 case tok::annot_pragma_ms_pointers_to_members:
4463 HandlePragmaMSPointersToMembers();
4464 continue;
4465
4466 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
4467 #include "clang/Basic/TransformTypeTraits.def"
4468 // HACK: libstdc++ already uses '__remove_cv' as an alias template so we
4469 // work around this by expecting all transform type traits to be suffixed
4470 // with '('. They're an identifier otherwise.
4471 if (!MaybeParseTypeTransformTypeSpecifier(DS))
4472 goto ParseIdentifier;
4473 continue;
4474
4475 case tok::kw__Atomic:
4476 // C11 6.7.2.4/4:
4477 // If the _Atomic keyword is immediately followed by a left parenthesis,
4478 // it is interpreted as a type specifier (with a type name), not as a
4479 // type qualifier.
4480 if (!getLangOpts().C11)
4481 Diag(Tok, diag::ext_c11_feature) << Tok.getName();
4482
4483 if (NextToken().is(tok::l_paren)) {
4484 ParseAtomicSpecifier(DS);
4485 continue;
4486 }
4487 isInvalid = DS.SetTypeQual(DeclSpec::TQ_atomic, Loc, PrevSpec, DiagID,
4488 getLangOpts());
4489 break;
4490
4491 // OpenCL address space qualifiers:
4492 case tok::kw___generic:
4493 // generic address space is introduced only in OpenCL v2.0
4494 // see OpenCL C Spec v2.0 s6.5.5
4495 // OpenCL v3.0 introduces __opencl_c_generic_address_space
4496 // feature macro to indicate if generic address space is supported
4497 if (!Actions.getLangOpts().OpenCLGenericAddressSpace) {
4498 DiagID = diag::err_opencl_unknown_type_specifier;
4499 PrevSpec = Tok.getIdentifierInfo()->getNameStart();
4500 isInvalid = true;
4501 break;
4502 }
4503 [[fallthrough]];
4504 case tok::kw_private:
4505 // It's fine (but redundant) to check this for __generic on the
4506 // fallthrough path; we only form the __generic token in OpenCL mode.
4507 if (!getLangOpts().OpenCL)
4508 goto DoneWithDeclSpec;
4509 [[fallthrough]];
4510 case tok::kw___private:
4511 case tok::kw___global:
4512 case tok::kw___local:
4513 case tok::kw___constant:
4514 // OpenCL access qualifiers:
4515 case tok::kw___read_only:
4516 case tok::kw___write_only:
4517 case tok::kw___read_write:
4518 ParseOpenCLQualifiers(DS.getAttributes());
4519 break;
4520
4521 case tok::kw_groupshared:
4522 case tok::kw_in:
4523 case tok::kw_inout:
4524 case tok::kw_out:
4525 // NOTE: ParseHLSLQualifiers will consume the qualifier token.
4526 ParseHLSLQualifiers(DS.getAttributes());
4527 continue;
4528
4529 case tok::less:
4530 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
4531 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous,
4532 // but we support it.
4533 if (DS.hasTypeSpecifier() || !getLangOpts().ObjC)
4534 goto DoneWithDeclSpec;
4535
4536 SourceLocation StartLoc = Tok.getLocation();
4537 SourceLocation EndLoc;
4538 TypeResult Type = parseObjCProtocolQualifierType(EndLoc);
4539 if (Type.isUsable()) {
4540 if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc, StartLoc,
4541 PrevSpec, DiagID, Type.get(),
4542 Actions.getASTContext().getPrintingPolicy()))
4543 Diag(StartLoc, DiagID) << PrevSpec;
4544
4545 DS.SetRangeEnd(EndLoc);
4546 } else {
4547 DS.SetTypeSpecError();
4548 }
4549
4550 // Need to support trailing type qualifiers (e.g. "id<p> const").
4551 // If a type specifier follows, it will be diagnosed elsewhere.
4552 continue;
4553 }
4554
4555 DS.SetRangeEnd(ConsumedEnd.isValid() ? ConsumedEnd : Tok.getLocation());
4556
4557 // If the specifier wasn't legal, issue a diagnostic.
4558 if (isInvalid) {
4559 assert(PrevSpec && "Method did not return previous specifier!");
4560 assert(DiagID);
4561
4562 if (DiagID == diag::ext_duplicate_declspec ||
4563 DiagID == diag::ext_warn_duplicate_declspec ||
4564 DiagID == diag::err_duplicate_declspec)
4565 Diag(Loc, DiagID) << PrevSpec
4566 << FixItHint::CreateRemoval(
4567 SourceRange(Loc, DS.getEndLoc()));
4568 else if (DiagID == diag::err_opencl_unknown_type_specifier) {
4569 Diag(Loc, DiagID) << getLangOpts().getOpenCLVersionString() << PrevSpec
4570 << isStorageClass;
4571 } else
4572 Diag(Loc, DiagID) << PrevSpec;
4573 }
4574
4575 if (DiagID != diag::err_bool_redeclaration && ConsumedEnd.isInvalid())
4576 // After an error the next token can be an annotation token.
4577 ConsumeAnyToken();
4578
4579 AttrsLastTime = false;
4580 }
4581 }
4582
4583 /// ParseStructDeclaration - Parse a struct declaration without the terminating
4584 /// semicolon.
4585 ///
4586 /// Note that a struct declaration refers to a declaration in a struct,
4587 /// not to the declaration of a struct.
4588 ///
4589 /// struct-declaration:
4590 /// [C23] attributes-specifier-seq[opt]
4591 /// specifier-qualifier-list struct-declarator-list
4592 /// [GNU] __extension__ struct-declaration
4593 /// [GNU] specifier-qualifier-list
4594 /// struct-declarator-list:
4595 /// struct-declarator
4596 /// struct-declarator-list ',' struct-declarator
4597 /// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator
4598 /// struct-declarator:
4599 /// declarator
4600 /// [GNU] declarator attributes[opt]
4601 /// declarator[opt] ':' constant-expression
4602 /// [GNU] declarator[opt] ':' constant-expression attributes[opt]
4603 ///
ParseStructDeclaration(ParsingDeclSpec & DS,llvm::function_ref<void (ParsingFieldDeclarator &)> FieldsCallback)4604 void Parser::ParseStructDeclaration(
4605 ParsingDeclSpec &DS,
4606 llvm::function_ref<void(ParsingFieldDeclarator &)> FieldsCallback) {
4607
4608 if (Tok.is(tok::kw___extension__)) {
4609 // __extension__ silences extension warnings in the subexpression.
4610 ExtensionRAIIObject O(Diags); // Use RAII to do this.
4611 ConsumeToken();
4612 return ParseStructDeclaration(DS, FieldsCallback);
4613 }
4614
4615 // Parse leading attributes.
4616 ParsedAttributes Attrs(AttrFactory);
4617 MaybeParseCXX11Attributes(Attrs);
4618
4619 // Parse the common specifier-qualifiers-list piece.
4620 ParseSpecifierQualifierList(DS);
4621
4622 // If there are no declarators, this is a free-standing declaration
4623 // specifier. Let the actions module cope with it.
4624 if (Tok.is(tok::semi)) {
4625 // C23 6.7.2.1p9 : "The optional attribute specifier sequence in a
4626 // member declaration appertains to each of the members declared by the
4627 // member declarator list; it shall not appear if the optional member
4628 // declarator list is omitted."
4629 ProhibitAttributes(Attrs);
4630 RecordDecl *AnonRecord = nullptr;
4631 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
4632 getCurScope(), AS_none, DS, ParsedAttributesView::none(), AnonRecord);
4633 assert(!AnonRecord && "Did not expect anonymous struct or union here");
4634 DS.complete(TheDecl);
4635 return;
4636 }
4637
4638 // Read struct-declarators until we find the semicolon.
4639 bool FirstDeclarator = true;
4640 SourceLocation CommaLoc;
4641 while (true) {
4642 ParsingFieldDeclarator DeclaratorInfo(*this, DS, Attrs);
4643 DeclaratorInfo.D.setCommaLoc(CommaLoc);
4644
4645 // Attributes are only allowed here on successive declarators.
4646 if (!FirstDeclarator) {
4647 // However, this does not apply for [[]] attributes (which could show up
4648 // before or after the __attribute__ attributes).
4649 DiagnoseAndSkipCXX11Attributes();
4650 MaybeParseGNUAttributes(DeclaratorInfo.D);
4651 DiagnoseAndSkipCXX11Attributes();
4652 }
4653
4654 /// struct-declarator: declarator
4655 /// struct-declarator: declarator[opt] ':' constant-expression
4656 if (Tok.isNot(tok::colon)) {
4657 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
4658 ColonProtectionRAIIObject X(*this);
4659 ParseDeclarator(DeclaratorInfo.D);
4660 } else
4661 DeclaratorInfo.D.SetIdentifier(nullptr, Tok.getLocation());
4662
4663 if (TryConsumeToken(tok::colon)) {
4664 ExprResult Res(ParseConstantExpression());
4665 if (Res.isInvalid())
4666 SkipUntil(tok::semi, StopBeforeMatch);
4667 else
4668 DeclaratorInfo.BitfieldSize = Res.get();
4669 }
4670
4671 // If attributes exist after the declarator, parse them.
4672 MaybeParseGNUAttributes(DeclaratorInfo.D);
4673
4674 // We're done with this declarator; invoke the callback.
4675 FieldsCallback(DeclaratorInfo);
4676
4677 // If we don't have a comma, it is either the end of the list (a ';')
4678 // or an error, bail out.
4679 if (!TryConsumeToken(tok::comma, CommaLoc))
4680 return;
4681
4682 FirstDeclarator = false;
4683 }
4684 }
4685
4686 /// ParseStructUnionBody
4687 /// struct-contents:
4688 /// struct-declaration-list
4689 /// [EXT] empty
4690 /// [GNU] "struct-declaration-list" without terminating ';'
4691 /// struct-declaration-list:
4692 /// struct-declaration
4693 /// struct-declaration-list struct-declaration
4694 /// [OBC] '@' 'defs' '(' class-name ')'
4695 ///
ParseStructUnionBody(SourceLocation RecordLoc,DeclSpec::TST TagType,RecordDecl * TagDecl)4696 void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
4697 DeclSpec::TST TagType, RecordDecl *TagDecl) {
4698 PrettyDeclStackTraceEntry CrashInfo(Actions.Context, TagDecl, RecordLoc,
4699 "parsing struct/union body");
4700 assert(!getLangOpts().CPlusPlus && "C++ declarations not supported");
4701
4702 BalancedDelimiterTracker T(*this, tok::l_brace);
4703 if (T.consumeOpen())
4704 return;
4705
4706 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
4707 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
4708
4709 // While we still have something to read, read the declarations in the struct.
4710 while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
4711 Tok.isNot(tok::eof)) {
4712 // Each iteration of this loop reads one struct-declaration.
4713
4714 // Check for extraneous top-level semicolon.
4715 if (Tok.is(tok::semi)) {
4716 ConsumeExtraSemi(InsideStruct, TagType);
4717 continue;
4718 }
4719
4720 // Parse _Static_assert declaration.
4721 if (Tok.isOneOf(tok::kw__Static_assert, tok::kw_static_assert)) {
4722 SourceLocation DeclEnd;
4723 ParseStaticAssertDeclaration(DeclEnd);
4724 continue;
4725 }
4726
4727 if (Tok.is(tok::annot_pragma_pack)) {
4728 HandlePragmaPack();
4729 continue;
4730 }
4731
4732 if (Tok.is(tok::annot_pragma_align)) {
4733 HandlePragmaAlign();
4734 continue;
4735 }
4736
4737 if (Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp)) {
4738 // Result can be ignored, because it must be always empty.
4739 AccessSpecifier AS = AS_none;
4740 ParsedAttributes Attrs(AttrFactory);
4741 (void)ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs);
4742 continue;
4743 }
4744
4745 if (Tok.is(tok::annot_pragma_openacc)) {
4746 ParseOpenACCDirectiveDecl();
4747 continue;
4748 }
4749
4750 if (tok::isPragmaAnnotation(Tok.getKind())) {
4751 Diag(Tok.getLocation(), diag::err_pragma_misplaced_in_decl)
4752 << DeclSpec::getSpecifierName(
4753 TagType, Actions.getASTContext().getPrintingPolicy());
4754 ConsumeAnnotationToken();
4755 continue;
4756 }
4757
4758 if (!Tok.is(tok::at)) {
4759 auto CFieldCallback = [&](ParsingFieldDeclarator &FD) {
4760 // Install the declarator into the current TagDecl.
4761 Decl *Field =
4762 Actions.ActOnField(getCurScope(), TagDecl,
4763 FD.D.getDeclSpec().getSourceRange().getBegin(),
4764 FD.D, FD.BitfieldSize);
4765 FD.complete(Field);
4766 };
4767
4768 // Parse all the comma separated declarators.
4769 ParsingDeclSpec DS(*this);
4770 ParseStructDeclaration(DS, CFieldCallback);
4771 } else { // Handle @defs
4772 ConsumeToken();
4773 if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
4774 Diag(Tok, diag::err_unexpected_at);
4775 SkipUntil(tok::semi);
4776 continue;
4777 }
4778 ConsumeToken();
4779 ExpectAndConsume(tok::l_paren);
4780 if (!Tok.is(tok::identifier)) {
4781 Diag(Tok, diag::err_expected) << tok::identifier;
4782 SkipUntil(tok::semi);
4783 continue;
4784 }
4785 SmallVector<Decl *, 16> Fields;
4786 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
4787 Tok.getIdentifierInfo(), Fields);
4788 ConsumeToken();
4789 ExpectAndConsume(tok::r_paren);
4790 }
4791
4792 if (TryConsumeToken(tok::semi))
4793 continue;
4794
4795 if (Tok.is(tok::r_brace)) {
4796 ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
4797 break;
4798 }
4799
4800 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
4801 // Skip to end of block or statement to avoid ext-warning on extra ';'.
4802 SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
4803 // If we stopped at a ';', eat it.
4804 TryConsumeToken(tok::semi);
4805 }
4806
4807 T.consumeClose();
4808
4809 ParsedAttributes attrs(AttrFactory);
4810 // If attributes exist after struct contents, parse them.
4811 MaybeParseGNUAttributes(attrs);
4812
4813 SmallVector<Decl *, 32> FieldDecls(TagDecl->fields());
4814
4815 Actions.ActOnFields(getCurScope(), RecordLoc, TagDecl, FieldDecls,
4816 T.getOpenLocation(), T.getCloseLocation(), attrs);
4817 StructScope.Exit();
4818 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, T.getRange());
4819 }
4820
4821 /// ParseEnumSpecifier
4822 /// enum-specifier: [C99 6.7.2.2]
4823 /// 'enum' identifier[opt] '{' enumerator-list '}'
4824 ///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
4825 /// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
4826 /// '}' attributes[opt]
4827 /// [MS] 'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt]
4828 /// '}'
4829 /// 'enum' identifier
4830 /// [GNU] 'enum' attributes[opt] identifier
4831 ///
4832 /// [C++11] enum-head '{' enumerator-list[opt] '}'
4833 /// [C++11] enum-head '{' enumerator-list ',' '}'
4834 ///
4835 /// enum-head: [C++11]
4836 /// enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]
4837 /// enum-key attribute-specifier-seq[opt] nested-name-specifier
4838 /// identifier enum-base[opt]
4839 ///
4840 /// enum-key: [C++11]
4841 /// 'enum'
4842 /// 'enum' 'class'
4843 /// 'enum' 'struct'
4844 ///
4845 /// enum-base: [C++11]
4846 /// ':' type-specifier-seq
4847 ///
4848 /// [C++] elaborated-type-specifier:
4849 /// [C++] 'enum' nested-name-specifier[opt] identifier
4850 ///
ParseEnumSpecifier(SourceLocation StartLoc,DeclSpec & DS,const ParsedTemplateInfo & TemplateInfo,AccessSpecifier AS,DeclSpecContext DSC)4851 void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
4852 const ParsedTemplateInfo &TemplateInfo,
4853 AccessSpecifier AS, DeclSpecContext DSC) {
4854 // Parse the tag portion of this.
4855 if (Tok.is(tok::code_completion)) {
4856 // Code completion for an enum name.
4857 cutOffParsing();
4858 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
4859 DS.SetTypeSpecError(); // Needed by ActOnUsingDeclaration.
4860 return;
4861 }
4862
4863 // If attributes exist after tag, parse them.
4864 ParsedAttributes attrs(AttrFactory);
4865 MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs);
4866
4867 SourceLocation ScopedEnumKWLoc;
4868 bool IsScopedUsingClassTag = false;
4869
4870 // In C++11, recognize 'enum class' and 'enum struct'.
4871 if (Tok.isOneOf(tok::kw_class, tok::kw_struct) && getLangOpts().CPlusPlus) {
4872 Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_scoped_enum
4873 : diag::ext_scoped_enum);
4874 IsScopedUsingClassTag = Tok.is(tok::kw_class);
4875 ScopedEnumKWLoc = ConsumeToken();
4876
4877 // Attributes are not allowed between these keywords. Diagnose,
4878 // but then just treat them like they appeared in the right place.
4879 ProhibitAttributes(attrs);
4880
4881 // They are allowed afterwards, though.
4882 MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs);
4883 }
4884
4885 // C++11 [temp.explicit]p12:
4886 // The usual access controls do not apply to names used to specify
4887 // explicit instantiations.
4888 // We extend this to also cover explicit specializations. Note that
4889 // we don't suppress if this turns out to be an elaborated type
4890 // specifier.
4891 bool shouldDelayDiagsInTag =
4892 (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
4893 TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
4894 SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
4895
4896 // Determine whether this declaration is permitted to have an enum-base.
4897 AllowDefiningTypeSpec AllowEnumSpecifier =
4898 isDefiningTypeSpecifierContext(DSC, getLangOpts().CPlusPlus);
4899 bool CanBeOpaqueEnumDeclaration =
4900 DS.isEmpty() && isOpaqueEnumDeclarationContext(DSC);
4901 bool CanHaveEnumBase = (getLangOpts().CPlusPlus11 || getLangOpts().ObjC ||
4902 getLangOpts().MicrosoftExt) &&
4903 (AllowEnumSpecifier == AllowDefiningTypeSpec::Yes ||
4904 CanBeOpaqueEnumDeclaration);
4905
4906 CXXScopeSpec &SS = DS.getTypeSpecScope();
4907 if (getLangOpts().CPlusPlus) {
4908 // "enum foo : bar;" is not a potential typo for "enum foo::bar;".
4909 ColonProtectionRAIIObject X(*this);
4910
4911 CXXScopeSpec Spec;
4912 if (ParseOptionalCXXScopeSpecifier(Spec, /*ObjectType=*/nullptr,
4913 /*ObjectHasErrors=*/false,
4914 /*EnteringContext=*/true))
4915 return;
4916
4917 if (Spec.isSet() && Tok.isNot(tok::identifier)) {
4918 Diag(Tok, diag::err_expected) << tok::identifier;
4919 DS.SetTypeSpecError();
4920 if (Tok.isNot(tok::l_brace)) {
4921 // Has no name and is not a definition.
4922 // Skip the rest of this declarator, up until the comma or semicolon.
4923 SkipUntil(tok::comma, StopAtSemi);
4924 return;
4925 }
4926 }
4927
4928 SS = Spec;
4929 }
4930
4931 // Must have either 'enum name' or 'enum {...}' or (rarely) 'enum : T { ... }'.
4932 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
4933 Tok.isNot(tok::colon)) {
4934 Diag(Tok, diag::err_expected_either) << tok::identifier << tok::l_brace;
4935
4936 DS.SetTypeSpecError();
4937 // Skip the rest of this declarator, up until the comma or semicolon.
4938 SkipUntil(tok::comma, StopAtSemi);
4939 return;
4940 }
4941
4942 // If an identifier is present, consume and remember it.
4943 IdentifierInfo *Name = nullptr;
4944 SourceLocation NameLoc;
4945 if (Tok.is(tok::identifier)) {
4946 Name = Tok.getIdentifierInfo();
4947 NameLoc = ConsumeToken();
4948 }
4949
4950 if (!Name && ScopedEnumKWLoc.isValid()) {
4951 // C++0x 7.2p2: The optional identifier shall not be omitted in the
4952 // declaration of a scoped enumeration.
4953 Diag(Tok, diag::err_scoped_enum_missing_identifier);
4954 ScopedEnumKWLoc = SourceLocation();
4955 IsScopedUsingClassTag = false;
4956 }
4957
4958 // Okay, end the suppression area. We'll decide whether to emit the
4959 // diagnostics in a second.
4960 if (shouldDelayDiagsInTag)
4961 diagsFromTag.done();
4962
4963 TypeResult BaseType;
4964 SourceRange BaseRange;
4965
4966 bool CanBeBitfield =
4967 getCurScope()->isClassScope() && ScopedEnumKWLoc.isInvalid() && Name;
4968
4969 // Parse the fixed underlying type.
4970 if (Tok.is(tok::colon)) {
4971 // This might be an enum-base or part of some unrelated enclosing context.
4972 //
4973 // 'enum E : base' is permitted in two circumstances:
4974 //
4975 // 1) As a defining-type-specifier, when followed by '{'.
4976 // 2) As the sole constituent of a complete declaration -- when DS is empty
4977 // and the next token is ';'.
4978 //
4979 // The restriction to defining-type-specifiers is important to allow parsing
4980 // a ? new enum E : int{}
4981 // _Generic(a, enum E : int{})
4982 // properly.
4983 //
4984 // One additional consideration applies:
4985 //
4986 // C++ [dcl.enum]p1:
4987 // A ':' following "enum nested-name-specifier[opt] identifier" within
4988 // the decl-specifier-seq of a member-declaration is parsed as part of
4989 // an enum-base.
4990 //
4991 // Other language modes supporting enumerations with fixed underlying types
4992 // do not have clear rules on this, so we disambiguate to determine whether
4993 // the tokens form a bit-field width or an enum-base.
4994
4995 if (CanBeBitfield && !isEnumBase(CanBeOpaqueEnumDeclaration)) {
4996 // Outside C++11, do not interpret the tokens as an enum-base if they do
4997 // not make sense as one. In C++11, it's an error if this happens.
4998 if (getLangOpts().CPlusPlus11)
4999 Diag(Tok.getLocation(), diag::err_anonymous_enum_bitfield);
5000 } else if (CanHaveEnumBase || !ColonIsSacred) {
5001 SourceLocation ColonLoc = ConsumeToken();
5002
5003 // Parse a type-specifier-seq as a type. We can't just ParseTypeName here,
5004 // because under -fms-extensions,
5005 // enum E : int *p;
5006 // declares 'enum E : int; E *p;' not 'enum E : int*; E p;'.
5007 DeclSpec DS(AttrFactory);
5008 // enum-base is not assumed to be a type and therefore requires the
5009 // typename keyword [p0634r3].
5010 ParseSpecifierQualifierList(DS, ImplicitTypenameContext::No, AS,
5011 DeclSpecContext::DSC_type_specifier);
5012 Declarator DeclaratorInfo(DS, ParsedAttributesView::none(),
5013 DeclaratorContext::TypeName);
5014 BaseType = Actions.ActOnTypeName(DeclaratorInfo);
5015
5016 BaseRange = SourceRange(ColonLoc, DeclaratorInfo.getSourceRange().getEnd());
5017
5018 if (!getLangOpts().ObjC && !getLangOpts().C23) {
5019 if (getLangOpts().CPlusPlus11)
5020 Diag(ColonLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type)
5021 << BaseRange;
5022 else if (getLangOpts().CPlusPlus)
5023 Diag(ColonLoc, diag::ext_cxx11_enum_fixed_underlying_type)
5024 << BaseRange;
5025 else if (getLangOpts().MicrosoftExt)
5026 Diag(ColonLoc, diag::ext_ms_c_enum_fixed_underlying_type)
5027 << BaseRange;
5028 else
5029 Diag(ColonLoc, diag::ext_clang_c_enum_fixed_underlying_type)
5030 << BaseRange;
5031 }
5032 }
5033 }
5034
5035 // There are four options here. If we have 'friend enum foo;' then this is a
5036 // friend declaration, and cannot have an accompanying definition. If we have
5037 // 'enum foo;', then this is a forward declaration. If we have
5038 // 'enum foo {...' then this is a definition. Otherwise we have something
5039 // like 'enum foo xyz', a reference.
5040 //
5041 // This is needed to handle stuff like this right (C99 6.7.2.3p11):
5042 // enum foo {..}; void bar() { enum foo; } <- new foo in bar.
5043 // enum foo {..}; void bar() { enum foo x; } <- use of old foo.
5044 //
5045 Sema::TagUseKind TUK;
5046 if (AllowEnumSpecifier == AllowDefiningTypeSpec::No)
5047 TUK = Sema::TUK_Reference;
5048 else if (Tok.is(tok::l_brace)) {
5049 if (DS.isFriendSpecified()) {
5050 Diag(Tok.getLocation(), diag::err_friend_decl_defines_type)
5051 << SourceRange(DS.getFriendSpecLoc());
5052 ConsumeBrace();
5053 SkipUntil(tok::r_brace, StopAtSemi);
5054 // Discard any other definition-only pieces.
5055 attrs.clear();
5056 ScopedEnumKWLoc = SourceLocation();
5057 IsScopedUsingClassTag = false;
5058 BaseType = TypeResult();
5059 TUK = Sema::TUK_Friend;
5060 } else {
5061 TUK = Sema::TUK_Definition;
5062 }
5063 } else if (!isTypeSpecifier(DSC) &&
5064 (Tok.is(tok::semi) ||
5065 (Tok.isAtStartOfLine() &&
5066 !isValidAfterTypeSpecifier(CanBeBitfield)))) {
5067 // An opaque-enum-declaration is required to be standalone (no preceding or
5068 // following tokens in the declaration). Sema enforces this separately by
5069 // diagnosing anything else in the DeclSpec.
5070 TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;
5071 if (Tok.isNot(tok::semi)) {
5072 // A semicolon was missing after this declaration. Diagnose and recover.
5073 ExpectAndConsume(tok::semi, diag::err_expected_after, "enum");
5074 PP.EnterToken(Tok, /*IsReinject=*/true);
5075 Tok.setKind(tok::semi);
5076 }
5077 } else {
5078 TUK = Sema::TUK_Reference;
5079 }
5080
5081 bool IsElaboratedTypeSpecifier =
5082 TUK == Sema::TUK_Reference || TUK == Sema::TUK_Friend;
5083
5084 // If this is an elaborated type specifier nested in a larger declaration,
5085 // and we delayed diagnostics before, just merge them into the current pool.
5086 if (TUK == Sema::TUK_Reference && shouldDelayDiagsInTag) {
5087 diagsFromTag.redelay();
5088 }
5089
5090 MultiTemplateParamsArg TParams;
5091 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
5092 TUK != Sema::TUK_Reference) {
5093 if (!getLangOpts().CPlusPlus11 || !SS.isSet()) {
5094 // Skip the rest of this declarator, up until the comma or semicolon.
5095 Diag(Tok, diag::err_enum_template);
5096 SkipUntil(tok::comma, StopAtSemi);
5097 return;
5098 }
5099
5100 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
5101 // Enumerations can't be explicitly instantiated.
5102 DS.SetTypeSpecError();
5103 Diag(StartLoc, diag::err_explicit_instantiation_enum);
5104 return;
5105 }
5106
5107 assert(TemplateInfo.TemplateParams && "no template parameters");
5108 TParams = MultiTemplateParamsArg(TemplateInfo.TemplateParams->data(),
5109 TemplateInfo.TemplateParams->size());
5110 SS.setTemplateParamLists(TParams);
5111 }
5112
5113 if (!Name && TUK != Sema::TUK_Definition) {
5114 Diag(Tok, diag::err_enumerator_unnamed_no_def);
5115
5116 DS.SetTypeSpecError();
5117 // Skip the rest of this declarator, up until the comma or semicolon.
5118 SkipUntil(tok::comma, StopAtSemi);
5119 return;
5120 }
5121
5122 // An elaborated-type-specifier has a much more constrained grammar:
5123 //
5124 // 'enum' nested-name-specifier[opt] identifier
5125 //
5126 // If we parsed any other bits, reject them now.
5127 //
5128 // MSVC and (for now at least) Objective-C permit a full enum-specifier
5129 // or opaque-enum-declaration anywhere.
5130 if (IsElaboratedTypeSpecifier && !getLangOpts().MicrosoftExt &&
5131 !getLangOpts().ObjC) {
5132 ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
5133 diag::err_keyword_not_allowed,
5134 /*DiagnoseEmptyAttrs=*/true);
5135 if (BaseType.isUsable())
5136 Diag(BaseRange.getBegin(), diag::ext_enum_base_in_type_specifier)
5137 << (AllowEnumSpecifier == AllowDefiningTypeSpec::Yes) << BaseRange;
5138 else if (ScopedEnumKWLoc.isValid())
5139 Diag(ScopedEnumKWLoc, diag::ext_elaborated_enum_class)
5140 << FixItHint::CreateRemoval(ScopedEnumKWLoc) << IsScopedUsingClassTag;
5141 }
5142
5143 stripTypeAttributesOffDeclSpec(attrs, DS, TUK);
5144
5145 Sema::SkipBodyInfo SkipBody;
5146 if (!Name && TUK == Sema::TUK_Definition && Tok.is(tok::l_brace) &&
5147 NextToken().is(tok::identifier))
5148 SkipBody = Actions.shouldSkipAnonEnumBody(getCurScope(),
5149 NextToken().getIdentifierInfo(),
5150 NextToken().getLocation());
5151
5152 bool Owned = false;
5153 bool IsDependent = false;
5154 const char *PrevSpec = nullptr;
5155 unsigned DiagID;
5156 Decl *TagDecl =
5157 Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK, StartLoc, SS,
5158 Name, NameLoc, attrs, AS, DS.getModulePrivateSpecLoc(),
5159 TParams, Owned, IsDependent, ScopedEnumKWLoc,
5160 IsScopedUsingClassTag,
5161 BaseType, DSC == DeclSpecContext::DSC_type_specifier,
5162 DSC == DeclSpecContext::DSC_template_param ||
5163 DSC == DeclSpecContext::DSC_template_type_arg,
5164 OffsetOfState, &SkipBody).get();
5165
5166 if (SkipBody.ShouldSkip) {
5167 assert(TUK == Sema::TUK_Definition && "can only skip a definition");
5168
5169 BalancedDelimiterTracker T(*this, tok::l_brace);
5170 T.consumeOpen();
5171 T.skipToEnd();
5172
5173 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
5174 NameLoc.isValid() ? NameLoc : StartLoc,
5175 PrevSpec, DiagID, TagDecl, Owned,
5176 Actions.getASTContext().getPrintingPolicy()))
5177 Diag(StartLoc, DiagID) << PrevSpec;
5178 return;
5179 }
5180
5181 if (IsDependent) {
5182 // This enum has a dependent nested-name-specifier. Handle it as a
5183 // dependent tag.
5184 if (!Name) {
5185 DS.SetTypeSpecError();
5186 Diag(Tok, diag::err_expected_type_name_after_typename);
5187 return;
5188 }
5189
5190 TypeResult Type = Actions.ActOnDependentTag(
5191 getCurScope(), DeclSpec::TST_enum, TUK, SS, Name, StartLoc, NameLoc);
5192 if (Type.isInvalid()) {
5193 DS.SetTypeSpecError();
5194 return;
5195 }
5196
5197 if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
5198 NameLoc.isValid() ? NameLoc : StartLoc,
5199 PrevSpec, DiagID, Type.get(),
5200 Actions.getASTContext().getPrintingPolicy()))
5201 Diag(StartLoc, DiagID) << PrevSpec;
5202
5203 return;
5204 }
5205
5206 if (!TagDecl) {
5207 // The action failed to produce an enumeration tag. If this is a
5208 // definition, consume the entire definition.
5209 if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) {
5210 ConsumeBrace();
5211 SkipUntil(tok::r_brace, StopAtSemi);
5212 }
5213
5214 DS.SetTypeSpecError();
5215 return;
5216 }
5217
5218 if (Tok.is(tok::l_brace) && TUK == Sema::TUK_Definition) {
5219 Decl *D = SkipBody.CheckSameAsPrevious ? SkipBody.New : TagDecl;
5220 ParseEnumBody(StartLoc, D);
5221 if (SkipBody.CheckSameAsPrevious &&
5222 !Actions.ActOnDuplicateDefinition(TagDecl, SkipBody)) {
5223 DS.SetTypeSpecError();
5224 return;
5225 }
5226 }
5227
5228 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
5229 NameLoc.isValid() ? NameLoc : StartLoc,
5230 PrevSpec, DiagID, TagDecl, Owned,
5231 Actions.getASTContext().getPrintingPolicy()))
5232 Diag(StartLoc, DiagID) << PrevSpec;
5233 }
5234
5235 /// ParseEnumBody - Parse a {} enclosed enumerator-list.
5236 /// enumerator-list:
5237 /// enumerator
5238 /// enumerator-list ',' enumerator
5239 /// enumerator:
5240 /// enumeration-constant attributes[opt]
5241 /// enumeration-constant attributes[opt] '=' constant-expression
5242 /// enumeration-constant:
5243 /// identifier
5244 ///
ParseEnumBody(SourceLocation StartLoc,Decl * EnumDecl)5245 void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
5246 // Enter the scope of the enum body and start the definition.
5247 ParseScope EnumScope(this, Scope::DeclScope | Scope::EnumScope);
5248 Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
5249
5250 BalancedDelimiterTracker T(*this, tok::l_brace);
5251 T.consumeOpen();
5252
5253 // C does not allow an empty enumerator-list, C++ does [dcl.enum].
5254 if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus)
5255 Diag(Tok, diag::err_empty_enum);
5256
5257 SmallVector<Decl *, 32> EnumConstantDecls;
5258 SmallVector<SuppressAccessChecks, 32> EnumAvailabilityDiags;
5259
5260 Decl *LastEnumConstDecl = nullptr;
5261
5262 // Parse the enumerator-list.
5263 while (Tok.isNot(tok::r_brace)) {
5264 // Parse enumerator. If failed, try skipping till the start of the next
5265 // enumerator definition.
5266 if (Tok.isNot(tok::identifier)) {
5267 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
5268 if (SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch) &&
5269 TryConsumeToken(tok::comma))
5270 continue;
5271 break;
5272 }
5273 IdentifierInfo *Ident = Tok.getIdentifierInfo();
5274 SourceLocation IdentLoc = ConsumeToken();
5275
5276 // If attributes exist after the enumerator, parse them.
5277 ParsedAttributes attrs(AttrFactory);
5278 MaybeParseGNUAttributes(attrs);
5279 if (isAllowedCXX11AttributeSpecifier()) {
5280 if (getLangOpts().CPlusPlus)
5281 Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
5282 ? diag::warn_cxx14_compat_ns_enum_attribute
5283 : diag::ext_ns_enum_attribute)
5284 << 1 /*enumerator*/;
5285 ParseCXX11Attributes(attrs);
5286 }
5287
5288 SourceLocation EqualLoc;
5289 ExprResult AssignedVal;
5290 EnumAvailabilityDiags.emplace_back(*this);
5291
5292 EnterExpressionEvaluationContext ConstantEvaluated(
5293 Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5294 if (TryConsumeToken(tok::equal, EqualLoc)) {
5295 AssignedVal = ParseConstantExpressionInExprEvalContext();
5296 if (AssignedVal.isInvalid())
5297 SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch);
5298 }
5299
5300 // Install the enumerator constant into EnumDecl.
5301 Decl *EnumConstDecl = Actions.ActOnEnumConstant(
5302 getCurScope(), EnumDecl, LastEnumConstDecl, IdentLoc, Ident, attrs,
5303 EqualLoc, AssignedVal.get());
5304 EnumAvailabilityDiags.back().done();
5305
5306 EnumConstantDecls.push_back(EnumConstDecl);
5307 LastEnumConstDecl = EnumConstDecl;
5308
5309 if (Tok.is(tok::identifier)) {
5310 // We're missing a comma between enumerators.
5311 SourceLocation Loc = getEndOfPreviousToken();
5312 Diag(Loc, diag::err_enumerator_list_missing_comma)
5313 << FixItHint::CreateInsertion(Loc, ", ");
5314 continue;
5315 }
5316
5317 // Emumerator definition must be finished, only comma or r_brace are
5318 // allowed here.
5319 SourceLocation CommaLoc;
5320 if (Tok.isNot(tok::r_brace) && !TryConsumeToken(tok::comma, CommaLoc)) {
5321 if (EqualLoc.isValid())
5322 Diag(Tok.getLocation(), diag::err_expected_either) << tok::r_brace
5323 << tok::comma;
5324 else
5325 Diag(Tok.getLocation(), diag::err_expected_end_of_enumerator);
5326 if (SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch)) {
5327 if (TryConsumeToken(tok::comma, CommaLoc))
5328 continue;
5329 } else {
5330 break;
5331 }
5332 }
5333
5334 // If comma is followed by r_brace, emit appropriate warning.
5335 if (Tok.is(tok::r_brace) && CommaLoc.isValid()) {
5336 if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11)
5337 Diag(CommaLoc, getLangOpts().CPlusPlus ?
5338 diag::ext_enumerator_list_comma_cxx :
5339 diag::ext_enumerator_list_comma_c)
5340 << FixItHint::CreateRemoval(CommaLoc);
5341 else if (getLangOpts().CPlusPlus11)
5342 Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma)
5343 << FixItHint::CreateRemoval(CommaLoc);
5344 break;
5345 }
5346 }
5347
5348 // Eat the }.
5349 T.consumeClose();
5350
5351 // If attributes exist after the identifier list, parse them.
5352 ParsedAttributes attrs(AttrFactory);
5353 MaybeParseGNUAttributes(attrs);
5354
5355 Actions.ActOnEnumBody(StartLoc, T.getRange(), EnumDecl, EnumConstantDecls,
5356 getCurScope(), attrs);
5357
5358 // Now handle enum constant availability diagnostics.
5359 assert(EnumConstantDecls.size() == EnumAvailabilityDiags.size());
5360 for (size_t i = 0, e = EnumConstantDecls.size(); i != e; ++i) {
5361 ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent);
5362 EnumAvailabilityDiags[i].redelay();
5363 PD.complete(EnumConstantDecls[i]);
5364 }
5365
5366 EnumScope.Exit();
5367 Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl, T.getRange());
5368
5369 // The next token must be valid after an enum definition. If not, a ';'
5370 // was probably forgotten.
5371 bool CanBeBitfield = getCurScope()->isClassScope();
5372 if (!isValidAfterTypeSpecifier(CanBeBitfield)) {
5373 ExpectAndConsume(tok::semi, diag::err_expected_after, "enum");
5374 // Push this token back into the preprocessor and change our current token
5375 // to ';' so that the rest of the code recovers as though there were an
5376 // ';' after the definition.
5377 PP.EnterToken(Tok, /*IsReinject=*/true);
5378 Tok.setKind(tok::semi);
5379 }
5380 }
5381
5382 /// isKnownToBeTypeSpecifier - Return true if we know that the specified token
5383 /// is definitely a type-specifier. Return false if it isn't part of a type
5384 /// specifier or if we're not sure.
isKnownToBeTypeSpecifier(const Token & Tok) const5385 bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
5386 switch (Tok.getKind()) {
5387 default: return false;
5388 // type-specifiers
5389 case tok::kw_short:
5390 case tok::kw_long:
5391 case tok::kw___int64:
5392 case tok::kw___int128:
5393 case tok::kw_signed:
5394 case tok::kw_unsigned:
5395 case tok::kw__Complex:
5396 case tok::kw__Imaginary:
5397 case tok::kw_void:
5398 case tok::kw_char:
5399 case tok::kw_wchar_t:
5400 case tok::kw_char8_t:
5401 case tok::kw_char16_t:
5402 case tok::kw_char32_t:
5403 case tok::kw_int:
5404 case tok::kw__ExtInt:
5405 case tok::kw__BitInt:
5406 case tok::kw___bf16:
5407 case tok::kw_half:
5408 case tok::kw_float:
5409 case tok::kw_double:
5410 case tok::kw__Accum:
5411 case tok::kw__Fract:
5412 case tok::kw__Float16:
5413 case tok::kw___float128:
5414 case tok::kw___ibm128:
5415 case tok::kw_bool:
5416 case tok::kw__Bool:
5417 case tok::kw__Decimal32:
5418 case tok::kw__Decimal64:
5419 case tok::kw__Decimal128:
5420 case tok::kw___vector:
5421 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
5422 #include "clang/Basic/OpenCLImageTypes.def"
5423
5424 // struct-or-union-specifier (C99) or class-specifier (C++)
5425 case tok::kw_class:
5426 case tok::kw_struct:
5427 case tok::kw___interface:
5428 case tok::kw_union:
5429 // enum-specifier
5430 case tok::kw_enum:
5431
5432 // typedef-name
5433 case tok::annot_typename:
5434 return true;
5435 }
5436 }
5437
5438 /// isTypeSpecifierQualifier - Return true if the current token could be the
5439 /// start of a specifier-qualifier-list.
isTypeSpecifierQualifier()5440 bool Parser::isTypeSpecifierQualifier() {
5441 switch (Tok.getKind()) {
5442 default: return false;
5443
5444 case tok::identifier: // foo::bar
5445 if (TryAltiVecVectorToken())
5446 return true;
5447 [[fallthrough]];
5448 case tok::kw_typename: // typename T::type
5449 // Annotate typenames and C++ scope specifiers. If we get one, just
5450 // recurse to handle whatever we get.
5451 if (TryAnnotateTypeOrScopeToken())
5452 return true;
5453 if (Tok.is(tok::identifier))
5454 return false;
5455 return isTypeSpecifierQualifier();
5456
5457 case tok::coloncolon: // ::foo::bar
5458 if (NextToken().is(tok::kw_new) || // ::new
5459 NextToken().is(tok::kw_delete)) // ::delete
5460 return false;
5461
5462 if (TryAnnotateTypeOrScopeToken())
5463 return true;
5464 return isTypeSpecifierQualifier();
5465
5466 // GNU attributes support.
5467 case tok::kw___attribute:
5468 // C23/GNU typeof support.
5469 case tok::kw_typeof:
5470 case tok::kw_typeof_unqual:
5471
5472 // type-specifiers
5473 case tok::kw_short:
5474 case tok::kw_long:
5475 case tok::kw___int64:
5476 case tok::kw___int128:
5477 case tok::kw_signed:
5478 case tok::kw_unsigned:
5479 case tok::kw__Complex:
5480 case tok::kw__Imaginary:
5481 case tok::kw_void:
5482 case tok::kw_char:
5483 case tok::kw_wchar_t:
5484 case tok::kw_char8_t:
5485 case tok::kw_char16_t:
5486 case tok::kw_char32_t:
5487 case tok::kw_int:
5488 case tok::kw__ExtInt:
5489 case tok::kw__BitInt:
5490 case tok::kw_half:
5491 case tok::kw___bf16:
5492 case tok::kw_float:
5493 case tok::kw_double:
5494 case tok::kw__Accum:
5495 case tok::kw__Fract:
5496 case tok::kw__Float16:
5497 case tok::kw___float128:
5498 case tok::kw___ibm128:
5499 case tok::kw_bool:
5500 case tok::kw__Bool:
5501 case tok::kw__Decimal32:
5502 case tok::kw__Decimal64:
5503 case tok::kw__Decimal128:
5504 case tok::kw___vector:
5505 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
5506 #include "clang/Basic/OpenCLImageTypes.def"
5507
5508 // struct-or-union-specifier (C99) or class-specifier (C++)
5509 case tok::kw_class:
5510 case tok::kw_struct:
5511 case tok::kw___interface:
5512 case tok::kw_union:
5513 // enum-specifier
5514 case tok::kw_enum:
5515
5516 // type-qualifier
5517 case tok::kw_const:
5518 case tok::kw_volatile:
5519 case tok::kw_restrict:
5520 case tok::kw__Sat:
5521
5522 // Debugger support.
5523 case tok::kw___unknown_anytype:
5524
5525 // typedef-name
5526 case tok::annot_typename:
5527 return true;
5528
5529 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
5530 case tok::less:
5531 return getLangOpts().ObjC;
5532
5533 case tok::kw___cdecl:
5534 case tok::kw___stdcall:
5535 case tok::kw___fastcall:
5536 case tok::kw___thiscall:
5537 case tok::kw___regcall:
5538 case tok::kw___vectorcall:
5539 case tok::kw___w64:
5540 case tok::kw___ptr64:
5541 case tok::kw___ptr32:
5542 case tok::kw___pascal:
5543 case tok::kw___unaligned:
5544
5545 case tok::kw__Nonnull:
5546 case tok::kw__Nullable:
5547 case tok::kw__Nullable_result:
5548 case tok::kw__Null_unspecified:
5549
5550 case tok::kw___kindof:
5551
5552 case tok::kw___private:
5553 case tok::kw___local:
5554 case tok::kw___global:
5555 case tok::kw___constant:
5556 case tok::kw___generic:
5557 case tok::kw___read_only:
5558 case tok::kw___read_write:
5559 case tok::kw___write_only:
5560 case tok::kw___funcref:
5561 return true;
5562
5563 case tok::kw_private:
5564 return getLangOpts().OpenCL;
5565
5566 // C11 _Atomic
5567 case tok::kw__Atomic:
5568 return true;
5569
5570 // HLSL type qualifiers
5571 case tok::kw_groupshared:
5572 case tok::kw_in:
5573 case tok::kw_inout:
5574 case tok::kw_out:
5575 return getLangOpts().HLSL;
5576 }
5577 }
5578
ParseTopLevelStmtDecl()5579 Parser::DeclGroupPtrTy Parser::ParseTopLevelStmtDecl() {
5580 assert(PP.isIncrementalProcessingEnabled() && "Not in incremental mode");
5581
5582 // Parse a top-level-stmt.
5583 Parser::StmtVector Stmts;
5584 ParsedStmtContext SubStmtCtx = ParsedStmtContext();
5585 Actions.PushFunctionScope();
5586 StmtResult R = ParseStatementOrDeclaration(Stmts, SubStmtCtx);
5587 Actions.PopFunctionScopeInfo();
5588 if (!R.isUsable())
5589 return nullptr;
5590
5591 SmallVector<Decl *, 2> DeclsInGroup;
5592 DeclsInGroup.push_back(Actions.ActOnTopLevelStmtDecl(R.get()));
5593
5594 if (Tok.is(tok::annot_repl_input_end) &&
5595 Tok.getAnnotationValue() != nullptr) {
5596 ConsumeAnnotationToken();
5597 cast<TopLevelStmtDecl>(DeclsInGroup.back())->setSemiMissing();
5598 }
5599
5600 // Currently happens for things like -fms-extensions and use `__if_exists`.
5601 for (Stmt *S : Stmts)
5602 DeclsInGroup.push_back(Actions.ActOnTopLevelStmtDecl(S));
5603
5604 return Actions.BuildDeclaratorGroup(DeclsInGroup);
5605 }
5606
5607 /// isDeclarationSpecifier() - Return true if the current token is part of a
5608 /// declaration specifier.
5609 ///
5610 /// \param AllowImplicitTypename whether this is a context where T::type [T
5611 /// dependent] can appear.
5612 /// \param DisambiguatingWithExpression True to indicate that the purpose of
5613 /// this check is to disambiguate between an expression and a declaration.
isDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,bool DisambiguatingWithExpression)5614 bool Parser::isDeclarationSpecifier(
5615 ImplicitTypenameContext AllowImplicitTypename,
5616 bool DisambiguatingWithExpression) {
5617 switch (Tok.getKind()) {
5618 default: return false;
5619
5620 // OpenCL 2.0 and later define this keyword.
5621 case tok::kw_pipe:
5622 return getLangOpts().OpenCL &&
5623 getLangOpts().getOpenCLCompatibleVersion() >= 200;
5624
5625 case tok::identifier: // foo::bar
5626 // Unfortunate hack to support "Class.factoryMethod" notation.
5627 if (getLangOpts().ObjC && NextToken().is(tok::period))
5628 return false;
5629 if (TryAltiVecVectorToken())
5630 return true;
5631 [[fallthrough]];
5632 case tok::kw_decltype: // decltype(T())::type
5633 case tok::kw_typename: // typename T::type
5634 // Annotate typenames and C++ scope specifiers. If we get one, just
5635 // recurse to handle whatever we get.
5636 if (TryAnnotateTypeOrScopeToken(AllowImplicitTypename))
5637 return true;
5638 if (TryAnnotateTypeConstraint())
5639 return true;
5640 if (Tok.is(tok::identifier))
5641 return false;
5642
5643 // If we're in Objective-C and we have an Objective-C class type followed
5644 // by an identifier and then either ':' or ']', in a place where an
5645 // expression is permitted, then this is probably a class message send
5646 // missing the initial '['. In this case, we won't consider this to be
5647 // the start of a declaration.
5648 if (DisambiguatingWithExpression &&
5649 isStartOfObjCClassMessageMissingOpenBracket())
5650 return false;
5651
5652 return isDeclarationSpecifier(AllowImplicitTypename);
5653
5654 case tok::coloncolon: // ::foo::bar
5655 if (!getLangOpts().CPlusPlus)
5656 return false;
5657 if (NextToken().is(tok::kw_new) || // ::new
5658 NextToken().is(tok::kw_delete)) // ::delete
5659 return false;
5660
5661 // Annotate typenames and C++ scope specifiers. If we get one, just
5662 // recurse to handle whatever we get.
5663 if (TryAnnotateTypeOrScopeToken())
5664 return true;
5665 return isDeclarationSpecifier(ImplicitTypenameContext::No);
5666
5667 // storage-class-specifier
5668 case tok::kw_typedef:
5669 case tok::kw_extern:
5670 case tok::kw___private_extern__:
5671 case tok::kw_static:
5672 case tok::kw_auto:
5673 case tok::kw___auto_type:
5674 case tok::kw_register:
5675 case tok::kw___thread:
5676 case tok::kw_thread_local:
5677 case tok::kw__Thread_local:
5678
5679 // Modules
5680 case tok::kw___module_private__:
5681
5682 // Debugger support
5683 case tok::kw___unknown_anytype:
5684
5685 // type-specifiers
5686 case tok::kw_short:
5687 case tok::kw_long:
5688 case tok::kw___int64:
5689 case tok::kw___int128:
5690 case tok::kw_signed:
5691 case tok::kw_unsigned:
5692 case tok::kw__Complex:
5693 case tok::kw__Imaginary:
5694 case tok::kw_void:
5695 case tok::kw_char:
5696 case tok::kw_wchar_t:
5697 case tok::kw_char8_t:
5698 case tok::kw_char16_t:
5699 case tok::kw_char32_t:
5700
5701 case tok::kw_int:
5702 case tok::kw__ExtInt:
5703 case tok::kw__BitInt:
5704 case tok::kw_half:
5705 case tok::kw___bf16:
5706 case tok::kw_float:
5707 case tok::kw_double:
5708 case tok::kw__Accum:
5709 case tok::kw__Fract:
5710 case tok::kw__Float16:
5711 case tok::kw___float128:
5712 case tok::kw___ibm128:
5713 case tok::kw_bool:
5714 case tok::kw__Bool:
5715 case tok::kw__Decimal32:
5716 case tok::kw__Decimal64:
5717 case tok::kw__Decimal128:
5718 case tok::kw___vector:
5719
5720 // struct-or-union-specifier (C99) or class-specifier (C++)
5721 case tok::kw_class:
5722 case tok::kw_struct:
5723 case tok::kw_union:
5724 case tok::kw___interface:
5725 // enum-specifier
5726 case tok::kw_enum:
5727
5728 // type-qualifier
5729 case tok::kw_const:
5730 case tok::kw_volatile:
5731 case tok::kw_restrict:
5732 case tok::kw__Sat:
5733
5734 // function-specifier
5735 case tok::kw_inline:
5736 case tok::kw_virtual:
5737 case tok::kw_explicit:
5738 case tok::kw__Noreturn:
5739
5740 // alignment-specifier
5741 case tok::kw__Alignas:
5742
5743 // friend keyword.
5744 case tok::kw_friend:
5745
5746 // static_assert-declaration
5747 case tok::kw_static_assert:
5748 case tok::kw__Static_assert:
5749
5750 // C23/GNU typeof support.
5751 case tok::kw_typeof:
5752 case tok::kw_typeof_unqual:
5753
5754 // GNU attributes.
5755 case tok::kw___attribute:
5756
5757 // C++11 decltype and constexpr.
5758 case tok::annot_decltype:
5759 case tok::kw_constexpr:
5760
5761 // C++20 consteval and constinit.
5762 case tok::kw_consteval:
5763 case tok::kw_constinit:
5764
5765 // C11 _Atomic
5766 case tok::kw__Atomic:
5767 return true;
5768
5769 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
5770 case tok::less:
5771 return getLangOpts().ObjC;
5772
5773 // typedef-name
5774 case tok::annot_typename:
5775 return !DisambiguatingWithExpression ||
5776 !isStartOfObjCClassMessageMissingOpenBracket();
5777
5778 // placeholder-type-specifier
5779 case tok::annot_template_id: {
5780 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
5781 if (TemplateId->hasInvalidName())
5782 return true;
5783 // FIXME: What about type templates that have only been annotated as
5784 // annot_template_id, not as annot_typename?
5785 return isTypeConstraintAnnotation() &&
5786 (NextToken().is(tok::kw_auto) || NextToken().is(tok::kw_decltype));
5787 }
5788
5789 case tok::annot_cxxscope: {
5790 TemplateIdAnnotation *TemplateId =
5791 NextToken().is(tok::annot_template_id)
5792 ? takeTemplateIdAnnotation(NextToken())
5793 : nullptr;
5794 if (TemplateId && TemplateId->hasInvalidName())
5795 return true;
5796 // FIXME: What about type templates that have only been annotated as
5797 // annot_template_id, not as annot_typename?
5798 if (NextToken().is(tok::identifier) && TryAnnotateTypeConstraint())
5799 return true;
5800 return isTypeConstraintAnnotation() &&
5801 GetLookAheadToken(2).isOneOf(tok::kw_auto, tok::kw_decltype);
5802 }
5803
5804 case tok::kw___declspec:
5805 case tok::kw___cdecl:
5806 case tok::kw___stdcall:
5807 case tok::kw___fastcall:
5808 case tok::kw___thiscall:
5809 case tok::kw___regcall:
5810 case tok::kw___vectorcall:
5811 case tok::kw___w64:
5812 case tok::kw___sptr:
5813 case tok::kw___uptr:
5814 case tok::kw___ptr64:
5815 case tok::kw___ptr32:
5816 case tok::kw___forceinline:
5817 case tok::kw___pascal:
5818 case tok::kw___unaligned:
5819
5820 case tok::kw__Nonnull:
5821 case tok::kw__Nullable:
5822 case tok::kw__Nullable_result:
5823 case tok::kw__Null_unspecified:
5824
5825 case tok::kw___kindof:
5826
5827 case tok::kw___private:
5828 case tok::kw___local:
5829 case tok::kw___global:
5830 case tok::kw___constant:
5831 case tok::kw___generic:
5832 case tok::kw___read_only:
5833 case tok::kw___read_write:
5834 case tok::kw___write_only:
5835 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
5836 #include "clang/Basic/OpenCLImageTypes.def"
5837
5838 case tok::kw___funcref:
5839 case tok::kw_groupshared:
5840 return true;
5841
5842 case tok::kw_private:
5843 return getLangOpts().OpenCL;
5844 }
5845 }
5846
isConstructorDeclarator(bool IsUnqualified,bool DeductionGuide,DeclSpec::FriendSpecified IsFriend,const ParsedTemplateInfo * TemplateInfo)5847 bool Parser::isConstructorDeclarator(bool IsUnqualified, bool DeductionGuide,
5848 DeclSpec::FriendSpecified IsFriend,
5849 const ParsedTemplateInfo *TemplateInfo) {
5850 RevertingTentativeParsingAction TPA(*this);
5851 // Parse the C++ scope specifier.
5852 CXXScopeSpec SS;
5853 if (TemplateInfo && TemplateInfo->TemplateParams)
5854 SS.setTemplateParamLists(*TemplateInfo->TemplateParams);
5855
5856 if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
5857 /*ObjectHasErrors=*/false,
5858 /*EnteringContext=*/true)) {
5859 return false;
5860 }
5861
5862 // Parse the constructor name.
5863 if (Tok.is(tok::identifier)) {
5864 // We already know that we have a constructor name; just consume
5865 // the token.
5866 ConsumeToken();
5867 } else if (Tok.is(tok::annot_template_id)) {
5868 ConsumeAnnotationToken();
5869 } else {
5870 return false;
5871 }
5872
5873 // There may be attributes here, appertaining to the constructor name or type
5874 // we just stepped past.
5875 SkipCXX11Attributes();
5876
5877 // Current class name must be followed by a left parenthesis.
5878 if (Tok.isNot(tok::l_paren)) {
5879 return false;
5880 }
5881 ConsumeParen();
5882
5883 // A right parenthesis, or ellipsis followed by a right parenthesis signals
5884 // that we have a constructor.
5885 if (Tok.is(tok::r_paren) ||
5886 (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren))) {
5887 return true;
5888 }
5889
5890 // A C++11 attribute here signals that we have a constructor, and is an
5891 // attribute on the first constructor parameter.
5892 if (getLangOpts().CPlusPlus11 &&
5893 isCXX11AttributeSpecifier(/*Disambiguate*/ false,
5894 /*OuterMightBeMessageSend*/ true)) {
5895 return true;
5896 }
5897
5898 // If we need to, enter the specified scope.
5899 DeclaratorScopeObj DeclScopeObj(*this, SS);
5900 if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
5901 DeclScopeObj.EnterDeclaratorScope();
5902
5903 // Optionally skip Microsoft attributes.
5904 ParsedAttributes Attrs(AttrFactory);
5905 MaybeParseMicrosoftAttributes(Attrs);
5906
5907 // Check whether the next token(s) are part of a declaration
5908 // specifier, in which case we have the start of a parameter and,
5909 // therefore, we know that this is a constructor.
5910 // Due to an ambiguity with implicit typename, the above is not enough.
5911 // Additionally, check to see if we are a friend.
5912 // If we parsed a scope specifier as well as friend,
5913 // we might be parsing a friend constructor.
5914 bool IsConstructor = false;
5915 ImplicitTypenameContext ITC = IsFriend && !SS.isSet()
5916 ? ImplicitTypenameContext::No
5917 : ImplicitTypenameContext::Yes;
5918 // Constructors cannot have this parameters, but we support that scenario here
5919 // to improve diagnostic.
5920 if (Tok.is(tok::kw_this)) {
5921 ConsumeToken();
5922 return isDeclarationSpecifier(ITC);
5923 }
5924
5925 if (isDeclarationSpecifier(ITC))
5926 IsConstructor = true;
5927 else if (Tok.is(tok::identifier) ||
5928 (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) {
5929 // We've seen "C ( X" or "C ( X::Y", but "X" / "X::Y" is not a type.
5930 // This might be a parenthesized member name, but is more likely to
5931 // be a constructor declaration with an invalid argument type. Keep
5932 // looking.
5933 if (Tok.is(tok::annot_cxxscope))
5934 ConsumeAnnotationToken();
5935 ConsumeToken();
5936
5937 // If this is not a constructor, we must be parsing a declarator,
5938 // which must have one of the following syntactic forms (see the
5939 // grammar extract at the start of ParseDirectDeclarator):
5940 switch (Tok.getKind()) {
5941 case tok::l_paren:
5942 // C(X ( int));
5943 case tok::l_square:
5944 // C(X [ 5]);
5945 // C(X [ [attribute]]);
5946 case tok::coloncolon:
5947 // C(X :: Y);
5948 // C(X :: *p);
5949 // Assume this isn't a constructor, rather than assuming it's a
5950 // constructor with an unnamed parameter of an ill-formed type.
5951 break;
5952
5953 case tok::r_paren:
5954 // C(X )
5955
5956 // Skip past the right-paren and any following attributes to get to
5957 // the function body or trailing-return-type.
5958 ConsumeParen();
5959 SkipCXX11Attributes();
5960
5961 if (DeductionGuide) {
5962 // C(X) -> ... is a deduction guide.
5963 IsConstructor = Tok.is(tok::arrow);
5964 break;
5965 }
5966 if (Tok.is(tok::colon) || Tok.is(tok::kw_try)) {
5967 // Assume these were meant to be constructors:
5968 // C(X) : (the name of a bit-field cannot be parenthesized).
5969 // C(X) try (this is otherwise ill-formed).
5970 IsConstructor = true;
5971 }
5972 if (Tok.is(tok::semi) || Tok.is(tok::l_brace)) {
5973 // If we have a constructor name within the class definition,
5974 // assume these were meant to be constructors:
5975 // C(X) {
5976 // C(X) ;
5977 // ... because otherwise we would be declaring a non-static data
5978 // member that is ill-formed because it's of the same type as its
5979 // surrounding class.
5980 //
5981 // FIXME: We can actually do this whether or not the name is qualified,
5982 // because if it is qualified in this context it must be being used as
5983 // a constructor name.
5984 // currently, so we're somewhat conservative here.
5985 IsConstructor = IsUnqualified;
5986 }
5987 break;
5988
5989 default:
5990 IsConstructor = true;
5991 break;
5992 }
5993 }
5994 return IsConstructor;
5995 }
5996
5997 /// ParseTypeQualifierListOpt
5998 /// type-qualifier-list: [C99 6.7.5]
5999 /// type-qualifier
6000 /// [vendor] attributes
6001 /// [ only if AttrReqs & AR_VendorAttributesParsed ]
6002 /// type-qualifier-list type-qualifier
6003 /// [vendor] type-qualifier-list attributes
6004 /// [ only if AttrReqs & AR_VendorAttributesParsed ]
6005 /// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq
6006 /// [ only if AttReqs & AR_CXX11AttributesParsed ]
6007 /// Note: vendor can be GNU, MS, etc and can be explicitly controlled via
6008 /// AttrRequirements bitmask values.
ParseTypeQualifierListOpt(DeclSpec & DS,unsigned AttrReqs,bool AtomicAllowed,bool IdentifierRequired,std::optional<llvm::function_ref<void ()>> CodeCompletionHandler)6009 void Parser::ParseTypeQualifierListOpt(
6010 DeclSpec &DS, unsigned AttrReqs, bool AtomicAllowed,
6011 bool IdentifierRequired,
6012 std::optional<llvm::function_ref<void()>> CodeCompletionHandler) {
6013 if ((AttrReqs & AR_CXX11AttributesParsed) &&
6014 isAllowedCXX11AttributeSpecifier()) {
6015 ParsedAttributes Attrs(AttrFactory);
6016 ParseCXX11Attributes(Attrs);
6017 DS.takeAttributesFrom(Attrs);
6018 }
6019
6020 SourceLocation EndLoc;
6021
6022 while (true) {
6023 bool isInvalid = false;
6024 const char *PrevSpec = nullptr;
6025 unsigned DiagID = 0;
6026 SourceLocation Loc = Tok.getLocation();
6027
6028 switch (Tok.getKind()) {
6029 case tok::code_completion:
6030 cutOffParsing();
6031 if (CodeCompletionHandler)
6032 (*CodeCompletionHandler)();
6033 else
6034 Actions.CodeCompleteTypeQualifiers(DS);
6035 return;
6036
6037 case tok::kw_const:
6038 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, DiagID,
6039 getLangOpts());
6040 break;
6041 case tok::kw_volatile:
6042 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
6043 getLangOpts());
6044 break;
6045 case tok::kw_restrict:
6046 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
6047 getLangOpts());
6048 break;
6049 case tok::kw__Atomic:
6050 if (!AtomicAllowed)
6051 goto DoneWithTypeQuals;
6052 if (!getLangOpts().C11)
6053 Diag(Tok, diag::ext_c11_feature) << Tok.getName();
6054 isInvalid = DS.SetTypeQual(DeclSpec::TQ_atomic, Loc, PrevSpec, DiagID,
6055 getLangOpts());
6056 break;
6057
6058 // OpenCL qualifiers:
6059 case tok::kw_private:
6060 if (!getLangOpts().OpenCL)
6061 goto DoneWithTypeQuals;
6062 [[fallthrough]];
6063 case tok::kw___private:
6064 case tok::kw___global:
6065 case tok::kw___local:
6066 case tok::kw___constant:
6067 case tok::kw___generic:
6068 case tok::kw___read_only:
6069 case tok::kw___write_only:
6070 case tok::kw___read_write:
6071 ParseOpenCLQualifiers(DS.getAttributes());
6072 break;
6073
6074 case tok::kw_groupshared:
6075 case tok::kw_in:
6076 case tok::kw_inout:
6077 case tok::kw_out:
6078 // NOTE: ParseHLSLQualifiers will consume the qualifier token.
6079 ParseHLSLQualifiers(DS.getAttributes());
6080 continue;
6081
6082 case tok::kw___unaligned:
6083 isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
6084 getLangOpts());
6085 break;
6086 case tok::kw___uptr:
6087 // GNU libc headers in C mode use '__uptr' as an identifier which conflicts
6088 // with the MS modifier keyword.
6089 if ((AttrReqs & AR_DeclspecAttributesParsed) && !getLangOpts().CPlusPlus &&
6090 IdentifierRequired && DS.isEmpty() && NextToken().is(tok::semi)) {
6091 if (TryKeywordIdentFallback(false))
6092 continue;
6093 }
6094 [[fallthrough]];
6095 case tok::kw___sptr:
6096 case tok::kw___w64:
6097 case tok::kw___ptr64:
6098 case tok::kw___ptr32:
6099 case tok::kw___cdecl:
6100 case tok::kw___stdcall:
6101 case tok::kw___fastcall:
6102 case tok::kw___thiscall:
6103 case tok::kw___regcall:
6104 case tok::kw___vectorcall:
6105 if (AttrReqs & AR_DeclspecAttributesParsed) {
6106 ParseMicrosoftTypeAttributes(DS.getAttributes());
6107 continue;
6108 }
6109 goto DoneWithTypeQuals;
6110
6111 case tok::kw___funcref:
6112 ParseWebAssemblyFuncrefTypeAttribute(DS.getAttributes());
6113 continue;
6114 goto DoneWithTypeQuals;
6115
6116 case tok::kw___pascal:
6117 if (AttrReqs & AR_VendorAttributesParsed) {
6118 ParseBorlandTypeAttributes(DS.getAttributes());
6119 continue;
6120 }
6121 goto DoneWithTypeQuals;
6122
6123 // Nullability type specifiers.
6124 case tok::kw__Nonnull:
6125 case tok::kw__Nullable:
6126 case tok::kw__Nullable_result:
6127 case tok::kw__Null_unspecified:
6128 ParseNullabilityTypeSpecifiers(DS.getAttributes());
6129 continue;
6130
6131 // Objective-C 'kindof' types.
6132 case tok::kw___kindof:
6133 DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
6134 nullptr, 0, tok::kw___kindof);
6135 (void)ConsumeToken();
6136 continue;
6137
6138 case tok::kw___attribute:
6139 if (AttrReqs & AR_GNUAttributesParsedAndRejected)
6140 // When GNU attributes are expressly forbidden, diagnose their usage.
6141 Diag(Tok, diag::err_attributes_not_allowed);
6142
6143 // Parse the attributes even if they are rejected to ensure that error
6144 // recovery is graceful.
6145 if (AttrReqs & AR_GNUAttributesParsed ||
6146 AttrReqs & AR_GNUAttributesParsedAndRejected) {
6147 ParseGNUAttributes(DS.getAttributes());
6148 continue; // do *not* consume the next token!
6149 }
6150 // otherwise, FALL THROUGH!
6151 [[fallthrough]];
6152 default:
6153 DoneWithTypeQuals:
6154 // If this is not a type-qualifier token, we're done reading type
6155 // qualifiers. First verify that DeclSpec's are consistent.
6156 DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
6157 if (EndLoc.isValid())
6158 DS.SetRangeEnd(EndLoc);
6159 return;
6160 }
6161
6162 // If the specifier combination wasn't legal, issue a diagnostic.
6163 if (isInvalid) {
6164 assert(PrevSpec && "Method did not return previous specifier!");
6165 Diag(Tok, DiagID) << PrevSpec;
6166 }
6167 EndLoc = ConsumeToken();
6168 }
6169 }
6170
6171 /// ParseDeclarator - Parse and verify a newly-initialized declarator.
ParseDeclarator(Declarator & D)6172 void Parser::ParseDeclarator(Declarator &D) {
6173 /// This implements the 'declarator' production in the C grammar, then checks
6174 /// for well-formedness and issues diagnostics.
6175 Actions.runWithSufficientStackSpace(D.getBeginLoc(), [&] {
6176 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
6177 });
6178 }
6179
isPtrOperatorToken(tok::TokenKind Kind,const LangOptions & Lang,DeclaratorContext TheContext)6180 static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang,
6181 DeclaratorContext TheContext) {
6182 if (Kind == tok::star || Kind == tok::caret)
6183 return true;
6184
6185 // OpenCL 2.0 and later define this keyword.
6186 if (Kind == tok::kw_pipe && Lang.OpenCL &&
6187 Lang.getOpenCLCompatibleVersion() >= 200)
6188 return true;
6189
6190 if (!Lang.CPlusPlus)
6191 return false;
6192
6193 if (Kind == tok::amp)
6194 return true;
6195
6196 // We parse rvalue refs in C++03, because otherwise the errors are scary.
6197 // But we must not parse them in conversion-type-ids and new-type-ids, since
6198 // those can be legitimately followed by a && operator.
6199 // (The same thing can in theory happen after a trailing-return-type, but
6200 // since those are a C++11 feature, there is no rejects-valid issue there.)
6201 if (Kind == tok::ampamp)
6202 return Lang.CPlusPlus11 || (TheContext != DeclaratorContext::ConversionId &&
6203 TheContext != DeclaratorContext::CXXNew);
6204
6205 return false;
6206 }
6207
6208 // Indicates whether the given declarator is a pipe declarator.
isPipeDeclarator(const Declarator & D)6209 static bool isPipeDeclarator(const Declarator &D) {
6210 const unsigned NumTypes = D.getNumTypeObjects();
6211
6212 for (unsigned Idx = 0; Idx != NumTypes; ++Idx)
6213 if (DeclaratorChunk::Pipe == D.getTypeObject(Idx).Kind)
6214 return true;
6215
6216 return false;
6217 }
6218
6219 /// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
6220 /// is parsed by the function passed to it. Pass null, and the direct-declarator
6221 /// isn't parsed at all, making this function effectively parse the C++
6222 /// ptr-operator production.
6223 ///
6224 /// If the grammar of this construct is extended, matching changes must also be
6225 /// made to TryParseDeclarator and MightBeDeclarator, and possibly to
6226 /// isConstructorDeclarator.
6227 ///
6228 /// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
6229 /// [C] pointer[opt] direct-declarator
6230 /// [C++] direct-declarator
6231 /// [C++] ptr-operator declarator
6232 ///
6233 /// pointer: [C99 6.7.5]
6234 /// '*' type-qualifier-list[opt]
6235 /// '*' type-qualifier-list[opt] pointer
6236 ///
6237 /// ptr-operator:
6238 /// '*' cv-qualifier-seq[opt]
6239 /// '&'
6240 /// [C++0x] '&&'
6241 /// [GNU] '&' restrict[opt] attributes[opt]
6242 /// [GNU?] '&&' restrict[opt] attributes[opt]
6243 /// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
ParseDeclaratorInternal(Declarator & D,DirectDeclParseFunction DirectDeclParser)6244 void Parser::ParseDeclaratorInternal(Declarator &D,
6245 DirectDeclParseFunction DirectDeclParser) {
6246 if (Diags.hasAllExtensionsSilenced())
6247 D.setExtension();
6248
6249 // C++ member pointers start with a '::' or a nested-name.
6250 // Member pointers get special handling, since there's no place for the
6251 // scope spec in the generic path below.
6252 if (getLangOpts().CPlusPlus &&
6253 (Tok.is(tok::coloncolon) || Tok.is(tok::kw_decltype) ||
6254 (Tok.is(tok::identifier) &&
6255 (NextToken().is(tok::coloncolon) || NextToken().is(tok::less))) ||
6256 Tok.is(tok::annot_cxxscope))) {
6257 bool EnteringContext = D.getContext() == DeclaratorContext::File ||
6258 D.getContext() == DeclaratorContext::Member;
6259 CXXScopeSpec SS;
6260 SS.setTemplateParamLists(D.getTemplateParameterLists());
6261 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
6262 /*ObjectHasErrors=*/false, EnteringContext);
6263
6264 if (SS.isNotEmpty()) {
6265 if (Tok.isNot(tok::star)) {
6266 // The scope spec really belongs to the direct-declarator.
6267 if (D.mayHaveIdentifier())
6268 D.getCXXScopeSpec() = SS;
6269 else
6270 AnnotateScopeToken(SS, true);
6271
6272 if (DirectDeclParser)
6273 (this->*DirectDeclParser)(D);
6274 return;
6275 }
6276
6277 if (SS.isValid()) {
6278 checkCompoundToken(SS.getEndLoc(), tok::coloncolon,
6279 CompoundToken::MemberPtr);
6280 }
6281
6282 SourceLocation StarLoc = ConsumeToken();
6283 D.SetRangeEnd(StarLoc);
6284 DeclSpec DS(AttrFactory);
6285 ParseTypeQualifierListOpt(DS);
6286 D.ExtendWithDeclSpec(DS);
6287
6288 // Recurse to parse whatever is left.
6289 Actions.runWithSufficientStackSpace(D.getBeginLoc(), [&] {
6290 ParseDeclaratorInternal(D, DirectDeclParser);
6291 });
6292
6293 // Sema will have to catch (syntactically invalid) pointers into global
6294 // scope. It has to catch pointers into namespace scope anyway.
6295 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(
6296 SS, DS.getTypeQualifiers(), StarLoc, DS.getEndLoc()),
6297 std::move(DS.getAttributes()),
6298 /* Don't replace range end. */ SourceLocation());
6299 return;
6300 }
6301 }
6302
6303 tok::TokenKind Kind = Tok.getKind();
6304
6305 if (D.getDeclSpec().isTypeSpecPipe() && !isPipeDeclarator(D)) {
6306 DeclSpec DS(AttrFactory);
6307 ParseTypeQualifierListOpt(DS);
6308
6309 D.AddTypeInfo(
6310 DeclaratorChunk::getPipe(DS.getTypeQualifiers(), DS.getPipeLoc()),
6311 std::move(DS.getAttributes()), SourceLocation());
6312 }
6313
6314 // Not a pointer, C++ reference, or block.
6315 if (!isPtrOperatorToken(Kind, getLangOpts(), D.getContext())) {
6316 if (DirectDeclParser)
6317 (this->*DirectDeclParser)(D);
6318 return;
6319 }
6320
6321 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
6322 // '&&' -> rvalue reference
6323 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&.
6324 D.SetRangeEnd(Loc);
6325
6326 if (Kind == tok::star || Kind == tok::caret) {
6327 // Is a pointer.
6328 DeclSpec DS(AttrFactory);
6329
6330 // GNU attributes are not allowed here in a new-type-id, but Declspec and
6331 // C++11 attributes are allowed.
6332 unsigned Reqs = AR_CXX11AttributesParsed | AR_DeclspecAttributesParsed |
6333 ((D.getContext() != DeclaratorContext::CXXNew)
6334 ? AR_GNUAttributesParsed
6335 : AR_GNUAttributesParsedAndRejected);
6336 ParseTypeQualifierListOpt(DS, Reqs, true, !D.mayOmitIdentifier());
6337 D.ExtendWithDeclSpec(DS);
6338
6339 // Recursively parse the declarator.
6340 Actions.runWithSufficientStackSpace(
6341 D.getBeginLoc(), [&] { ParseDeclaratorInternal(D, DirectDeclParser); });
6342 if (Kind == tok::star)
6343 // Remember that we parsed a pointer type, and remember the type-quals.
6344 D.AddTypeInfo(DeclaratorChunk::getPointer(
6345 DS.getTypeQualifiers(), Loc, DS.getConstSpecLoc(),
6346 DS.getVolatileSpecLoc(), DS.getRestrictSpecLoc(),
6347 DS.getAtomicSpecLoc(), DS.getUnalignedSpecLoc()),
6348 std::move(DS.getAttributes()), SourceLocation());
6349 else
6350 // Remember that we parsed a Block type, and remember the type-quals.
6351 D.AddTypeInfo(
6352 DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(), Loc),
6353 std::move(DS.getAttributes()), SourceLocation());
6354 } else {
6355 // Is a reference
6356 DeclSpec DS(AttrFactory);
6357
6358 // Complain about rvalue references in C++03, but then go on and build
6359 // the declarator.
6360 if (Kind == tok::ampamp)
6361 Diag(Loc, getLangOpts().CPlusPlus11 ?
6362 diag::warn_cxx98_compat_rvalue_reference :
6363 diag::ext_rvalue_reference);
6364
6365 // GNU-style and C++11 attributes are allowed here, as is restrict.
6366 ParseTypeQualifierListOpt(DS);
6367 D.ExtendWithDeclSpec(DS);
6368
6369 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
6370 // cv-qualifiers are introduced through the use of a typedef or of a
6371 // template type argument, in which case the cv-qualifiers are ignored.
6372 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
6373 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
6374 Diag(DS.getConstSpecLoc(),
6375 diag::err_invalid_reference_qualifier_application) << "const";
6376 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
6377 Diag(DS.getVolatileSpecLoc(),
6378 diag::err_invalid_reference_qualifier_application) << "volatile";
6379 // 'restrict' is permitted as an extension.
6380 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
6381 Diag(DS.getAtomicSpecLoc(),
6382 diag::err_invalid_reference_qualifier_application) << "_Atomic";
6383 }
6384
6385 // Recursively parse the declarator.
6386 Actions.runWithSufficientStackSpace(
6387 D.getBeginLoc(), [&] { ParseDeclaratorInternal(D, DirectDeclParser); });
6388
6389 if (D.getNumTypeObjects() > 0) {
6390 // C++ [dcl.ref]p4: There shall be no references to references.
6391 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
6392 if (InnerChunk.Kind == DeclaratorChunk::Reference) {
6393 if (const IdentifierInfo *II = D.getIdentifier())
6394 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
6395 << II;
6396 else
6397 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
6398 << "type name";
6399
6400 // Once we've complained about the reference-to-reference, we
6401 // can go ahead and build the (technically ill-formed)
6402 // declarator: reference collapsing will take care of it.
6403 }
6404 }
6405
6406 // Remember that we parsed a reference type.
6407 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
6408 Kind == tok::amp),
6409 std::move(DS.getAttributes()), SourceLocation());
6410 }
6411 }
6412
6413 // When correcting from misplaced brackets before the identifier, the location
6414 // is saved inside the declarator so that other diagnostic messages can use
6415 // them. This extracts and returns that location, or returns the provided
6416 // location if a stored location does not exist.
getMissingDeclaratorIdLoc(Declarator & D,SourceLocation Loc)6417 static SourceLocation getMissingDeclaratorIdLoc(Declarator &D,
6418 SourceLocation Loc) {
6419 if (D.getName().StartLocation.isInvalid() &&
6420 D.getName().EndLocation.isValid())
6421 return D.getName().EndLocation;
6422
6423 return Loc;
6424 }
6425
6426 /// ParseDirectDeclarator
6427 /// direct-declarator: [C99 6.7.5]
6428 /// [C99] identifier
6429 /// '(' declarator ')'
6430 /// [GNU] '(' attributes declarator ')'
6431 /// [C90] direct-declarator '[' constant-expression[opt] ']'
6432 /// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
6433 /// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
6434 /// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
6435 /// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
6436 /// [C++11] direct-declarator '[' constant-expression[opt] ']'
6437 /// attribute-specifier-seq[opt]
6438 /// direct-declarator '(' parameter-type-list ')'
6439 /// direct-declarator '(' identifier-list[opt] ')'
6440 /// [GNU] direct-declarator '(' parameter-forward-declarations
6441 /// parameter-type-list[opt] ')'
6442 /// [C++] direct-declarator '(' parameter-declaration-clause ')'
6443 /// cv-qualifier-seq[opt] exception-specification[opt]
6444 /// [C++11] direct-declarator '(' parameter-declaration-clause ')'
6445 /// attribute-specifier-seq[opt] cv-qualifier-seq[opt]
6446 /// ref-qualifier[opt] exception-specification[opt]
6447 /// [C++] declarator-id
6448 /// [C++11] declarator-id attribute-specifier-seq[opt]
6449 ///
6450 /// declarator-id: [C++ 8]
6451 /// '...'[opt] id-expression
6452 /// '::'[opt] nested-name-specifier[opt] type-name
6453 ///
6454 /// id-expression: [C++ 5.1]
6455 /// unqualified-id
6456 /// qualified-id
6457 ///
6458 /// unqualified-id: [C++ 5.1]
6459 /// identifier
6460 /// operator-function-id
6461 /// conversion-function-id
6462 /// '~' class-name
6463 /// template-id
6464 ///
6465 /// C++17 adds the following, which we also handle here:
6466 ///
6467 /// simple-declaration:
6468 /// <decl-spec> '[' identifier-list ']' brace-or-equal-initializer ';'
6469 ///
6470 /// Note, any additional constructs added here may need corresponding changes
6471 /// in isConstructorDeclarator.
ParseDirectDeclarator(Declarator & D)6472 void Parser::ParseDirectDeclarator(Declarator &D) {
6473 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
6474
6475 if (getLangOpts().CPlusPlus && D.mayHaveIdentifier()) {
6476 // This might be a C++17 structured binding.
6477 if (Tok.is(tok::l_square) && !D.mayOmitIdentifier() &&
6478 D.getCXXScopeSpec().isEmpty())
6479 return ParseDecompositionDeclarator(D);
6480
6481 // Don't parse FOO:BAR as if it were a typo for FOO::BAR inside a class, in
6482 // this context it is a bitfield. Also in range-based for statement colon
6483 // may delimit for-range-declaration.
6484 ColonProtectionRAIIObject X(
6485 *this, D.getContext() == DeclaratorContext::Member ||
6486 (D.getContext() == DeclaratorContext::ForInit &&
6487 getLangOpts().CPlusPlus11));
6488
6489 // ParseDeclaratorInternal might already have parsed the scope.
6490 if (D.getCXXScopeSpec().isEmpty()) {
6491 bool EnteringContext = D.getContext() == DeclaratorContext::File ||
6492 D.getContext() == DeclaratorContext::Member;
6493 ParseOptionalCXXScopeSpecifier(
6494 D.getCXXScopeSpec(), /*ObjectType=*/nullptr,
6495 /*ObjectHasErrors=*/false, EnteringContext);
6496 }
6497
6498 if (D.getCXXScopeSpec().isValid()) {
6499 if (Actions.ShouldEnterDeclaratorScope(getCurScope(),
6500 D.getCXXScopeSpec()))
6501 // Change the declaration context for name lookup, until this function
6502 // is exited (and the declarator has been parsed).
6503 DeclScopeObj.EnterDeclaratorScope();
6504 else if (getObjCDeclContext()) {
6505 // Ensure that we don't interpret the next token as an identifier when
6506 // dealing with declarations in an Objective-C container.
6507 D.SetIdentifier(nullptr, Tok.getLocation());
6508 D.setInvalidType(true);
6509 ConsumeToken();
6510 goto PastIdentifier;
6511 }
6512 }
6513
6514 // C++0x [dcl.fct]p14:
6515 // There is a syntactic ambiguity when an ellipsis occurs at the end of a
6516 // parameter-declaration-clause without a preceding comma. In this case,
6517 // the ellipsis is parsed as part of the abstract-declarator if the type
6518 // of the parameter either names a template parameter pack that has not
6519 // been expanded or contains auto; otherwise, it is parsed as part of the
6520 // parameter-declaration-clause.
6521 if (Tok.is(tok::ellipsis) && D.getCXXScopeSpec().isEmpty() &&
6522 !((D.getContext() == DeclaratorContext::Prototype ||
6523 D.getContext() == DeclaratorContext::LambdaExprParameter ||
6524 D.getContext() == DeclaratorContext::BlockLiteral) &&
6525 NextToken().is(tok::r_paren) && !D.hasGroupingParens() &&
6526 !Actions.containsUnexpandedParameterPacks(D) &&
6527 D.getDeclSpec().getTypeSpecType() != TST_auto)) {
6528 SourceLocation EllipsisLoc = ConsumeToken();
6529 if (isPtrOperatorToken(Tok.getKind(), getLangOpts(), D.getContext())) {
6530 // The ellipsis was put in the wrong place. Recover, and explain to
6531 // the user what they should have done.
6532 ParseDeclarator(D);
6533 if (EllipsisLoc.isValid())
6534 DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
6535 return;
6536 } else
6537 D.setEllipsisLoc(EllipsisLoc);
6538
6539 // The ellipsis can't be followed by a parenthesized declarator. We
6540 // check for that in ParseParenDeclarator, after we have disambiguated
6541 // the l_paren token.
6542 }
6543
6544 if (Tok.isOneOf(tok::identifier, tok::kw_operator, tok::annot_template_id,
6545 tok::tilde)) {
6546 // We found something that indicates the start of an unqualified-id.
6547 // Parse that unqualified-id.
6548 bool AllowConstructorName;
6549 bool AllowDeductionGuide;
6550 if (D.getDeclSpec().hasTypeSpecifier()) {
6551 AllowConstructorName = false;
6552 AllowDeductionGuide = false;
6553 } else if (D.getCXXScopeSpec().isSet()) {
6554 AllowConstructorName = (D.getContext() == DeclaratorContext::File ||
6555 D.getContext() == DeclaratorContext::Member);
6556 AllowDeductionGuide = false;
6557 } else {
6558 AllowConstructorName = (D.getContext() == DeclaratorContext::Member);
6559 AllowDeductionGuide = (D.getContext() == DeclaratorContext::File ||
6560 D.getContext() == DeclaratorContext::Member);
6561 }
6562
6563 bool HadScope = D.getCXXScopeSpec().isValid();
6564 if (ParseUnqualifiedId(D.getCXXScopeSpec(),
6565 /*ObjectType=*/nullptr,
6566 /*ObjectHadErrors=*/false,
6567 /*EnteringContext=*/true,
6568 /*AllowDestructorName=*/true, AllowConstructorName,
6569 AllowDeductionGuide, nullptr, D.getName()) ||
6570 // Once we're past the identifier, if the scope was bad, mark the
6571 // whole declarator bad.
6572 D.getCXXScopeSpec().isInvalid()) {
6573 D.SetIdentifier(nullptr, Tok.getLocation());
6574 D.setInvalidType(true);
6575 } else {
6576 // ParseUnqualifiedId might have parsed a scope specifier during error
6577 // recovery. If it did so, enter that scope.
6578 if (!HadScope && D.getCXXScopeSpec().isValid() &&
6579 Actions.ShouldEnterDeclaratorScope(getCurScope(),
6580 D.getCXXScopeSpec()))
6581 DeclScopeObj.EnterDeclaratorScope();
6582
6583 // Parsed the unqualified-id; update range information and move along.
6584 if (D.getSourceRange().getBegin().isInvalid())
6585 D.SetRangeBegin(D.getName().getSourceRange().getBegin());
6586 D.SetRangeEnd(D.getName().getSourceRange().getEnd());
6587 }
6588 goto PastIdentifier;
6589 }
6590
6591 if (D.getCXXScopeSpec().isNotEmpty()) {
6592 // We have a scope specifier but no following unqualified-id.
6593 Diag(PP.getLocForEndOfToken(D.getCXXScopeSpec().getEndLoc()),
6594 diag::err_expected_unqualified_id)
6595 << /*C++*/1;
6596 D.SetIdentifier(nullptr, Tok.getLocation());
6597 goto PastIdentifier;
6598 }
6599 } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
6600 assert(!getLangOpts().CPlusPlus &&
6601 "There's a C++-specific check for tok::identifier above");
6602 assert(Tok.getIdentifierInfo() && "Not an identifier?");
6603 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
6604 D.SetRangeEnd(Tok.getLocation());
6605 ConsumeToken();
6606 goto PastIdentifier;
6607 } else if (Tok.is(tok::identifier) && !D.mayHaveIdentifier()) {
6608 // We're not allowed an identifier here, but we got one. Try to figure out
6609 // if the user was trying to attach a name to the type, or whether the name
6610 // is some unrelated trailing syntax.
6611 bool DiagnoseIdentifier = false;
6612 if (D.hasGroupingParens())
6613 // An identifier within parens is unlikely to be intended to be anything
6614 // other than a name being "declared".
6615 DiagnoseIdentifier = true;
6616 else if (D.getContext() == DeclaratorContext::TemplateArg)
6617 // T<int N> is an accidental identifier; T<int N indicates a missing '>'.
6618 DiagnoseIdentifier =
6619 NextToken().isOneOf(tok::comma, tok::greater, tok::greatergreater);
6620 else if (D.getContext() == DeclaratorContext::AliasDecl ||
6621 D.getContext() == DeclaratorContext::AliasTemplate)
6622 // The most likely error is that the ';' was forgotten.
6623 DiagnoseIdentifier = NextToken().isOneOf(tok::comma, tok::semi);
6624 else if ((D.getContext() == DeclaratorContext::TrailingReturn ||
6625 D.getContext() == DeclaratorContext::TrailingReturnVar) &&
6626 !isCXX11VirtSpecifier(Tok))
6627 DiagnoseIdentifier = NextToken().isOneOf(
6628 tok::comma, tok::semi, tok::equal, tok::l_brace, tok::kw_try);
6629 if (DiagnoseIdentifier) {
6630 Diag(Tok.getLocation(), diag::err_unexpected_unqualified_id)
6631 << FixItHint::CreateRemoval(Tok.getLocation());
6632 D.SetIdentifier(nullptr, Tok.getLocation());
6633 ConsumeToken();
6634 goto PastIdentifier;
6635 }
6636 }
6637
6638 if (Tok.is(tok::l_paren)) {
6639 // If this might be an abstract-declarator followed by a direct-initializer,
6640 // check whether this is a valid declarator chunk. If it can't be, assume
6641 // that it's an initializer instead.
6642 if (D.mayOmitIdentifier() && D.mayBeFollowedByCXXDirectInit()) {
6643 RevertingTentativeParsingAction PA(*this);
6644 if (TryParseDeclarator(true, D.mayHaveIdentifier(), true,
6645 D.getDeclSpec().getTypeSpecType() == TST_auto) ==
6646 TPResult::False) {
6647 D.SetIdentifier(nullptr, Tok.getLocation());
6648 goto PastIdentifier;
6649 }
6650 }
6651
6652 // direct-declarator: '(' declarator ')'
6653 // direct-declarator: '(' attributes declarator ')'
6654 // Example: 'char (*X)' or 'int (*XX)(void)'
6655 ParseParenDeclarator(D);
6656
6657 // If the declarator was parenthesized, we entered the declarator
6658 // scope when parsing the parenthesized declarator, then exited
6659 // the scope already. Re-enter the scope, if we need to.
6660 if (D.getCXXScopeSpec().isSet()) {
6661 // If there was an error parsing parenthesized declarator, declarator
6662 // scope may have been entered before. Don't do it again.
6663 if (!D.isInvalidType() &&
6664 Actions.ShouldEnterDeclaratorScope(getCurScope(),
6665 D.getCXXScopeSpec()))
6666 // Change the declaration context for name lookup, until this function
6667 // is exited (and the declarator has been parsed).
6668 DeclScopeObj.EnterDeclaratorScope();
6669 }
6670 } else if (D.mayOmitIdentifier()) {
6671 // This could be something simple like "int" (in which case the declarator
6672 // portion is empty), if an abstract-declarator is allowed.
6673 D.SetIdentifier(nullptr, Tok.getLocation());
6674
6675 // The grammar for abstract-pack-declarator does not allow grouping parens.
6676 // FIXME: Revisit this once core issue 1488 is resolved.
6677 if (D.hasEllipsis() && D.hasGroupingParens())
6678 Diag(PP.getLocForEndOfToken(D.getEllipsisLoc()),
6679 diag::ext_abstract_pack_declarator_parens);
6680 } else {
6681 if (Tok.getKind() == tok::annot_pragma_parser_crash)
6682 LLVM_BUILTIN_TRAP;
6683 if (Tok.is(tok::l_square))
6684 return ParseMisplacedBracketDeclarator(D);
6685 if (D.getContext() == DeclaratorContext::Member) {
6686 // Objective-C++: Detect C++ keywords and try to prevent further errors by
6687 // treating these keyword as valid member names.
6688 if (getLangOpts().ObjC && getLangOpts().CPlusPlus &&
6689 !Tok.isAnnotation() && Tok.getIdentifierInfo() &&
6690 Tok.getIdentifierInfo()->isCPlusPlusKeyword(getLangOpts())) {
6691 Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
6692 diag::err_expected_member_name_or_semi_objcxx_keyword)
6693 << Tok.getIdentifierInfo()
6694 << (D.getDeclSpec().isEmpty() ? SourceRange()
6695 : D.getDeclSpec().getSourceRange());
6696 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
6697 D.SetRangeEnd(Tok.getLocation());
6698 ConsumeToken();
6699 goto PastIdentifier;
6700 }
6701 Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
6702 diag::err_expected_member_name_or_semi)
6703 << (D.getDeclSpec().isEmpty() ? SourceRange()
6704 : D.getDeclSpec().getSourceRange());
6705 } else {
6706 if (Tok.getKind() == tok::TokenKind::kw_while) {
6707 Diag(Tok, diag::err_while_loop_outside_of_a_function);
6708 } else if (getLangOpts().CPlusPlus) {
6709 if (Tok.isOneOf(tok::period, tok::arrow))
6710 Diag(Tok, diag::err_invalid_operator_on_type) << Tok.is(tok::arrow);
6711 else {
6712 SourceLocation Loc = D.getCXXScopeSpec().getEndLoc();
6713 if (Tok.isAtStartOfLine() && Loc.isValid())
6714 Diag(PP.getLocForEndOfToken(Loc), diag::err_expected_unqualified_id)
6715 << getLangOpts().CPlusPlus;
6716 else
6717 Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
6718 diag::err_expected_unqualified_id)
6719 << getLangOpts().CPlusPlus;
6720 }
6721 } else {
6722 Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
6723 diag::err_expected_either)
6724 << tok::identifier << tok::l_paren;
6725 }
6726 }
6727 D.SetIdentifier(nullptr, Tok.getLocation());
6728 D.setInvalidType(true);
6729 }
6730
6731 PastIdentifier:
6732 assert(D.isPastIdentifier() &&
6733 "Haven't past the location of the identifier yet?");
6734
6735 // Don't parse attributes unless we have parsed an unparenthesized name.
6736 if (D.hasName() && !D.getNumTypeObjects())
6737 MaybeParseCXX11Attributes(D);
6738
6739 while (true) {
6740 if (Tok.is(tok::l_paren)) {
6741 bool IsFunctionDeclaration = D.isFunctionDeclaratorAFunctionDeclaration();
6742 // Enter function-declaration scope, limiting any declarators to the
6743 // function prototype scope, including parameter declarators.
6744 ParseScope PrototypeScope(this,
6745 Scope::FunctionPrototypeScope|Scope::DeclScope|
6746 (IsFunctionDeclaration
6747 ? Scope::FunctionDeclarationScope : 0));
6748
6749 // The paren may be part of a C++ direct initializer, eg. "int x(1);".
6750 // In such a case, check if we actually have a function declarator; if it
6751 // is not, the declarator has been fully parsed.
6752 bool IsAmbiguous = false;
6753 if (getLangOpts().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
6754 // C++2a [temp.res]p5
6755 // A qualified-id is assumed to name a type if
6756 // - [...]
6757 // - it is a decl-specifier of the decl-specifier-seq of a
6758 // - [...]
6759 // - parameter-declaration in a member-declaration [...]
6760 // - parameter-declaration in a declarator of a function or function
6761 // template declaration whose declarator-id is qualified [...]
6762 auto AllowImplicitTypename = ImplicitTypenameContext::No;
6763 if (D.getCXXScopeSpec().isSet())
6764 AllowImplicitTypename =
6765 (ImplicitTypenameContext)Actions.isDeclaratorFunctionLike(D);
6766 else if (D.getContext() == DeclaratorContext::Member) {
6767 AllowImplicitTypename = ImplicitTypenameContext::Yes;
6768 }
6769
6770 // The name of the declarator, if any, is tentatively declared within
6771 // a possible direct initializer.
6772 TentativelyDeclaredIdentifiers.push_back(D.getIdentifier());
6773 bool IsFunctionDecl =
6774 isCXXFunctionDeclarator(&IsAmbiguous, AllowImplicitTypename);
6775 TentativelyDeclaredIdentifiers.pop_back();
6776 if (!IsFunctionDecl)
6777 break;
6778 }
6779 ParsedAttributes attrs(AttrFactory);
6780 BalancedDelimiterTracker T(*this, tok::l_paren);
6781 T.consumeOpen();
6782 if (IsFunctionDeclaration)
6783 Actions.ActOnStartFunctionDeclarationDeclarator(D,
6784 TemplateParameterDepth);
6785 ParseFunctionDeclarator(D, attrs, T, IsAmbiguous);
6786 if (IsFunctionDeclaration)
6787 Actions.ActOnFinishFunctionDeclarationDeclarator(D);
6788 PrototypeScope.Exit();
6789 } else if (Tok.is(tok::l_square)) {
6790 ParseBracketDeclarator(D);
6791 } else if (Tok.isRegularKeywordAttribute()) {
6792 // For consistency with attribute parsing.
6793 Diag(Tok, diag::err_keyword_not_allowed) << Tok.getIdentifierInfo();
6794 bool TakesArgs = doesKeywordAttributeTakeArgs(Tok.getKind());
6795 ConsumeToken();
6796 if (TakesArgs) {
6797 BalancedDelimiterTracker T(*this, tok::l_paren);
6798 if (!T.consumeOpen())
6799 T.skipToEnd();
6800 }
6801 } else if (Tok.is(tok::kw_requires) && D.hasGroupingParens()) {
6802 // This declarator is declaring a function, but the requires clause is
6803 // in the wrong place:
6804 // void (f() requires true);
6805 // instead of
6806 // void f() requires true;
6807 // or
6808 // void (f()) requires true;
6809 Diag(Tok, diag::err_requires_clause_inside_parens);
6810 ConsumeToken();
6811 ExprResult TrailingRequiresClause = Actions.CorrectDelayedTyposInExpr(
6812 ParseConstraintLogicalOrExpression(/*IsTrailingRequiresClause=*/true));
6813 if (TrailingRequiresClause.isUsable() && D.isFunctionDeclarator() &&
6814 !D.hasTrailingRequiresClause())
6815 // We're already ill-formed if we got here but we'll accept it anyway.
6816 D.setTrailingRequiresClause(TrailingRequiresClause.get());
6817 } else {
6818 break;
6819 }
6820 }
6821 }
6822
ParseDecompositionDeclarator(Declarator & D)6823 void Parser::ParseDecompositionDeclarator(Declarator &D) {
6824 assert(Tok.is(tok::l_square));
6825
6826 // If this doesn't look like a structured binding, maybe it's a misplaced
6827 // array declarator.
6828 // FIXME: Consume the l_square first so we don't need extra lookahead for
6829 // this.
6830 if (!(NextToken().is(tok::identifier) &&
6831 GetLookAheadToken(2).isOneOf(tok::comma, tok::r_square)) &&
6832 !(NextToken().is(tok::r_square) &&
6833 GetLookAheadToken(2).isOneOf(tok::equal, tok::l_brace)))
6834 return ParseMisplacedBracketDeclarator(D);
6835
6836 BalancedDelimiterTracker T(*this, tok::l_square);
6837 T.consumeOpen();
6838
6839 SmallVector<DecompositionDeclarator::Binding, 32> Bindings;
6840 while (Tok.isNot(tok::r_square)) {
6841 if (!Bindings.empty()) {
6842 if (Tok.is(tok::comma))
6843 ConsumeToken();
6844 else {
6845 if (Tok.is(tok::identifier)) {
6846 SourceLocation EndLoc = getEndOfPreviousToken();
6847 Diag(EndLoc, diag::err_expected)
6848 << tok::comma << FixItHint::CreateInsertion(EndLoc, ",");
6849 } else {
6850 Diag(Tok, diag::err_expected_comma_or_rsquare);
6851 }
6852
6853 SkipUntil(tok::r_square, tok::comma, tok::identifier,
6854 StopAtSemi | StopBeforeMatch);
6855 if (Tok.is(tok::comma))
6856 ConsumeToken();
6857 else if (Tok.isNot(tok::identifier))
6858 break;
6859 }
6860 }
6861
6862 if (Tok.isNot(tok::identifier)) {
6863 Diag(Tok, diag::err_expected) << tok::identifier;
6864 break;
6865 }
6866
6867 Bindings.push_back({Tok.getIdentifierInfo(), Tok.getLocation()});
6868 ConsumeToken();
6869 }
6870
6871 if (Tok.isNot(tok::r_square))
6872 // We've already diagnosed a problem here.
6873 T.skipToEnd();
6874 else {
6875 // C++17 does not allow the identifier-list in a structured binding
6876 // to be empty.
6877 if (Bindings.empty())
6878 Diag(Tok.getLocation(), diag::ext_decomp_decl_empty);
6879
6880 T.consumeClose();
6881 }
6882
6883 return D.setDecompositionBindings(T.getOpenLocation(), Bindings,
6884 T.getCloseLocation());
6885 }
6886
6887 /// ParseParenDeclarator - We parsed the declarator D up to a paren. This is
6888 /// only called before the identifier, so these are most likely just grouping
6889 /// parens for precedence. If we find that these are actually function
6890 /// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
6891 ///
6892 /// direct-declarator:
6893 /// '(' declarator ')'
6894 /// [GNU] '(' attributes declarator ')'
6895 /// direct-declarator '(' parameter-type-list ')'
6896 /// direct-declarator '(' identifier-list[opt] ')'
6897 /// [GNU] direct-declarator '(' parameter-forward-declarations
6898 /// parameter-type-list[opt] ')'
6899 ///
ParseParenDeclarator(Declarator & D)6900 void Parser::ParseParenDeclarator(Declarator &D) {
6901 BalancedDelimiterTracker T(*this, tok::l_paren);
6902 T.consumeOpen();
6903
6904 assert(!D.isPastIdentifier() && "Should be called before passing identifier");
6905
6906 // Eat any attributes before we look at whether this is a grouping or function
6907 // declarator paren. If this is a grouping paren, the attribute applies to
6908 // the type being built up, for example:
6909 // int (__attribute__(()) *x)(long y)
6910 // If this ends up not being a grouping paren, the attribute applies to the
6911 // first argument, for example:
6912 // int (__attribute__(()) int x)
6913 // In either case, we need to eat any attributes to be able to determine what
6914 // sort of paren this is.
6915 //
6916 ParsedAttributes attrs(AttrFactory);
6917 bool RequiresArg = false;
6918 if (Tok.is(tok::kw___attribute)) {
6919 ParseGNUAttributes(attrs);
6920
6921 // We require that the argument list (if this is a non-grouping paren) be
6922 // present even if the attribute list was empty.
6923 RequiresArg = true;
6924 }
6925
6926 // Eat any Microsoft extensions.
6927 ParseMicrosoftTypeAttributes(attrs);
6928
6929 // Eat any Borland extensions.
6930 if (Tok.is(tok::kw___pascal))
6931 ParseBorlandTypeAttributes(attrs);
6932
6933 // If we haven't past the identifier yet (or where the identifier would be
6934 // stored, if this is an abstract declarator), then this is probably just
6935 // grouping parens. However, if this could be an abstract-declarator, then
6936 // this could also be the start of function arguments (consider 'void()').
6937 bool isGrouping;
6938
6939 if (!D.mayOmitIdentifier()) {
6940 // If this can't be an abstract-declarator, this *must* be a grouping
6941 // paren, because we haven't seen the identifier yet.
6942 isGrouping = true;
6943 } else if (Tok.is(tok::r_paren) || // 'int()' is a function.
6944 (getLangOpts().CPlusPlus && Tok.is(tok::ellipsis) &&
6945 NextToken().is(tok::r_paren)) || // C++ int(...)
6946 isDeclarationSpecifier(
6947 ImplicitTypenameContext::No) || // 'int(int)' is a function.
6948 isCXX11AttributeSpecifier()) { // 'int([[]]int)' is a function.
6949 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
6950 // considered to be a type, not a K&R identifier-list.
6951 isGrouping = false;
6952 } else {
6953 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
6954 isGrouping = true;
6955 }
6956
6957 // If this is a grouping paren, handle:
6958 // direct-declarator: '(' declarator ')'
6959 // direct-declarator: '(' attributes declarator ')'
6960 if (isGrouping) {
6961 SourceLocation EllipsisLoc = D.getEllipsisLoc();
6962 D.setEllipsisLoc(SourceLocation());
6963
6964 bool hadGroupingParens = D.hasGroupingParens();
6965 D.setGroupingParens(true);
6966 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
6967 // Match the ')'.
6968 T.consumeClose();
6969 D.AddTypeInfo(
6970 DeclaratorChunk::getParen(T.getOpenLocation(), T.getCloseLocation()),
6971 std::move(attrs), T.getCloseLocation());
6972
6973 D.setGroupingParens(hadGroupingParens);
6974
6975 // An ellipsis cannot be placed outside parentheses.
6976 if (EllipsisLoc.isValid())
6977 DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
6978
6979 return;
6980 }
6981
6982 // Okay, if this wasn't a grouping paren, it must be the start of a function
6983 // argument list. Recognize that this declarator will never have an
6984 // identifier (and remember where it would have been), then call into
6985 // ParseFunctionDeclarator to handle of argument list.
6986 D.SetIdentifier(nullptr, Tok.getLocation());
6987
6988 // Enter function-declaration scope, limiting any declarators to the
6989 // function prototype scope, including parameter declarators.
6990 ParseScope PrototypeScope(this,
6991 Scope::FunctionPrototypeScope | Scope::DeclScope |
6992 (D.isFunctionDeclaratorAFunctionDeclaration()
6993 ? Scope::FunctionDeclarationScope : 0));
6994 ParseFunctionDeclarator(D, attrs, T, false, RequiresArg);
6995 PrototypeScope.Exit();
6996 }
6997
InitCXXThisScopeForDeclaratorIfRelevant(const Declarator & D,const DeclSpec & DS,std::optional<Sema::CXXThisScopeRAII> & ThisScope)6998 void Parser::InitCXXThisScopeForDeclaratorIfRelevant(
6999 const Declarator &D, const DeclSpec &DS,
7000 std::optional<Sema::CXXThisScopeRAII> &ThisScope) {
7001 // C++11 [expr.prim.general]p3:
7002 // If a declaration declares a member function or member function
7003 // template of a class X, the expression this is a prvalue of type
7004 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
7005 // and the end of the function-definition, member-declarator, or
7006 // declarator.
7007 // FIXME: currently, "static" case isn't handled correctly.
7008 bool IsCXX11MemberFunction =
7009 getLangOpts().CPlusPlus11 &&
7010 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
7011 (D.getContext() == DeclaratorContext::Member
7012 ? !D.getDeclSpec().isFriendSpecified()
7013 : D.getContext() == DeclaratorContext::File &&
7014 D.getCXXScopeSpec().isValid() &&
7015 Actions.CurContext->isRecord());
7016 if (!IsCXX11MemberFunction)
7017 return;
7018
7019 Qualifiers Q = Qualifiers::fromCVRUMask(DS.getTypeQualifiers());
7020 if (D.getDeclSpec().hasConstexprSpecifier() && !getLangOpts().CPlusPlus14)
7021 Q.addConst();
7022 // FIXME: Collect C++ address spaces.
7023 // If there are multiple different address spaces, the source is invalid.
7024 // Carry on using the first addr space for the qualifiers of 'this'.
7025 // The diagnostic will be given later while creating the function
7026 // prototype for the method.
7027 if (getLangOpts().OpenCLCPlusPlus) {
7028 for (ParsedAttr &attr : DS.getAttributes()) {
7029 LangAS ASIdx = attr.asOpenCLLangAS();
7030 if (ASIdx != LangAS::Default) {
7031 Q.addAddressSpace(ASIdx);
7032 break;
7033 }
7034 }
7035 }
7036 ThisScope.emplace(Actions, dyn_cast<CXXRecordDecl>(Actions.CurContext), Q,
7037 IsCXX11MemberFunction);
7038 }
7039
7040 /// ParseFunctionDeclarator - We are after the identifier and have parsed the
7041 /// declarator D up to a paren, which indicates that we are parsing function
7042 /// arguments.
7043 ///
7044 /// If FirstArgAttrs is non-null, then the caller parsed those attributes
7045 /// immediately after the open paren - they will be applied to the DeclSpec
7046 /// of the first parameter.
7047 ///
7048 /// If RequiresArg is true, then the first argument of the function is required
7049 /// to be present and required to not be an identifier list.
7050 ///
7051 /// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],
7052 /// (C++11) ref-qualifier[opt], exception-specification[opt],
7053 /// (C++11) attribute-specifier-seq[opt], (C++11) trailing-return-type[opt] and
7054 /// (C++2a) the trailing requires-clause.
7055 ///
7056 /// [C++11] exception-specification:
7057 /// dynamic-exception-specification
7058 /// noexcept-specification
7059 ///
ParseFunctionDeclarator(Declarator & D,ParsedAttributes & FirstArgAttrs,BalancedDelimiterTracker & Tracker,bool IsAmbiguous,bool RequiresArg)7060 void Parser::ParseFunctionDeclarator(Declarator &D,
7061 ParsedAttributes &FirstArgAttrs,
7062 BalancedDelimiterTracker &Tracker,
7063 bool IsAmbiguous,
7064 bool RequiresArg) {
7065 assert(getCurScope()->isFunctionPrototypeScope() &&
7066 "Should call from a Function scope");
7067 // lparen is already consumed!
7068 assert(D.isPastIdentifier() && "Should not call before identifier!");
7069
7070 // This should be true when the function has typed arguments.
7071 // Otherwise, it is treated as a K&R-style function.
7072 bool HasProto = false;
7073 // Build up an array of information about the parsed arguments.
7074 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
7075 // Remember where we see an ellipsis, if any.
7076 SourceLocation EllipsisLoc;
7077
7078 DeclSpec DS(AttrFactory);
7079 bool RefQualifierIsLValueRef = true;
7080 SourceLocation RefQualifierLoc;
7081 ExceptionSpecificationType ESpecType = EST_None;
7082 SourceRange ESpecRange;
7083 SmallVector<ParsedType, 2> DynamicExceptions;
7084 SmallVector<SourceRange, 2> DynamicExceptionRanges;
7085 ExprResult NoexceptExpr;
7086 CachedTokens *ExceptionSpecTokens = nullptr;
7087 ParsedAttributes FnAttrs(AttrFactory);
7088 TypeResult TrailingReturnType;
7089 SourceLocation TrailingReturnTypeLoc;
7090
7091 /* LocalEndLoc is the end location for the local FunctionTypeLoc.
7092 EndLoc is the end location for the function declarator.
7093 They differ for trailing return types. */
7094 SourceLocation StartLoc, LocalEndLoc, EndLoc;
7095 SourceLocation LParenLoc, RParenLoc;
7096 LParenLoc = Tracker.getOpenLocation();
7097 StartLoc = LParenLoc;
7098
7099 if (isFunctionDeclaratorIdentifierList()) {
7100 if (RequiresArg)
7101 Diag(Tok, diag::err_argument_required_after_attribute);
7102
7103 ParseFunctionDeclaratorIdentifierList(D, ParamInfo);
7104
7105 Tracker.consumeClose();
7106 RParenLoc = Tracker.getCloseLocation();
7107 LocalEndLoc = RParenLoc;
7108 EndLoc = RParenLoc;
7109
7110 // If there are attributes following the identifier list, parse them and
7111 // prohibit them.
7112 MaybeParseCXX11Attributes(FnAttrs);
7113 ProhibitAttributes(FnAttrs);
7114 } else {
7115 if (Tok.isNot(tok::r_paren))
7116 ParseParameterDeclarationClause(D, FirstArgAttrs, ParamInfo, EllipsisLoc);
7117 else if (RequiresArg)
7118 Diag(Tok, diag::err_argument_required_after_attribute);
7119
7120 // OpenCL disallows functions without a prototype, but it doesn't enforce
7121 // strict prototypes as in C23 because it allows a function definition to
7122 // have an identifier list. See OpenCL 3.0 6.11/g for more details.
7123 HasProto = ParamInfo.size() || getLangOpts().requiresStrictPrototypes() ||
7124 getLangOpts().OpenCL;
7125
7126 // If we have the closing ')', eat it.
7127 Tracker.consumeClose();
7128 RParenLoc = Tracker.getCloseLocation();
7129 LocalEndLoc = RParenLoc;
7130 EndLoc = RParenLoc;
7131
7132 if (getLangOpts().CPlusPlus) {
7133 // FIXME: Accept these components in any order, and produce fixits to
7134 // correct the order if the user gets it wrong. Ideally we should deal
7135 // with the pure-specifier in the same way.
7136
7137 // Parse cv-qualifier-seq[opt].
7138 ParseTypeQualifierListOpt(DS, AR_NoAttributesParsed,
7139 /*AtomicAllowed*/ false,
7140 /*IdentifierRequired=*/false,
7141 llvm::function_ref<void()>([&]() {
7142 Actions.CodeCompleteFunctionQualifiers(DS, D);
7143 }));
7144 if (!DS.getSourceRange().getEnd().isInvalid()) {
7145 EndLoc = DS.getSourceRange().getEnd();
7146 }
7147
7148 // Parse ref-qualifier[opt].
7149 if (ParseRefQualifier(RefQualifierIsLValueRef, RefQualifierLoc))
7150 EndLoc = RefQualifierLoc;
7151
7152 std::optional<Sema::CXXThisScopeRAII> ThisScope;
7153 InitCXXThisScopeForDeclaratorIfRelevant(D, DS, ThisScope);
7154
7155 // Parse exception-specification[opt].
7156 // FIXME: Per [class.mem]p6, all exception-specifications at class scope
7157 // should be delayed, including those for non-members (eg, friend
7158 // declarations). But only applying this to member declarations is
7159 // consistent with what other implementations do.
7160 bool Delayed = D.isFirstDeclarationOfMember() &&
7161 D.isFunctionDeclaratorAFunctionDeclaration();
7162 if (Delayed && Actions.isLibstdcxxEagerExceptionSpecHack(D) &&
7163 GetLookAheadToken(0).is(tok::kw_noexcept) &&
7164 GetLookAheadToken(1).is(tok::l_paren) &&
7165 GetLookAheadToken(2).is(tok::kw_noexcept) &&
7166 GetLookAheadToken(3).is(tok::l_paren) &&
7167 GetLookAheadToken(4).is(tok::identifier) &&
7168 GetLookAheadToken(4).getIdentifierInfo()->isStr("swap")) {
7169 // HACK: We've got an exception-specification
7170 // noexcept(noexcept(swap(...)))
7171 // or
7172 // noexcept(noexcept(swap(...)) && noexcept(swap(...)))
7173 // on a 'swap' member function. This is a libstdc++ bug; the lookup
7174 // for 'swap' will only find the function we're currently declaring,
7175 // whereas it expects to find a non-member swap through ADL. Turn off
7176 // delayed parsing to give it a chance to find what it expects.
7177 Delayed = false;
7178 }
7179 ESpecType = tryParseExceptionSpecification(Delayed,
7180 ESpecRange,
7181 DynamicExceptions,
7182 DynamicExceptionRanges,
7183 NoexceptExpr,
7184 ExceptionSpecTokens);
7185 if (ESpecType != EST_None)
7186 EndLoc = ESpecRange.getEnd();
7187
7188 // Parse attribute-specifier-seq[opt]. Per DR 979 and DR 1297, this goes
7189 // after the exception-specification.
7190 MaybeParseCXX11Attributes(FnAttrs);
7191
7192 // Parse trailing-return-type[opt].
7193 LocalEndLoc = EndLoc;
7194 if (getLangOpts().CPlusPlus11 && Tok.is(tok::arrow)) {
7195 Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);
7196 if (D.getDeclSpec().getTypeSpecType() == TST_auto)
7197 StartLoc = D.getDeclSpec().getTypeSpecTypeLoc();
7198 LocalEndLoc = Tok.getLocation();
7199 SourceRange Range;
7200 TrailingReturnType =
7201 ParseTrailingReturnType(Range, D.mayBeFollowedByCXXDirectInit());
7202 TrailingReturnTypeLoc = Range.getBegin();
7203 EndLoc = Range.getEnd();
7204 }
7205 } else {
7206 MaybeParseCXX11Attributes(FnAttrs);
7207 }
7208 }
7209
7210 // Collect non-parameter declarations from the prototype if this is a function
7211 // declaration. They will be moved into the scope of the function. Only do
7212 // this in C and not C++, where the decls will continue to live in the
7213 // surrounding context.
7214 SmallVector<NamedDecl *, 0> DeclsInPrototype;
7215 if (getCurScope()->isFunctionDeclarationScope() && !getLangOpts().CPlusPlus) {
7216 for (Decl *D : getCurScope()->decls()) {
7217 NamedDecl *ND = dyn_cast<NamedDecl>(D);
7218 if (!ND || isa<ParmVarDecl>(ND))
7219 continue;
7220 DeclsInPrototype.push_back(ND);
7221 }
7222 // Sort DeclsInPrototype based on raw encoding of the source location.
7223 // Scope::decls() is iterating over a SmallPtrSet so sort the Decls before
7224 // moving to DeclContext. This provides a stable ordering for traversing
7225 // Decls in DeclContext, which is important for tasks like ASTWriter for
7226 // deterministic output.
7227 llvm::sort(DeclsInPrototype, [](Decl *D1, Decl *D2) {
7228 return D1->getLocation().getRawEncoding() <
7229 D2->getLocation().getRawEncoding();
7230 });
7231 }
7232
7233 // Remember that we parsed a function type, and remember the attributes.
7234 D.AddTypeInfo(DeclaratorChunk::getFunction(
7235 HasProto, IsAmbiguous, LParenLoc, ParamInfo.data(),
7236 ParamInfo.size(), EllipsisLoc, RParenLoc,
7237 RefQualifierIsLValueRef, RefQualifierLoc,
7238 /*MutableLoc=*/SourceLocation(),
7239 ESpecType, ESpecRange, DynamicExceptions.data(),
7240 DynamicExceptionRanges.data(), DynamicExceptions.size(),
7241 NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
7242 ExceptionSpecTokens, DeclsInPrototype, StartLoc,
7243 LocalEndLoc, D, TrailingReturnType, TrailingReturnTypeLoc,
7244 &DS),
7245 std::move(FnAttrs), EndLoc);
7246 }
7247
7248 /// ParseRefQualifier - Parses a member function ref-qualifier. Returns
7249 /// true if a ref-qualifier is found.
ParseRefQualifier(bool & RefQualifierIsLValueRef,SourceLocation & RefQualifierLoc)7250 bool Parser::ParseRefQualifier(bool &RefQualifierIsLValueRef,
7251 SourceLocation &RefQualifierLoc) {
7252 if (Tok.isOneOf(tok::amp, tok::ampamp)) {
7253 Diag(Tok, getLangOpts().CPlusPlus11 ?
7254 diag::warn_cxx98_compat_ref_qualifier :
7255 diag::ext_ref_qualifier);
7256
7257 RefQualifierIsLValueRef = Tok.is(tok::amp);
7258 RefQualifierLoc = ConsumeToken();
7259 return true;
7260 }
7261 return false;
7262 }
7263
7264 /// isFunctionDeclaratorIdentifierList - This parameter list may have an
7265 /// identifier list form for a K&R-style function: void foo(a,b,c)
7266 ///
7267 /// Note that identifier-lists are only allowed for normal declarators, not for
7268 /// abstract-declarators.
isFunctionDeclaratorIdentifierList()7269 bool Parser::isFunctionDeclaratorIdentifierList() {
7270 return !getLangOpts().requiresStrictPrototypes()
7271 && Tok.is(tok::identifier)
7272 && !TryAltiVecVectorToken()
7273 // K&R identifier lists can't have typedefs as identifiers, per C99
7274 // 6.7.5.3p11.
7275 && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename))
7276 // Identifier lists follow a really simple grammar: the identifiers can
7277 // be followed *only* by a ", identifier" or ")". However, K&R
7278 // identifier lists are really rare in the brave new modern world, and
7279 // it is very common for someone to typo a type in a non-K&R style
7280 // list. If we are presented with something like: "void foo(intptr x,
7281 // float y)", we don't want to start parsing the function declarator as
7282 // though it is a K&R style declarator just because intptr is an
7283 // invalid type.
7284 //
7285 // To handle this, we check to see if the token after the first
7286 // identifier is a "," or ")". Only then do we parse it as an
7287 // identifier list.
7288 && (!Tok.is(tok::eof) &&
7289 (NextToken().is(tok::comma) || NextToken().is(tok::r_paren)));
7290 }
7291
7292 /// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
7293 /// we found a K&R-style identifier list instead of a typed parameter list.
7294 ///
7295 /// After returning, ParamInfo will hold the parsed parameters.
7296 ///
7297 /// identifier-list: [C99 6.7.5]
7298 /// identifier
7299 /// identifier-list ',' identifier
7300 ///
ParseFunctionDeclaratorIdentifierList(Declarator & D,SmallVectorImpl<DeclaratorChunk::ParamInfo> & ParamInfo)7301 void Parser::ParseFunctionDeclaratorIdentifierList(
7302 Declarator &D,
7303 SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo) {
7304 // We should never reach this point in C23 or C++.
7305 assert(!getLangOpts().requiresStrictPrototypes() &&
7306 "Cannot parse an identifier list in C23 or C++");
7307
7308 // If there was no identifier specified for the declarator, either we are in
7309 // an abstract-declarator, or we are in a parameter declarator which was found
7310 // to be abstract. In abstract-declarators, identifier lists are not valid:
7311 // diagnose this.
7312 if (!D.getIdentifier())
7313 Diag(Tok, diag::ext_ident_list_in_param);
7314
7315 // Maintain an efficient lookup of params we have seen so far.
7316 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
7317
7318 do {
7319 // If this isn't an identifier, report the error and skip until ')'.
7320 if (Tok.isNot(tok::identifier)) {
7321 Diag(Tok, diag::err_expected) << tok::identifier;
7322 SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
7323 // Forget we parsed anything.
7324 ParamInfo.clear();
7325 return;
7326 }
7327
7328 IdentifierInfo *ParmII = Tok.getIdentifierInfo();
7329
7330 // Reject 'typedef int y; int test(x, y)', but continue parsing.
7331 if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
7332 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
7333
7334 // Verify that the argument identifier has not already been mentioned.
7335 if (!ParamsSoFar.insert(ParmII).second) {
7336 Diag(Tok, diag::err_param_redefinition) << ParmII;
7337 } else {
7338 // Remember this identifier in ParamInfo.
7339 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
7340 Tok.getLocation(),
7341 nullptr));
7342 }
7343
7344 // Eat the identifier.
7345 ConsumeToken();
7346 // The list continues if we see a comma.
7347 } while (TryConsumeToken(tok::comma));
7348 }
7349
7350 /// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
7351 /// after the opening parenthesis. This function will not parse a K&R-style
7352 /// identifier list.
7353 ///
7354 /// DeclContext is the context of the declarator being parsed. If FirstArgAttrs
7355 /// is non-null, then the caller parsed those attributes immediately after the
7356 /// open paren - they will be applied to the DeclSpec of the first parameter.
7357 ///
7358 /// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
7359 /// be the location of the ellipsis, if any was parsed.
7360 ///
7361 /// parameter-type-list: [C99 6.7.5]
7362 /// parameter-list
7363 /// parameter-list ',' '...'
7364 /// [C++] parameter-list '...'
7365 ///
7366 /// parameter-list: [C99 6.7.5]
7367 /// parameter-declaration
7368 /// parameter-list ',' parameter-declaration
7369 ///
7370 /// parameter-declaration: [C99 6.7.5]
7371 /// declaration-specifiers declarator
7372 /// [C++] declaration-specifiers declarator '=' assignment-expression
7373 /// [C++11] initializer-clause
7374 /// [GNU] declaration-specifiers declarator attributes
7375 /// declaration-specifiers abstract-declarator[opt]
7376 /// [C++] declaration-specifiers abstract-declarator[opt]
7377 /// '=' assignment-expression
7378 /// [GNU] declaration-specifiers abstract-declarator[opt] attributes
7379 /// [C++11] attribute-specifier-seq parameter-declaration
7380 /// [C++2b] attribute-specifier-seq 'this' parameter-declaration
7381 ///
ParseParameterDeclarationClause(DeclaratorContext DeclaratorCtx,ParsedAttributes & FirstArgAttrs,SmallVectorImpl<DeclaratorChunk::ParamInfo> & ParamInfo,SourceLocation & EllipsisLoc,bool IsACXXFunctionDeclaration)7382 void Parser::ParseParameterDeclarationClause(
7383 DeclaratorContext DeclaratorCtx, ParsedAttributes &FirstArgAttrs,
7384 SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
7385 SourceLocation &EllipsisLoc, bool IsACXXFunctionDeclaration) {
7386
7387 // Avoid exceeding the maximum function scope depth.
7388 // See https://bugs.llvm.org/show_bug.cgi?id=19607
7389 // Note Sema::ActOnParamDeclarator calls ParmVarDecl::setScopeInfo with
7390 // getFunctionPrototypeDepth() - 1.
7391 if (getCurScope()->getFunctionPrototypeDepth() - 1 >
7392 ParmVarDecl::getMaxFunctionScopeDepth()) {
7393 Diag(Tok.getLocation(), diag::err_function_scope_depth_exceeded)
7394 << ParmVarDecl::getMaxFunctionScopeDepth();
7395 cutOffParsing();
7396 return;
7397 }
7398
7399 // C++2a [temp.res]p5
7400 // A qualified-id is assumed to name a type if
7401 // - [...]
7402 // - it is a decl-specifier of the decl-specifier-seq of a
7403 // - [...]
7404 // - parameter-declaration in a member-declaration [...]
7405 // - parameter-declaration in a declarator of a function or function
7406 // template declaration whose declarator-id is qualified [...]
7407 // - parameter-declaration in a lambda-declarator [...]
7408 auto AllowImplicitTypename = ImplicitTypenameContext::No;
7409 if (DeclaratorCtx == DeclaratorContext::Member ||
7410 DeclaratorCtx == DeclaratorContext::LambdaExpr ||
7411 DeclaratorCtx == DeclaratorContext::RequiresExpr ||
7412 IsACXXFunctionDeclaration) {
7413 AllowImplicitTypename = ImplicitTypenameContext::Yes;
7414 }
7415
7416 do {
7417 // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
7418 // before deciding this was a parameter-declaration-clause.
7419 if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
7420 break;
7421
7422 // Parse the declaration-specifiers.
7423 // Just use the ParsingDeclaration "scope" of the declarator.
7424 DeclSpec DS(AttrFactory);
7425
7426 ParsedAttributes ArgDeclAttrs(AttrFactory);
7427 ParsedAttributes ArgDeclSpecAttrs(AttrFactory);
7428
7429 if (FirstArgAttrs.Range.isValid()) {
7430 // If the caller parsed attributes for the first argument, add them now.
7431 // Take them so that we only apply the attributes to the first parameter.
7432 // We have already started parsing the decl-specifier sequence, so don't
7433 // parse any parameter-declaration pieces that precede it.
7434 ArgDeclSpecAttrs.takeAllFrom(FirstArgAttrs);
7435 } else {
7436 // Parse any C++11 attributes.
7437 MaybeParseCXX11Attributes(ArgDeclAttrs);
7438
7439 // Skip any Microsoft attributes before a param.
7440 MaybeParseMicrosoftAttributes(ArgDeclSpecAttrs);
7441 }
7442
7443 SourceLocation DSStart = Tok.getLocation();
7444
7445 // Parse a C++23 Explicit Object Parameter
7446 // We do that in all language modes to produce a better diagnostic.
7447 SourceLocation ThisLoc;
7448 if (getLangOpts().CPlusPlus && Tok.is(tok::kw_this))
7449 ThisLoc = ConsumeToken();
7450
7451 ParseDeclarationSpecifiers(DS, /*TemplateInfo=*/ParsedTemplateInfo(),
7452 AS_none, DeclSpecContext::DSC_normal,
7453 /*LateAttrs=*/nullptr, AllowImplicitTypename);
7454
7455 DS.takeAttributesFrom(ArgDeclSpecAttrs);
7456
7457 // Parse the declarator. This is "PrototypeContext" or
7458 // "LambdaExprParameterContext", because we must accept either
7459 // 'declarator' or 'abstract-declarator' here.
7460 Declarator ParmDeclarator(DS, ArgDeclAttrs,
7461 DeclaratorCtx == DeclaratorContext::RequiresExpr
7462 ? DeclaratorContext::RequiresExpr
7463 : DeclaratorCtx == DeclaratorContext::LambdaExpr
7464 ? DeclaratorContext::LambdaExprParameter
7465 : DeclaratorContext::Prototype);
7466 ParseDeclarator(ParmDeclarator);
7467
7468 if (ThisLoc.isValid())
7469 ParmDeclarator.SetRangeBegin(ThisLoc);
7470
7471 // Parse GNU attributes, if present.
7472 MaybeParseGNUAttributes(ParmDeclarator);
7473 if (getLangOpts().HLSL)
7474 MaybeParseHLSLSemantics(DS.getAttributes());
7475
7476 if (Tok.is(tok::kw_requires)) {
7477 // User tried to define a requires clause in a parameter declaration,
7478 // which is surely not a function declaration.
7479 // void f(int (*g)(int, int) requires true);
7480 Diag(Tok,
7481 diag::err_requires_clause_on_declarator_not_declaring_a_function);
7482 ConsumeToken();
7483 Actions.CorrectDelayedTyposInExpr(
7484 ParseConstraintLogicalOrExpression(/*IsTrailingRequiresClause=*/true));
7485 }
7486
7487 // Remember this parsed parameter in ParamInfo.
7488 IdentifierInfo *ParmII = ParmDeclarator.getIdentifier();
7489
7490 // DefArgToks is used when the parsing of default arguments needs
7491 // to be delayed.
7492 std::unique_ptr<CachedTokens> DefArgToks;
7493
7494 // If no parameter was specified, verify that *something* was specified,
7495 // otherwise we have a missing type and identifier.
7496 if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
7497 ParmDeclarator.getNumTypeObjects() == 0) {
7498 // Completely missing, emit error.
7499 Diag(DSStart, diag::err_missing_param);
7500 } else {
7501 // Otherwise, we have something. Add it and let semantic analysis try
7502 // to grok it and add the result to the ParamInfo we are building.
7503
7504 // Last chance to recover from a misplaced ellipsis in an attempted
7505 // parameter pack declaration.
7506 if (Tok.is(tok::ellipsis) &&
7507 (NextToken().isNot(tok::r_paren) ||
7508 (!ParmDeclarator.getEllipsisLoc().isValid() &&
7509 !Actions.isUnexpandedParameterPackPermitted())) &&
7510 Actions.containsUnexpandedParameterPacks(ParmDeclarator))
7511 DiagnoseMisplacedEllipsisInDeclarator(ConsumeToken(), ParmDeclarator);
7512
7513 // Now we are at the point where declarator parsing is finished.
7514 //
7515 // Try to catch keywords in place of the identifier in a declarator, and
7516 // in particular the common case where:
7517 // 1 identifier comes at the end of the declarator
7518 // 2 if the identifier is dropped, the declarator is valid but anonymous
7519 // (no identifier)
7520 // 3 declarator parsing succeeds, and then we have a trailing keyword,
7521 // which is never valid in a param list (e.g. missing a ',')
7522 // And we can't handle this in ParseDeclarator because in general keywords
7523 // may be allowed to follow the declarator. (And in some cases there'd be
7524 // better recovery like inserting punctuation). ParseDeclarator is just
7525 // treating this as an anonymous parameter, and fortunately at this point
7526 // we've already almost done that.
7527 //
7528 // We care about case 1) where the declarator type should be known, and
7529 // the identifier should be null.
7530 if (!ParmDeclarator.isInvalidType() && !ParmDeclarator.hasName() &&
7531 Tok.isNot(tok::raw_identifier) && !Tok.isAnnotation() &&
7532 Tok.getIdentifierInfo() &&
7533 Tok.getIdentifierInfo()->isKeyword(getLangOpts())) {
7534 Diag(Tok, diag::err_keyword_as_parameter) << PP.getSpelling(Tok);
7535 // Consume the keyword.
7536 ConsumeToken();
7537 }
7538 // Inform the actions module about the parameter declarator, so it gets
7539 // added to the current scope.
7540 Decl *Param =
7541 Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator, ThisLoc);
7542 // Parse the default argument, if any. We parse the default
7543 // arguments in all dialects; the semantic analysis in
7544 // ActOnParamDefaultArgument will reject the default argument in
7545 // C.
7546 if (Tok.is(tok::equal)) {
7547 SourceLocation EqualLoc = Tok.getLocation();
7548
7549 // Parse the default argument
7550 if (DeclaratorCtx == DeclaratorContext::Member) {
7551 // If we're inside a class definition, cache the tokens
7552 // corresponding to the default argument. We'll actually parse
7553 // them when we see the end of the class definition.
7554 DefArgToks.reset(new CachedTokens);
7555
7556 SourceLocation ArgStartLoc = NextToken().getLocation();
7557 ConsumeAndStoreInitializer(*DefArgToks, CIK_DefaultArgument);
7558 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
7559 ArgStartLoc);
7560 } else {
7561 // Consume the '='.
7562 ConsumeToken();
7563
7564 // The argument isn't actually potentially evaluated unless it is
7565 // used.
7566 EnterExpressionEvaluationContext Eval(
7567 Actions,
7568 Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed,
7569 Param);
7570
7571 ExprResult DefArgResult;
7572 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
7573 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
7574 DefArgResult = ParseBraceInitializer();
7575 } else {
7576 if (Tok.is(tok::l_paren) && NextToken().is(tok::l_brace)) {
7577 Diag(Tok, diag::err_stmt_expr_in_default_arg) << 0;
7578 Actions.ActOnParamDefaultArgumentError(Param, EqualLoc,
7579 /*DefaultArg=*/nullptr);
7580 // Skip the statement expression and continue parsing
7581 SkipUntil(tok::comma, StopBeforeMatch);
7582 continue;
7583 }
7584 DefArgResult = ParseAssignmentExpression();
7585 }
7586 DefArgResult = Actions.CorrectDelayedTyposInExpr(DefArgResult);
7587 if (DefArgResult.isInvalid()) {
7588 Actions.ActOnParamDefaultArgumentError(Param, EqualLoc,
7589 /*DefaultArg=*/nullptr);
7590 SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch);
7591 } else {
7592 // Inform the actions module about the default argument
7593 Actions.ActOnParamDefaultArgument(Param, EqualLoc,
7594 DefArgResult.get());
7595 }
7596 }
7597 }
7598
7599 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
7600 ParmDeclarator.getIdentifierLoc(),
7601 Param, std::move(DefArgToks)));
7602 }
7603
7604 if (TryConsumeToken(tok::ellipsis, EllipsisLoc)) {
7605 if (!getLangOpts().CPlusPlus) {
7606 // We have ellipsis without a preceding ',', which is ill-formed
7607 // in C. Complain and provide the fix.
7608 Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
7609 << FixItHint::CreateInsertion(EllipsisLoc, ", ");
7610 } else if (ParmDeclarator.getEllipsisLoc().isValid() ||
7611 Actions.containsUnexpandedParameterPacks(ParmDeclarator)) {
7612 // It looks like this was supposed to be a parameter pack. Warn and
7613 // point out where the ellipsis should have gone.
7614 SourceLocation ParmEllipsis = ParmDeclarator.getEllipsisLoc();
7615 Diag(EllipsisLoc, diag::warn_misplaced_ellipsis_vararg)
7616 << ParmEllipsis.isValid() << ParmEllipsis;
7617 if (ParmEllipsis.isValid()) {
7618 Diag(ParmEllipsis,
7619 diag::note_misplaced_ellipsis_vararg_existing_ellipsis);
7620 } else {
7621 Diag(ParmDeclarator.getIdentifierLoc(),
7622 diag::note_misplaced_ellipsis_vararg_add_ellipsis)
7623 << FixItHint::CreateInsertion(ParmDeclarator.getIdentifierLoc(),
7624 "...")
7625 << !ParmDeclarator.hasName();
7626 }
7627 Diag(EllipsisLoc, diag::note_misplaced_ellipsis_vararg_add_comma)
7628 << FixItHint::CreateInsertion(EllipsisLoc, ", ");
7629 }
7630
7631 // We can't have any more parameters after an ellipsis.
7632 break;
7633 }
7634
7635 // If the next token is a comma, consume it and keep reading arguments.
7636 } while (TryConsumeToken(tok::comma));
7637 }
7638
7639 /// [C90] direct-declarator '[' constant-expression[opt] ']'
7640 /// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
7641 /// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
7642 /// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
7643 /// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
7644 /// [C++11] direct-declarator '[' constant-expression[opt] ']'
7645 /// attribute-specifier-seq[opt]
ParseBracketDeclarator(Declarator & D)7646 void Parser::ParseBracketDeclarator(Declarator &D) {
7647 if (CheckProhibitedCXX11Attribute())
7648 return;
7649
7650 BalancedDelimiterTracker T(*this, tok::l_square);
7651 T.consumeOpen();
7652
7653 // C array syntax has many features, but by-far the most common is [] and [4].
7654 // This code does a fast path to handle some of the most obvious cases.
7655 if (Tok.getKind() == tok::r_square) {
7656 T.consumeClose();
7657 ParsedAttributes attrs(AttrFactory);
7658 MaybeParseCXX11Attributes(attrs);
7659
7660 // Remember that we parsed the empty array type.
7661 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, nullptr,
7662 T.getOpenLocation(),
7663 T.getCloseLocation()),
7664 std::move(attrs), T.getCloseLocation());
7665 return;
7666 } else if (Tok.getKind() == tok::numeric_constant &&
7667 GetLookAheadToken(1).is(tok::r_square)) {
7668 // [4] is very common. Parse the numeric constant expression.
7669 ExprResult ExprRes(Actions.ActOnNumericConstant(Tok, getCurScope()));
7670 ConsumeToken();
7671
7672 T.consumeClose();
7673 ParsedAttributes attrs(AttrFactory);
7674 MaybeParseCXX11Attributes(attrs);
7675
7676 // Remember that we parsed a array type, and remember its features.
7677 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, ExprRes.get(),
7678 T.getOpenLocation(),
7679 T.getCloseLocation()),
7680 std::move(attrs), T.getCloseLocation());
7681 return;
7682 } else if (Tok.getKind() == tok::code_completion) {
7683 cutOffParsing();
7684 Actions.CodeCompleteBracketDeclarator(getCurScope());
7685 return;
7686 }
7687
7688 // If valid, this location is the position where we read the 'static' keyword.
7689 SourceLocation StaticLoc;
7690 TryConsumeToken(tok::kw_static, StaticLoc);
7691
7692 // If there is a type-qualifier-list, read it now.
7693 // Type qualifiers in an array subscript are a C99 feature.
7694 DeclSpec DS(AttrFactory);
7695 ParseTypeQualifierListOpt(DS, AR_CXX11AttributesParsed);
7696
7697 // If we haven't already read 'static', check to see if there is one after the
7698 // type-qualifier-list.
7699 if (!StaticLoc.isValid())
7700 TryConsumeToken(tok::kw_static, StaticLoc);
7701
7702 // Handle "direct-declarator [ type-qual-list[opt] * ]".
7703 bool isStar = false;
7704 ExprResult NumElements;
7705
7706 // Handle the case where we have '[*]' as the array size. However, a leading
7707 // star could be the start of an expression, for example 'X[*p + 4]'. Verify
7708 // the token after the star is a ']'. Since stars in arrays are
7709 // infrequent, use of lookahead is not costly here.
7710 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
7711 ConsumeToken(); // Eat the '*'.
7712
7713 if (StaticLoc.isValid()) {
7714 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
7715 StaticLoc = SourceLocation(); // Drop the static.
7716 }
7717 isStar = true;
7718 } else if (Tok.isNot(tok::r_square)) {
7719 // Note, in C89, this production uses the constant-expr production instead
7720 // of assignment-expr. The only difference is that assignment-expr allows
7721 // things like '=' and '*='. Sema rejects these in C89 mode because they
7722 // are not i-c-e's, so we don't need to distinguish between the two here.
7723
7724 // Parse the constant-expression or assignment-expression now (depending
7725 // on dialect).
7726 if (getLangOpts().CPlusPlus) {
7727 NumElements = ParseArrayBoundExpression();
7728 } else {
7729 EnterExpressionEvaluationContext Unevaluated(
7730 Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
7731 NumElements =
7732 Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
7733 }
7734 } else {
7735 if (StaticLoc.isValid()) {
7736 Diag(StaticLoc, diag::err_unspecified_size_with_static);
7737 StaticLoc = SourceLocation(); // Drop the static.
7738 }
7739 }
7740
7741 // If there was an error parsing the assignment-expression, recover.
7742 if (NumElements.isInvalid()) {
7743 D.setInvalidType(true);
7744 // If the expression was invalid, skip it.
7745 SkipUntil(tok::r_square, StopAtSemi);
7746 return;
7747 }
7748
7749 T.consumeClose();
7750
7751 MaybeParseCXX11Attributes(DS.getAttributes());
7752
7753 // Remember that we parsed a array type, and remember its features.
7754 D.AddTypeInfo(
7755 DeclaratorChunk::getArray(DS.getTypeQualifiers(), StaticLoc.isValid(),
7756 isStar, NumElements.get(), T.getOpenLocation(),
7757 T.getCloseLocation()),
7758 std::move(DS.getAttributes()), T.getCloseLocation());
7759 }
7760
7761 /// Diagnose brackets before an identifier.
ParseMisplacedBracketDeclarator(Declarator & D)7762 void Parser::ParseMisplacedBracketDeclarator(Declarator &D) {
7763 assert(Tok.is(tok::l_square) && "Missing opening bracket");
7764 assert(!D.mayOmitIdentifier() && "Declarator cannot omit identifier");
7765
7766 SourceLocation StartBracketLoc = Tok.getLocation();
7767 Declarator TempDeclarator(D.getDeclSpec(), ParsedAttributesView::none(),
7768 D.getContext());
7769
7770 while (Tok.is(tok::l_square)) {
7771 ParseBracketDeclarator(TempDeclarator);
7772 }
7773
7774 // Stuff the location of the start of the brackets into the Declarator.
7775 // The diagnostics from ParseDirectDeclarator will make more sense if
7776 // they use this location instead.
7777 if (Tok.is(tok::semi))
7778 D.getName().EndLocation = StartBracketLoc;
7779
7780 SourceLocation SuggestParenLoc = Tok.getLocation();
7781
7782 // Now that the brackets are removed, try parsing the declarator again.
7783 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
7784
7785 // Something went wrong parsing the brackets, in which case,
7786 // ParseBracketDeclarator has emitted an error, and we don't need to emit
7787 // one here.
7788 if (TempDeclarator.getNumTypeObjects() == 0)
7789 return;
7790
7791 // Determine if parens will need to be suggested in the diagnostic.
7792 bool NeedParens = false;
7793 if (D.getNumTypeObjects() != 0) {
7794 switch (D.getTypeObject(D.getNumTypeObjects() - 1).Kind) {
7795 case DeclaratorChunk::Pointer:
7796 case DeclaratorChunk::Reference:
7797 case DeclaratorChunk::BlockPointer:
7798 case DeclaratorChunk::MemberPointer:
7799 case DeclaratorChunk::Pipe:
7800 NeedParens = true;
7801 break;
7802 case DeclaratorChunk::Array:
7803 case DeclaratorChunk::Function:
7804 case DeclaratorChunk::Paren:
7805 break;
7806 }
7807 }
7808
7809 if (NeedParens) {
7810 // Create a DeclaratorChunk for the inserted parens.
7811 SourceLocation EndLoc = PP.getLocForEndOfToken(D.getEndLoc());
7812 D.AddTypeInfo(DeclaratorChunk::getParen(SuggestParenLoc, EndLoc),
7813 SourceLocation());
7814 }
7815
7816 // Adding back the bracket info to the end of the Declarator.
7817 for (unsigned i = 0, e = TempDeclarator.getNumTypeObjects(); i < e; ++i) {
7818 const DeclaratorChunk &Chunk = TempDeclarator.getTypeObject(i);
7819 D.AddTypeInfo(Chunk, SourceLocation());
7820 }
7821
7822 // The missing identifier would have been diagnosed in ParseDirectDeclarator.
7823 // If parentheses are required, always suggest them.
7824 if (!D.getIdentifier() && !NeedParens)
7825 return;
7826
7827 SourceLocation EndBracketLoc = TempDeclarator.getEndLoc();
7828
7829 // Generate the move bracket error message.
7830 SourceRange BracketRange(StartBracketLoc, EndBracketLoc);
7831 SourceLocation EndLoc = PP.getLocForEndOfToken(D.getEndLoc());
7832
7833 if (NeedParens) {
7834 Diag(EndLoc, diag::err_brackets_go_after_unqualified_id)
7835 << getLangOpts().CPlusPlus
7836 << FixItHint::CreateInsertion(SuggestParenLoc, "(")
7837 << FixItHint::CreateInsertion(EndLoc, ")")
7838 << FixItHint::CreateInsertionFromRange(
7839 EndLoc, CharSourceRange(BracketRange, true))
7840 << FixItHint::CreateRemoval(BracketRange);
7841 } else {
7842 Diag(EndLoc, diag::err_brackets_go_after_unqualified_id)
7843 << getLangOpts().CPlusPlus
7844 << FixItHint::CreateInsertionFromRange(
7845 EndLoc, CharSourceRange(BracketRange, true))
7846 << FixItHint::CreateRemoval(BracketRange);
7847 }
7848 }
7849
7850 /// [GNU] typeof-specifier:
7851 /// typeof ( expressions )
7852 /// typeof ( type-name )
7853 /// [GNU/C++] typeof unary-expression
7854 /// [C23] typeof-specifier:
7855 /// typeof '(' typeof-specifier-argument ')'
7856 /// typeof_unqual '(' typeof-specifier-argument ')'
7857 ///
7858 /// typeof-specifier-argument:
7859 /// expression
7860 /// type-name
7861 ///
ParseTypeofSpecifier(DeclSpec & DS)7862 void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
7863 assert(Tok.isOneOf(tok::kw_typeof, tok::kw_typeof_unqual) &&
7864 "Not a typeof specifier");
7865
7866 bool IsUnqual = Tok.is(tok::kw_typeof_unqual);
7867 const IdentifierInfo *II = Tok.getIdentifierInfo();
7868 if (getLangOpts().C23 && !II->getName().starts_with("__"))
7869 Diag(Tok.getLocation(), diag::warn_c23_compat_keyword) << Tok.getName();
7870
7871 Token OpTok = Tok;
7872 SourceLocation StartLoc = ConsumeToken();
7873 bool HasParens = Tok.is(tok::l_paren);
7874
7875 EnterExpressionEvaluationContext Unevaluated(
7876 Actions, Sema::ExpressionEvaluationContext::Unevaluated,
7877 Sema::ReuseLambdaContextDecl);
7878
7879 bool isCastExpr;
7880 ParsedType CastTy;
7881 SourceRange CastRange;
7882 ExprResult Operand = Actions.CorrectDelayedTyposInExpr(
7883 ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr, CastTy, CastRange));
7884 if (HasParens)
7885 DS.setTypeArgumentRange(CastRange);
7886
7887 if (CastRange.getEnd().isInvalid())
7888 // FIXME: Not accurate, the range gets one token more than it should.
7889 DS.SetRangeEnd(Tok.getLocation());
7890 else
7891 DS.SetRangeEnd(CastRange.getEnd());
7892
7893 if (isCastExpr) {
7894 if (!CastTy) {
7895 DS.SetTypeSpecError();
7896 return;
7897 }
7898
7899 const char *PrevSpec = nullptr;
7900 unsigned DiagID;
7901 // Check for duplicate type specifiers (e.g. "int typeof(int)").
7902 if (DS.SetTypeSpecType(IsUnqual ? DeclSpec::TST_typeof_unqualType
7903 : DeclSpec::TST_typeofType,
7904 StartLoc, PrevSpec,
7905 DiagID, CastTy,
7906 Actions.getASTContext().getPrintingPolicy()))
7907 Diag(StartLoc, DiagID) << PrevSpec;
7908 return;
7909 }
7910
7911 // If we get here, the operand to the typeof was an expression.
7912 if (Operand.isInvalid()) {
7913 DS.SetTypeSpecError();
7914 return;
7915 }
7916
7917 // We might need to transform the operand if it is potentially evaluated.
7918 Operand = Actions.HandleExprEvaluationContextForTypeof(Operand.get());
7919 if (Operand.isInvalid()) {
7920 DS.SetTypeSpecError();
7921 return;
7922 }
7923
7924 const char *PrevSpec = nullptr;
7925 unsigned DiagID;
7926 // Check for duplicate type specifiers (e.g. "int typeof(int)").
7927 if (DS.SetTypeSpecType(IsUnqual ? DeclSpec::TST_typeof_unqualExpr
7928 : DeclSpec::TST_typeofExpr,
7929 StartLoc, PrevSpec,
7930 DiagID, Operand.get(),
7931 Actions.getASTContext().getPrintingPolicy()))
7932 Diag(StartLoc, DiagID) << PrevSpec;
7933 }
7934
7935 /// [C11] atomic-specifier:
7936 /// _Atomic ( type-name )
7937 ///
ParseAtomicSpecifier(DeclSpec & DS)7938 void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
7939 assert(Tok.is(tok::kw__Atomic) && NextToken().is(tok::l_paren) &&
7940 "Not an atomic specifier");
7941
7942 SourceLocation StartLoc = ConsumeToken();
7943 BalancedDelimiterTracker T(*this, tok::l_paren);
7944 if (T.consumeOpen())
7945 return;
7946
7947 TypeResult Result = ParseTypeName();
7948 if (Result.isInvalid()) {
7949 SkipUntil(tok::r_paren, StopAtSemi);
7950 return;
7951 }
7952
7953 // Match the ')'
7954 T.consumeClose();
7955
7956 if (T.getCloseLocation().isInvalid())
7957 return;
7958
7959 DS.setTypeArgumentRange(T.getRange());
7960 DS.SetRangeEnd(T.getCloseLocation());
7961
7962 const char *PrevSpec = nullptr;
7963 unsigned DiagID;
7964 if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
7965 DiagID, Result.get(),
7966 Actions.getASTContext().getPrintingPolicy()))
7967 Diag(StartLoc, DiagID) << PrevSpec;
7968 }
7969
7970 /// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
7971 /// from TryAltiVecVectorToken.
TryAltiVecVectorTokenOutOfLine()7972 bool Parser::TryAltiVecVectorTokenOutOfLine() {
7973 Token Next = NextToken();
7974 switch (Next.getKind()) {
7975 default: return false;
7976 case tok::kw_short:
7977 case tok::kw_long:
7978 case tok::kw_signed:
7979 case tok::kw_unsigned:
7980 case tok::kw_void:
7981 case tok::kw_char:
7982 case tok::kw_int:
7983 case tok::kw_float:
7984 case tok::kw_double:
7985 case tok::kw_bool:
7986 case tok::kw__Bool:
7987 case tok::kw___bool:
7988 case tok::kw___pixel:
7989 Tok.setKind(tok::kw___vector);
7990 return true;
7991 case tok::identifier:
7992 if (Next.getIdentifierInfo() == Ident_pixel) {
7993 Tok.setKind(tok::kw___vector);
7994 return true;
7995 }
7996 if (Next.getIdentifierInfo() == Ident_bool ||
7997 Next.getIdentifierInfo() == Ident_Bool) {
7998 Tok.setKind(tok::kw___vector);
7999 return true;
8000 }
8001 return false;
8002 }
8003 }
8004
TryAltiVecTokenOutOfLine(DeclSpec & DS,SourceLocation Loc,const char * & PrevSpec,unsigned & DiagID,bool & isInvalid)8005 bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
8006 const char *&PrevSpec, unsigned &DiagID,
8007 bool &isInvalid) {
8008 const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
8009 if (Tok.getIdentifierInfo() == Ident_vector) {
8010 Token Next = NextToken();
8011 switch (Next.getKind()) {
8012 case tok::kw_short:
8013 case tok::kw_long:
8014 case tok::kw_signed:
8015 case tok::kw_unsigned:
8016 case tok::kw_void:
8017 case tok::kw_char:
8018 case tok::kw_int:
8019 case tok::kw_float:
8020 case tok::kw_double:
8021 case tok::kw_bool:
8022 case tok::kw__Bool:
8023 case tok::kw___bool:
8024 case tok::kw___pixel:
8025 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
8026 return true;
8027 case tok::identifier:
8028 if (Next.getIdentifierInfo() == Ident_pixel) {
8029 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
8030 return true;
8031 }
8032 if (Next.getIdentifierInfo() == Ident_bool ||
8033 Next.getIdentifierInfo() == Ident_Bool) {
8034 isInvalid =
8035 DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
8036 return true;
8037 }
8038 break;
8039 default:
8040 break;
8041 }
8042 } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
8043 DS.isTypeAltiVecVector()) {
8044 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
8045 return true;
8046 } else if ((Tok.getIdentifierInfo() == Ident_bool) &&
8047 DS.isTypeAltiVecVector()) {
8048 isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
8049 return true;
8050 }
8051 return false;
8052 }
8053
ParseTypeFromString(StringRef TypeStr,StringRef Context,SourceLocation IncludeLoc)8054 TypeResult Parser::ParseTypeFromString(StringRef TypeStr, StringRef Context,
8055 SourceLocation IncludeLoc) {
8056 // Consume (unexpanded) tokens up to the end-of-directive.
8057 SmallVector<Token, 4> Tokens;
8058 {
8059 // Create a new buffer from which we will parse the type.
8060 auto &SourceMgr = PP.getSourceManager();
8061 FileID FID = SourceMgr.createFileID(
8062 llvm::MemoryBuffer::getMemBufferCopy(TypeStr, Context), SrcMgr::C_User,
8063 0, 0, IncludeLoc);
8064
8065 // Form a new lexer that references the buffer.
8066 Lexer L(FID, SourceMgr.getBufferOrFake(FID), PP);
8067 L.setParsingPreprocessorDirective(true);
8068
8069 // Lex the tokens from that buffer.
8070 Token Tok;
8071 do {
8072 L.Lex(Tok);
8073 Tokens.push_back(Tok);
8074 } while (Tok.isNot(tok::eod));
8075 }
8076
8077 // Replace the "eod" token with an "eof" token identifying the end of
8078 // the provided string.
8079 Token &EndToken = Tokens.back();
8080 EndToken.startToken();
8081 EndToken.setKind(tok::eof);
8082 EndToken.setLocation(Tok.getLocation());
8083 EndToken.setEofData(TypeStr.data());
8084
8085 // Add the current token back.
8086 Tokens.push_back(Tok);
8087
8088 // Enter the tokens into the token stream.
8089 PP.EnterTokenStream(Tokens, /*DisableMacroExpansion=*/false,
8090 /*IsReinject=*/false);
8091
8092 // Consume the current token so that we'll start parsing the tokens we
8093 // added to the stream.
8094 ConsumeAnyToken();
8095
8096 // Enter a new scope.
8097 ParseScope LocalScope(this, 0);
8098
8099 // Parse the type.
8100 TypeResult Result = ParseTypeName(nullptr);
8101
8102 // Check if we parsed the whole thing.
8103 if (Result.isUsable() &&
8104 (Tok.isNot(tok::eof) || Tok.getEofData() != TypeStr.data())) {
8105 Diag(Tok.getLocation(), diag::err_type_unparsed);
8106 }
8107
8108 // There could be leftover tokens (e.g. because of an error).
8109 // Skip through until we reach the 'end of directive' token.
8110 while (Tok.isNot(tok::eof))
8111 ConsumeAnyToken();
8112
8113 // Consume the end token.
8114 if (Tok.is(tok::eof) && Tok.getEofData() == TypeStr.data())
8115 ConsumeAnyToken();
8116 return Result;
8117 }
8118
DiagnoseBitIntUse(const Token & Tok)8119 void Parser::DiagnoseBitIntUse(const Token &Tok) {
8120 // If the token is for _ExtInt, diagnose it as being deprecated. Otherwise,
8121 // the token is about _BitInt and gets (potentially) diagnosed as use of an
8122 // extension.
8123 assert(Tok.isOneOf(tok::kw__ExtInt, tok::kw__BitInt) &&
8124 "expected either an _ExtInt or _BitInt token!");
8125
8126 SourceLocation Loc = Tok.getLocation();
8127 if (Tok.is(tok::kw__ExtInt)) {
8128 Diag(Loc, diag::warn_ext_int_deprecated)
8129 << FixItHint::CreateReplacement(Loc, "_BitInt");
8130 } else {
8131 // In C23 mode, diagnose that the use is not compatible with pre-C23 modes.
8132 // Otherwise, diagnose that the use is a Clang extension.
8133 if (getLangOpts().C23)
8134 Diag(Loc, diag::warn_c23_compat_keyword) << Tok.getName();
8135 else
8136 Diag(Loc, diag::ext_bit_int) << getLangOpts().CPlusPlus;
8137 }
8138 }
8139