CbC/CbC_llvm: clang/lib/Parse/ParseDecl.cpp comparison

comparison clang/lib/Parse/ParseDecl.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	dd44ba33042e 5f17cb93ff66

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 bool AttrStartIsInMacro =
 Lexer::isAtStartOfMacroExpansion(StartLoc, SM, PP.getLangOpts());
 bool AttrEndIsInMacro =
 Lexer::isAtEndOfMacroExpansion(EndLoc, SM, PP.getLangOpts());
 return AttrStartIsInMacro && AttrEndIsInMacro;
+}
+void Parser::ParseAttributes(unsigned WhichAttrKinds,
+ParsedAttributesWithRange &Attrs,
+SourceLocation *End,
+LateParsedAttrList *LateAttrs) {
+bool MoreToParse;
+do {
+// Assume there's nothing left to parse, but if any attributes are in fact
+// parsed, loop to ensure all specified attribute combinations are parsed.
+MoreToParse = false;
+if (WhichAttrKinds & PAKM_CXX11)
+MoreToParse |= MaybeParseCXX11Attributes(Attrs, End);
+if (WhichAttrKinds & PAKM_GNU)
+MoreToParse |= MaybeParseGNUAttributes(Attrs, End, LateAttrs);
+if (WhichAttrKinds & PAKM_Declspec)
+MoreToParse |= MaybeParseMicrosoftDeclSpecs(Attrs, End);
+} while (MoreToParse);
 }
 /// ParseGNUAttributes - Parse a non-empty attributes list.
 ///
 /// [GNU] attributes:
 ///    and the attribute *wants* an identifier, it is parsed as an identifier.
 ///    At block scope, any additional tokens between the identifier and the
 ///    ',' or ')' are ignored, otherwise they produce a parse error.
 ///
 /// We follow the C++ model, but don't allow junk after the identifier.
-void Parser::ParseGNUAttributes(ParsedAttributes &attrs,
+void Parser::ParseGNUAttributes(ParsedAttributesWithRange &Attrs,
-SourceLocation *endLoc,
+SourceLocation *EndLoc,
-LateParsedAttrList *LateAttrs,
+LateParsedAttrList *LateAttrs, Declarator *D) {
-Declarator *D) {
 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
+SourceLocation StartLoc = Tok.getLocation(), Loc;
+if (!EndLoc)
+EndLoc = &Loc;
 while (Tok.is(tok::kw___attribute)) {
 SourceLocation AttrTokLoc = ConsumeToken();
-unsigned OldNumAttrs = attrs.size();
+unsigned OldNumAttrs = Attrs.size();
 unsigned OldNumLateAttrs = LateAttrs ? LateAttrs->size() : 0;
 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
 "attribute")) {
 SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
 break;
 SourceLocation AttrNameLoc = ConsumeToken();
 if (Tok.isNot(tok::l_paren)) {
-attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
+Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
 ParsedAttr::AS_GNU);
 continue;
 }
 // Handle "parameterized" attributes
 if (!LateAttrs || !isAttributeLateParsed(*AttrName)) {
-ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc, nullptr,
+ParseGNUAttributeArgs(AttrName, AttrNameLoc, Attrs, EndLoc, nullptr,
 SourceLocation(), ParsedAttr::AS_GNU, D);
 continue;
 }
 // Handle attributes with arguments that require late parsing.
 if (ExpectAndConsume(tok::r_paren))
 SkipUntil(tok::r_paren, StopAtSemi);
 SourceLocation Loc = Tok.getLocation();
 if (ExpectAndConsume(tok::r_paren))
 SkipUntil(tok::r_paren, StopAtSemi);
-if (endLoc)
+if (EndLoc)
-*endLoc = Loc;
+*EndLoc = Loc;
 // If this was declared in a macro, attach the macro IdentifierInfo to the
 // parsed attribute.
 auto &SM = PP.getSourceManager();
 if (!SM.isWrittenInBuiltinFile(SM.getSpellingLoc(AttrTokLoc)) &&
 CharSourceRange ExpansionRange = SM.getExpansionRange(AttrTokLoc);
 StringRef FoundName =
 Lexer::getSourceText(ExpansionRange, SM, PP.getLangOpts());
 IdentifierInfo *MacroII = PP.getIdentifierInfo(FoundName);
-for (unsigned i = OldNumAttrs; i < attrs.size(); ++i)
+for (unsigned i = OldNumAttrs; i < Attrs.size(); ++i)
-attrs[i].setMacroIdentifier(MacroII, ExpansionRange.getBegin());
+Attrs[i].setMacroIdentifier(MacroII, ExpansionRange.getBegin());
 if (LateAttrs) {
 for (unsigned i = OldNumLateAttrs; i < LateAttrs->size(); ++i)
 (*LateAttrs)[i]->MacroII = MacroII;
 }
 }
 }
+Attrs.Range = SourceRange(StartLoc, *EndLoc);
 }
 /// Determine whether the given attribute has an identifier argument.
 static bool attributeHasIdentifierArg(const IdentifierInfo &II) {
 #define CLANG_ATTR_IDENTIFIER_ARG_LIST
 return;
 } else if (AttrKind == ParsedAttr::AT_ObjCBridgeRelated) {
 ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
 ScopeName, ScopeLoc, Syntax);
 return;
+} else if (AttrKind == ParsedAttr::AT_SwiftNewType) {
+ParseSwiftNewTypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
+ScopeLoc, Syntax);
+return;
 } else if (AttrKind == ParsedAttr::AT_TypeTagForDatatype) {
 ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
 ScopeName, ScopeLoc, Syntax);
 return;
 } else if (attributeIsTypeArgAttr(*AttrName)) {
 ScopeLoc, Syntax);
 break;
 case ParsedAttr::AT_ObjCBridgeRelated:
 ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
 ScopeName, ScopeLoc, Syntax);
+break;
+case ParsedAttr::AT_SwiftNewType:
+ParseSwiftNewTypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
+ScopeLoc, Syntax);
 break;
 case ParsedAttr::AT_TypeTagForDatatype:
 ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
 ScopeName, ScopeLoc, Syntax);
 break;
 // Treat these like attributes, even though they're type specifiers.
 while (true) {
 switch (Tok.getKind()) {
 case tok::kw__Nonnull:
 case tok::kw__Nullable:
+case tok::kw__Nullable_result:
 case tok::kw__Null_unspecified: {
 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 SourceLocation AttrNameLoc = ConsumeToken();
 if (!getLangOpts().ObjC)
 Diag(AttrNameLoc, diag::ext_nullability)
 else
 ReplacementExpr = ParseStringLiteralExpression();
 // Also reject wide string literals.
 if (StringLiteral *MessageStringLiteral =
 cast_or_null<StringLiteral>(MessageExpr.get())) {
-if (MessageStringLiteral->getCharByteWidth() != 1) {
+if (!MessageStringLiteral->isAscii()) {
 Diag(MessageStringLiteral->getSourceRange().getBegin(),
 diag::err_expected_string_literal)
 << /*Source='availability attribute'*/ 2;
 SkipUntil(tok::r_paren, StopAtSemi);
 return;
 ClassMethod,
 InstanceMethod,
 Syntax);
 }
-// Late Parsed Attributes:
-// See other examples of late parsing in lib/Parse/ParseCXXInlineMethods
+void Parser::ParseSwiftNewTypeAttribute(
+IdentifierInfo &AttrName, SourceLocation AttrNameLoc,
-void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
+ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
+SourceLocation ScopeLoc, ParsedAttr::Syntax Syntax) {
-void Parser::LateParsedClass::ParseLexedAttributes() {
+BalancedDelimiterTracker T(*this, tok::l_paren);
-Self->ParseLexedAttributes(*Class);
-}
+// Opening '('
+if (T.consumeOpen()) {
-void Parser::LateParsedAttribute::ParseLexedAttributes() {
+Diag(Tok, diag::err_expected) << tok::l_paren;
-Self->ParseLexedAttribute(*this, true, false);
+return;
 }
-/// Wrapper class which calls ParseLexedAttribute, after setting up the
+if (Tok.is(tok::r_paren)) {
-/// scope appropriately.
+Diag(Tok.getLocation(), diag::err_argument_required_after_attribute);
-void Parser::ParseLexedAttributes(ParsingClass &Class) {
+T.consumeClose();
-// Deal with templates
+return;
-// FIXME: Test cases to make sure this does the right thing for templates.
+}
-bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
+if (Tok.isNot(tok::kw_struct) && Tok.isNot(tok::kw_enum)) {
-ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
+Diag(Tok, diag::warn_attribute_type_not_supported)
-HasTemplateScope);
+<< &AttrName << Tok.getIdentifierInfo();
-if (HasTemplateScope)
+if (!isTokenSpecial())
-Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
+ConsumeToken();
+T.consumeClose();
-// Set or update the scope flags.
+return;
-bool AlreadyHasClassScope = Class.TopLevelClass;
+}
-unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope;
-ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
+auto *SwiftType = IdentifierLoc::create(Actions.Context, Tok.getLocation(),
-ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
+Tok.getIdentifierInfo());
+ConsumeToken();
-// Enter the scope of nested classes
-if (!AlreadyHasClassScope)
+// Closing ')'
-Actions.ActOnStartDelayedMemberDeclarations(getCurScope(),
+if (T.consumeClose())
-Class.TagOrTemplate);
+return;
-if (!Class.LateParsedDeclarations.empty()) {
+if (EndLoc)
-for (unsigned i = 0, ni = Class.LateParsedDeclarations.size(); i < ni; ++i){
+*EndLoc = T.getCloseLocation();
-Class.LateParsedDeclarations[i]->ParseLexedAttributes();
-}
+ArgsUnion Args[] = {SwiftType};
-}
+Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, T.getCloseLocation()),
+ScopeName, ScopeLoc, Args, llvm::array_lengthof(Args), Syntax);
-if (!AlreadyHasClassScope)
+}
-Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(),
-Class.TagOrTemplate);
-}
-/// Parse all attributes in LAs, and attach them to Decl D.
-void Parser::ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
-bool EnterScope, bool OnDefinition) {
-assert(LAs.parseSoon() &&
-"Attribute list should be marked for immediate parsing.");
-for (unsigned i = 0, ni = LAs.size(); i < ni; ++i) {
-if (D)
-LAs[i]->addDecl(D);
-ParseLexedAttribute(*LAs[i], EnterScope, OnDefinition);
-delete LAs[i];
-}
-LAs.clear();
-}
-/// Finish parsing an attribute for which parsing was delayed.
-/// This will be called at the end of parsing a class declaration
-/// for each LateParsedAttribute. We consume the saved tokens and
-/// create an attribute with the arguments filled in. We add this
-/// to the Attribute list for the decl.
-void Parser::ParseLexedAttribute(LateParsedAttribute &LA,
-bool EnterScope, bool OnDefinition) {
-// Create a fake EOF so that attribute parsing won't go off the end of the
-// attribute.
-Token AttrEnd;
-AttrEnd.startToken();
-AttrEnd.setKind(tok::eof);
-AttrEnd.setLocation(Tok.getLocation());
-AttrEnd.setEofData(LA.Toks.data());
-LA.Toks.push_back(AttrEnd);
-// Append the current token at the end of the new token stream so that it
-// doesn't get lost.
-LA.Toks.push_back(Tok);
-PP.EnterTokenStream(LA.Toks, true, /*IsReinject=*/true);
-// Consume the previously pushed token.
-ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
-ParsedAttributes Attrs(AttrFactory);
-SourceLocation endLoc;
-if (LA.Decls.size() > 0) {
-Decl *D = LA.Decls[0];
-NamedDecl *ND  = dyn_cast<NamedDecl>(D);
-RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext());
-// Allow 'this' within late-parsed attributes.
-Sema::CXXThisScopeRAII ThisScope(Actions, RD, Qualifiers(),
-ND && ND->isCXXInstanceMember());
-if (LA.Decls.size() == 1) {
-// If the Decl is templatized, add template parameters to scope.
-bool HasTemplateScope = EnterScope && D->isTemplateDecl();
-ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope);
-if (HasTemplateScope)
-Actions.ActOnReenterTemplateScope(Actions.CurScope, D);
-// If the Decl is on a function, add function parameters to the scope.
-bool HasFunScope = EnterScope && D->isFunctionOrFunctionTemplate();
-ParseScope FnScope(
-this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope,
-HasFunScope);
-if (HasFunScope)
-Actions.ActOnReenterFunctionContext(Actions.CurScope, D);
-ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
-nullptr, SourceLocation(), ParsedAttr::AS_GNU,
-nullptr);
-if (HasFunScope) {
-Actions.ActOnExitFunctionContext();
-FnScope.Exit();  // Pop scope, and remove Decls from IdResolver
-}
-if (HasTemplateScope) {
-TempScope.Exit();
-}
-} else {
-// If there are multiple decls, then the decl cannot be within the
-// function scope.
-ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
-nullptr, SourceLocation(), ParsedAttr::AS_GNU,
-nullptr);
-}
-} else {
-Diag(Tok, diag::warn_attribute_no_decl) << LA.AttrName.getName();
-}
-if (OnDefinition && !Attrs.empty() && !Attrs.begin()->isCXX11Attribute() &&
-Attrs.begin()->isKnownToGCC())
-Diag(Tok, diag::warn_attribute_on_function_definition)
-<< &LA.AttrName;
-for (unsigned i = 0, ni = LA.Decls.size(); i < ni; ++i)
-Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.Decls[i], Attrs);
-// Due to a parsing error, we either went over the cached tokens or
-// there are still cached tokens left, so we skip the leftover tokens.
-while (Tok.isNot(tok::eof))
-ConsumeAnyToken();
-if (Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())
-ConsumeAnyToken();
-}
 void Parser::ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
 SourceLocation AttrNameLoc,
 ParsedAttributes &Attrs,
 SourceLocation *EndLoc,
 } else
 Diag(Range.getBegin(), diag::err_attributes_not_allowed) << Range;
 }
 void Parser::ProhibitCXX11Attributes(ParsedAttributesWithRange &Attrs,
-unsigned DiagID) {
+unsigned DiagID, bool DiagnoseEmptyAttrs) {
+if (DiagnoseEmptyAttrs && Attrs.empty() && Attrs.Range.isValid()) {
+// An attribute list has been parsed, but it was empty.
+// This is the case for [[]].
+const auto &LangOpts = getLangOpts();
+auto &SM = PP.getSourceManager();
+Token FirstLSquare;
+Lexer::getRawToken(Attrs.Range.getBegin(), FirstLSquare, SM, LangOpts);
+if (FirstLSquare.is(tok::l_square)) {
+llvm::Optional<Token> SecondLSquare =
+Lexer::findNextToken(FirstLSquare.getLocation(), SM, LangOpts);
+if (SecondLSquare && SecondLSquare->is(tok::l_square)) {
+// The attribute range starts with [[, but is empty. So this must
+// be [[]], which we are supposed to diagnose because
+// DiagnoseEmptyAttrs is true.
+Diag(Attrs.Range.getBegin(), DiagID) << Attrs.Range;
+return;
+}
+}
+}
 for (const ParsedAttr &AL : Attrs) {
 if (!AL.isCXX11Attribute() && !AL.isC2xAttribute())
 continue;
 if (AL.getKind() == ParsedAttr::UnknownAttribute)
-Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) << AL;
+Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
+<< AL << AL.getRange();
 else {
 Diag(AL.getLoc(), DiagID) << AL;
 AL.setInvalid();
 }
+}
+}
+void Parser::DiagnoseCXX11AttributeExtension(ParsedAttributesWithRange &Attrs) {
+for (const ParsedAttr &PA : Attrs) {
+if (PA.isCXX11Attribute() || PA.isC2xAttribute())
+Diag(PA.getLoc(), diag::ext_cxx11_attr_placement) << PA << PA.getRange();
 }
 }
 // Usually, `__attribute__((attrib)) class Foo {} var` means that attribute
 // applies to var, not the type Foo.
 case tok::amp:
 case tok::ampamp:
 return getLangOpts().CPlusPlus;
 case tok::l_square: // Might be an attribute on an unnamed bit-field.
-return Context == DeclaratorContext::MemberContext &&
+return Context == DeclaratorContext::Member && getLangOpts().CPlusPlus11 &&
-getLangOpts().CPlusPlus11 && NextToken().is(tok::l_square);
+NextToken().is(tok::l_square);
 case tok::colon: // Might be a typo for '::' or an unnamed bit-field.
-return Context == DeclaratorContext::MemberContext ||
+return Context == DeclaratorContext::Member || getLangOpts().CPlusPlus;
-getLangOpts().CPlusPlus;
 case tok::identifier:
 switch (NextToken().getKind()) {
 case tok::code_completion:
 case tok::coloncolon:
 case tok::colon:
 // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
 // and in block scope it's probably a label. Inside a class definition,
 // this is a bit-field.
-return Context == DeclaratorContext::MemberContext ||
+return Context == DeclaratorContext::Member ||
-(getLangOpts().CPlusPlus &&
+(getLangOpts().CPlusPlus && Context == DeclaratorContext::File);
-Context == DeclaratorContext::FileContext);
 case tok::identifier: // Possible virt-specifier.
 return getLangOpts().CPlusPlus11 && isCXX11VirtSpecifier(NextToken());
 default:
 : FixItHint());
 }
 }
 // Check to see if we have a function *definition* which must have a body.
-if (D.isFunctionDeclarator() &&
+if (D.isFunctionDeclarator()) {
-// Look at the next token to make sure that this isn't a function
+if (Tok.is(tok::equal) && NextToken().is(tok::code_completion)) {
-// declaration.  We have to check this because __attribute__ might be the
+cutOffParsing();
-// start of a function definition in GCC-extended K&R C.
+Actions.CodeCompleteAfterFunctionEquals(D);
-!isDeclarationAfterDeclarator()) {
+return nullptr;
+}
-// Function definitions are only allowed at file scope and in C++ classes.
+// Look at the next token to make sure that this isn't a function
-// The C++ inline method definition case is handled elsewhere, so we only
+// declaration.  We have to check this because __attribute__ might be the
-// need to handle the file scope definition case.
+// start of a function definition in GCC-extended K&R C.
-if (Context == DeclaratorContext::FileContext) {
+if (!isDeclarationAfterDeclarator()) {
-if (isStartOfFunctionDefinition(D)) {
-if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
+// Function definitions are only allowed at file scope and in C++ classes.
-Diag(Tok, diag::err_function_declared_typedef);
+// The C++ inline method definition case is handled elsewhere, so we only
+// need to handle the file scope definition case.
-// Recover by treating the 'typedef' as spurious.
+if (Context == DeclaratorContext::File) {
-DS.ClearStorageClassSpecs();
+if (isStartOfFunctionDefinition(D)) {
+if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
+Diag(Tok, diag::err_function_declared_typedef);
+// Recover by treating the 'typedef' as spurious.
+DS.ClearStorageClassSpecs();
+}
+Decl *TheDecl = ParseFunctionDefinition(D, ParsedTemplateInfo(),
+&LateParsedAttrs);
+return Actions.ConvertDeclToDeclGroup(TheDecl);
 }
-Decl *TheDecl =
+if (isDeclarationSpecifier()) {
-ParseFunctionDefinition(D, ParsedTemplateInfo(), &LateParsedAttrs);
+// If there is an invalid declaration specifier right after the
-return Actions.ConvertDeclToDeclGroup(TheDecl);
+// function prototype, then we must be in a missing semicolon case
-}
+// where this isn't actually a body.  Just fall through into the code
+// that handles it as a prototype, and let the top-level code handle
-if (isDeclarationSpecifier()) {
+// the erroneous declspec where it would otherwise expect a comma or
-// If there is an invalid declaration specifier right after the
+// semicolon.
-// function prototype, then we must be in a missing semicolon case
+} else {
-// where this isn't actually a body.  Just fall through into the code
+Diag(Tok, diag::err_expected_fn_body);
-// that handles it as a prototype, and let the top-level code handle
+SkipUntil(tok::semi);
-// the erroneous declspec where it would otherwise expect a comma or
+return nullptr;
-// semicolon.
+}
 } else {
-Diag(Tok, diag::err_expected_fn_body);
+if (Tok.is(tok::l_brace)) {
-SkipUntil(tok::semi);
+Diag(Tok, diag::err_function_definition_not_allowed);
-return nullptr;
+SkipMalformedDecl();
-}
+return nullptr;
-} else {
+}
-if (Tok.is(tok::l_brace)) {
-Diag(Tok, diag::err_function_definition_not_allowed);
-SkipMalformedDecl();
-return nullptr;
 }
 }
 }
 if (ParseAsmAttributesAfterDeclarator(D))
 ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false);
 D.complete(FirstDecl);
 if (FirstDecl)
 DeclsInGroup.push_back(FirstDecl);
-bool ExpectSemi = Context != DeclaratorContext::ForContext;
+bool ExpectSemi = Context != DeclaratorContext::ForInit;
 // If we don't have a comma, it is either the end of the list (a ';') or an
 // error, bail out.
 SourceLocation CommaLoc;
 while (TryConsumeToken(tok::comma, CommaLoc)) {
 }
 if (DeclEnd)
 *DeclEnd = Tok.getLocation();
-if (ExpectSemi &&
+if (ExpectSemi && ExpectAndConsumeSemi(
-ExpectAndConsumeSemi(Context == DeclaratorContext::FileContext
+Context == DeclaratorContext::File
 ? diag::err_invalid_token_after_toplevel_declarator
 : diag::err_expected_semi_declaration)) {
 // Okay, there was no semicolon and one was expected.  If we see a
 // declaration specifier, just assume it was missing and continue parsing.
 // Otherwise things are very confused and we skip to recover.
 if (!isDeclarationSpecifier()) {
 SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
 }
 ThisDecl = nullptr;
 }
 };
-// Inform the current actions module that we just parsed this declarator.
+enum class InitKind { Uninitialized, Equal, CXXDirect, CXXBraced };
+InitKind TheInitKind;
+// If a '==' or '+=' is found, suggest a fixit to '='.
+if (isTokenEqualOrEqualTypo())
+TheInitKind = InitKind::Equal;
+else if (Tok.is(tok::l_paren))
+TheInitKind = InitKind::CXXDirect;
+else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace) &&
+(!CurParsedObjCImpl || !D.isFunctionDeclarator()))
+TheInitKind = InitKind::CXXBraced;
+else
+TheInitKind = InitKind::Uninitialized;
+if (TheInitKind != InitKind::Uninitialized)
+D.setHasInitializer();
+// Inform Sema that we just parsed this declarator.
 Decl *ThisDecl = nullptr;
+Decl *OuterDecl = nullptr;
 switch (TemplateInfo.Kind) {
 case ParsedTemplateInfo::NonTemplate:
 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
 break;
 case ParsedTemplateInfo::Template:
 case ParsedTemplateInfo::ExplicitSpecialization: {
 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
 *TemplateInfo.TemplateParams,
 D);
-if (VarTemplateDecl *VT = dyn_cast_or_null<VarTemplateDecl>(ThisDecl))
+if (VarTemplateDecl *VT = dyn_cast_or_null<VarTemplateDecl>(ThisDecl)) {
 // Re-direct this decl to refer to the templated decl so that we can
 // initialize it.
 ThisDecl = VT->getTemplatedDecl();
+OuterDecl = VT;
+}
 break;
 }
 case ParsedTemplateInfo::ExplicitInstantiation: {
 if (Tok.is(tok::semi)) {
 DeclResult ThisRes = Actions.ActOnExplicitInstantiation(
 }
 break;
 }
 }
+switch (TheInitKind) {
 // Parse declarator '=' initializer.
-// If a '==' or '+=' is found, suggest a fixit to '='.
+case InitKind::Equal: {
-if (isTokenEqualOrEqualTypo()) {
 SourceLocation EqualLoc = ConsumeToken();
 if (Tok.is(tok::kw_delete)) {
 if (D.isFunctionDeclarator())
 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
 << getLangOpts().CPlusPlus20;
 } else {
 InitializerScopeRAII InitScope(*this, D, ThisDecl);
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
 Actions.FinalizeDeclaration(ThisDecl);
-cutOffParsing();
 return nullptr;
 }
 PreferredType.enterVariableInit(Tok.getLocation(), ThisDecl);
 ExprResult Init = ParseInitializer();
 InitScope.pop();
 if (Init.isInvalid()) {
 SmallVector<tok::TokenKind, 2> StopTokens;
 StopTokens.push_back(tok::comma);
-if (D.getContext() == DeclaratorContext::ForContext ||
+if (D.getContext() == DeclaratorContext::ForInit ||
-D.getContext() == DeclaratorContext::InitStmtContext)
+D.getContext() == DeclaratorContext::SelectionInit)
 StopTokens.push_back(tok::r_paren);
 SkipUntil(StopTokens, StopAtSemi | StopBeforeMatch);
 Actions.ActOnInitializerError(ThisDecl);
 } else
 Actions.AddInitializerToDecl(ThisDecl, Init.get(),
 /*DirectInit=*/false);
 }
-} else if (Tok.is(tok::l_paren)) {
+break;
+}
+case InitKind::CXXDirect: {
 // Parse C++ direct initializer: '(' expression-list ')'
 BalancedDelimiterTracker T(*this, tok::l_paren);
 T.consumeOpen();
 ExprVector Exprs;
 T.getCloseLocation(),
 Exprs);
 Actions.AddInitializerToDecl(ThisDecl, Initializer.get(),
 /*DirectInit=*/true);
 }
-} else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace) &&
+break;
-(!CurParsedObjCImpl || !D.isFunctionDeclarator())) {
+}
+case InitKind::CXXBraced: {
 // Parse C++0x braced-init-list.
 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
 InitializerScopeRAII InitScope(*this, D, ThisDecl);
 if (Init.isInvalid()) {
 Actions.ActOnInitializerError(ThisDecl);
 } else
 Actions.AddInitializerToDecl(ThisDecl, Init.get(), /*DirectInit=*/true);
+break;
-} else {
+}
+case InitKind::Uninitialized: {
 Actions.ActOnUninitializedDecl(ThisDecl);
+break;
+}
 }
 Actions.FinalizeDeclaration(ThisDecl);
+return OuterDecl ? OuterDecl : ThisDecl;
-return ThisDecl;
 }
 /// ParseSpecifierQualifierList
 ///        specifier-qualifier-list:
 ///          type-specifier specifier-qualifier-list[opt]
 }
 // Issue diagnostic and remove constexpr specifier if present.
 if (DS.hasConstexprSpecifier() && DSC != DeclSpecContext::DSC_condition) {
 Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr)
-<< DS.getConstexprSpecifier();
+<< static_cast<int>(DS.getConstexprSpecifier());
 DS.ClearConstexprSpec();
 }
 }
 /// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
 ///
 /// \param Context the declarator context, which is one of the
 /// DeclaratorContext enumerator values.
 Parser::DeclSpecContext
 Parser::getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context) {
-if (Context == DeclaratorContext::MemberContext)
+if (Context == DeclaratorContext::Member)
 return DeclSpecContext::DSC_class;
-if (Context == DeclaratorContext::FileContext)
+if (Context == DeclaratorContext::File)
 return DeclSpecContext::DSC_top_level;
-if (Context == DeclaratorContext::TemplateParamContext)
+if (Context == DeclaratorContext::TemplateParam)
 return DeclSpecContext::DSC_template_param;
-if (Context == DeclaratorContext::TemplateArgContext ||
+if (Context == DeclaratorContext::TemplateArg ||
-Context == DeclaratorContext::TemplateTypeArgContext)
+Context == DeclaratorContext::TemplateTypeArg)
 return DeclSpecContext::DSC_template_type_arg;
-if (Context == DeclaratorContext::TrailingReturnContext ||
+if (Context == DeclaratorContext::TrailingReturn ||
-Context == DeclaratorContext::TrailingReturnVarContext)
+Context == DeclaratorContext::TrailingReturnVar)
 return DeclSpecContext::DSC_trailing;
-if (Context == DeclaratorContext::AliasDeclContext ||
+if (Context == DeclaratorContext::AliasDecl ||
-Context == DeclaratorContext::AliasTemplateContext)
+Context == DeclaratorContext::AliasTemplate)
 return DeclSpecContext::DSC_alias_declaration;
 return DeclSpecContext::DSC_normal;
 }
 /// ParseAlignArgument - Parse the argument to an alignment-specifier.
 break;
 case Sema::NC_Unknown:
 case Sema::NC_NonType:
 case Sema::NC_DependentNonType:
-case Sema::NC_ContextIndependentExpr:
+case Sema::NC_OverloadSet:
 case Sema::NC_VarTemplate:
 case Sema::NC_FunctionTemplate:
 case Sema::NC_Concept:
 // Might be a redeclaration of a prior entity.
 break;
 !DS.hasTypeSpecifier() && GetLookAheadToken(1).is(tok::less))
 Tok.setKind(tok::identifier);
 SourceLocation Loc = Tok.getLocation();
+// Helper for image types in OpenCL.
+auto handleOpenCLImageKW = [&] (StringRef Ext, TypeSpecifierType ImageTypeSpec) {
+// Check if the image type is supported and otherwise turn the keyword into an identifier
+// because image types from extensions are not reserved identifiers.
+if (!StringRef(Ext).empty() && !getActions().getOpenCLOptions().isSupported(Ext, getLangOpts())) {
+Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
+Tok.setKind(tok::identifier);
+return false;
+}
+isInvalid = DS.SetTypeSpecType(ImageTypeSpec, Loc, PrevSpec, DiagID, Policy);
+return true;
+};
 switch (Tok.getKind()) {
 default:
 DoneWithDeclSpec:
 if (!AttrsLastTime)
 ProhibitAttributes(attrs);
 Scope::AtCatchScope)) == 0;
 bool AllowNestedNameSpecifiers
 = DSContext == DeclSpecContext::DSC_top_level ||
 (DSContext == DeclSpecContext::DSC_class && DS.isFriendSpecified());
+cutOffParsing();
 Actions.CodeCompleteDeclSpec(getCurScope(), DS,
 AllowNonIdentifiers,
 AllowNestedNameSpecifiers);
-return cutOffParsing();
+return;
 }
 if (getCurScope()->getFnParent() || getCurScope()->getBlockParent())
 CCC = Sema::PCC_LocalDeclarationSpecifiers;
 else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
 else if (DSContext == DeclSpecContext::DSC_class)
 CCC = Sema::PCC_Class;
 else if (CurParsedObjCImpl)
 CCC = Sema::PCC_ObjCImplementation;
+cutOffParsing();
 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
-return cutOffParsing();
+return;
 }
 case tok::coloncolon: // ::foo::bar
 // C++ scope specifier.  Annotate and loop, or bail out on error.
 if (TryAnnotateCXXScopeToken(EnteringContext)) {
 CXXScopeSpec SS;
 AnnotateTemplateIdTokenAsType(SS);
 continue;
 }
-// GNU attributes support.
+// Attributes support.
 case tok::kw___attribute:
-ParseGNUAttributes(DS.getAttributes(), nullptr, LateAttrs);
-continue;
-// Microsoft declspec support.
 case tok::kw___declspec:
-ParseMicrosoftDeclSpecs(DS.getAttributes());
+ParseAttributes(PAKM_GNU | PAKM_Declspec, DS.getAttributes(), nullptr,
+LateAttrs);
 continue;
 // Microsoft single token adornments.
 case tok::kw___forceinline: {
 isInvalid = DS.setFunctionSpecForceInline(Loc, PrevSpec, DiagID);
 continue;
 // Nullability type specifiers.
 case tok::kw__Nonnull:
 case tok::kw__Nullable:
+case tok::kw__Nullable_result:
 case tok::kw__Null_unspecified:
 ParseNullabilityTypeSpecifiers(DS.getAttributes());
 continue;
 // Objective-C 'kindof' types.
 isInvalid = DS.setFunctionSpecInline(Loc, PrevSpec, DiagID);
 break;
 case tok::kw_virtual:
 // C++ for OpenCL does not allow virtual function qualifier, to avoid
 // function pointers restricted in OpenCL v2.0 s6.9.a.
-if (getLangOpts().OpenCLCPlusPlus) {
+if (getLangOpts().OpenCLCPlusPlus &&
+!getActions().getOpenCLOptions().isAvailableOption(
+"__cl_clang_function_pointers", getLangOpts())) {
 DiagID = diag::err_openclcxx_virtual_function;
 PrevSpec = Tok.getIdentifierInfo()->getNameStart();
 isInvalid = true;
-}
+} else {
-else {
 isInvalid = DS.setFunctionSpecVirtual(Loc, PrevSpec, DiagID);
 }
 break;
 case tok::kw_explicit: {
 SourceLocation ExplicitLoc = Loc;
 isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
 break;
 // constexpr, consteval, constinit specifiers
 case tok::kw_constexpr:
-isInvalid = DS.SetConstexprSpec(CSK_constexpr, Loc, PrevSpec, DiagID);
+isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Constexpr, Loc,
+PrevSpec, DiagID);
 break;
 case tok::kw_consteval:
-isInvalid = DS.SetConstexprSpec(CSK_consteval, Loc, PrevSpec, DiagID);
+isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Consteval, Loc,
+PrevSpec, DiagID);
 break;
 case tok::kw_constinit:
-isInvalid = DS.SetConstexprSpec(CSK_constinit, Loc, PrevSpec, DiagID);
+isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Constinit, Loc,
+PrevSpec, DiagID);
 break;
 // type-specifier
 case tok::kw_short:
-isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
+isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::Short, Loc, PrevSpec,
 DiagID, Policy);
 break;
 case tok::kw_long:
-if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
+if (DS.getTypeSpecWidth() != TypeSpecifierWidth::Long)
-isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
+isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::Long, Loc, PrevSpec,
 DiagID, Policy);
 else
-isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
+isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc,
-DiagID, Policy);
+PrevSpec, DiagID, Policy);
 break;
 case tok::kw___int64:
-isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
+isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc,
-DiagID, Policy);
+PrevSpec, DiagID, Policy);
 break;
 case tok::kw_signed:
-isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec,
+isInvalid =
-DiagID);
+DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID);
 break;
 case tok::kw_unsigned:
-isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
+isInvalid = DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec,
 DiagID);
 break;
 case tok::kw__Complex:
 if (!getLangOpts().C99)
 Diag(Tok, diag::ext_c99_feature) << Tok.getName();
 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec,
 DiagID, Policy);
 break;
 case tok::kw_half:
 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
+DiagID, Policy);
+break;
+case tok::kw___bf16:
+isInvalid = DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec,
 DiagID, Policy);
 break;
 case tok::kw_float:
 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
 DiagID, Policy);
 isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
 break;
 case tok::kw_pipe:
 if (!getLangOpts().OpenCL || (getLangOpts().OpenCLVersion < 200 &&
 !getLangOpts().OpenCLCPlusPlus)) {
-// OpenCL 2.0 defined this keyword. OpenCL 1.2 and earlier should
+// OpenCL 2.0 and later define this keyword. OpenCL 1.2 and earlier
-// support the "pipe" word as identifier.
+// should support the "pipe" word as identifier.
 Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
+Tok.setKind(tok::identifier);
 goto DoneWithDeclSpec;
 }
 isInvalid = DS.SetTypePipe(true, Loc, PrevSpec, DiagID, Policy);
 break;
-#define GENERIC_IMAGE_TYPE(ImgType, Id) \
+// We only need to enumerate each image type once.
-case tok::kw_##ImgType##_t: \
+#define IMAGE_READ_WRITE_TYPE(Type, Id, Ext)
-isInvalid = DS.SetTypeSpecType(DeclSpec::TST_##ImgType##_t, Loc, PrevSpec, \
+#define IMAGE_WRITE_TYPE(Type, Id, Ext)
-DiagID, Policy); \
+#define IMAGE_READ_TYPE(ImgType, Id, Ext) \
-break;
+case tok::kw_##ImgType##_t: \
+if (!handleOpenCLImageKW(Ext, DeclSpec::TST_##ImgType##_t)) \
+goto DoneWithDeclSpec; \
+break;
 #include "clang/Basic/OpenCLImageTypes.def"
 case tok::kw___unknown_anytype:
 isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
 PrevSpec, DiagID, Policy);
 break;
 // OpenCL address space qualifiers:
 case tok::kw___generic:
 // generic address space is introduced only in OpenCL v2.0
 // see OpenCL C Spec v2.0 s6.5.5
-if (Actions.getLangOpts().OpenCLVersion < 200 &&
+if (!Actions.getLangOpts().OpenCLGenericAddressSpace) {
-!Actions.getLangOpts().OpenCLCPlusPlus) {
 DiagID = diag::err_opencl_unknown_type_specifier;
 PrevSpec = Tok.getIdentifierInfo()->getNameStart();
 isInvalid = true;
 break;
 }
 while (1) {
 ParsingFieldDeclarator DeclaratorInfo(*this, DS);
 DeclaratorInfo.D.setCommaLoc(CommaLoc);
 // Attributes are only allowed here on successive declarators.
-if (!FirstDeclarator)
+if (!FirstDeclarator) {
+// However, this does not apply for [[]] attributes (which could show up
+// before or after the __attribute__ attributes).
+DiagnoseAndSkipCXX11Attributes();
 MaybeParseGNUAttributes(DeclaratorInfo.D);
+DiagnoseAndSkipCXX11Attributes();
+}
 /// struct-declarator: declarator
 /// struct-declarator: declarator[opt] ':' constant-expression
 if (Tok.isNot(tok::colon)) {
 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
 /// ParseStructUnionBody
 ///       struct-contents:
 ///         struct-declaration-list
 /// [EXT]   empty
-/// [GNU]   "struct-declaration-list" without terminatoring ';'
+/// [GNU]   "struct-declaration-list" without terminating ';'
 ///       struct-declaration-list:
 ///         struct-declaration
 ///         struct-declaration-list struct-declaration
 /// [OBC]   '@' 'defs' '(' class-name ')'
 ///
 void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
-DeclSpec::TST TagType, Decl *TagDecl) {
+DeclSpec::TST TagType, RecordDecl *TagDecl) {
 PrettyDeclStackTraceEntry CrashInfo(Actions.Context, TagDecl, RecordLoc,
 "parsing struct/union body");
 assert(!getLangOpts().CPlusPlus && "C++ declarations not supported");
 BalancedDelimiterTracker T(*this, tok::l_brace);
 if (T.consumeOpen())
 return;
 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
-SmallVector<Decl *, 32> FieldDecls;
 // While we still have something to read, read the declarations in the struct.
 while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
 Tok.isNot(tok::eof)) {
 // Each iteration of this loop reads one struct-declaration.
 ConsumeExtraSemi(InsideStruct, TagType);
 continue;
 }
 // Parse _Static_assert declaration.
-if (Tok.is(tok::kw__Static_assert)) {
+if (Tok.isOneOf(tok::kw__Static_assert, tok::kw_static_assert)) {
 SourceLocation DeclEnd;
 ParseStaticAssertDeclaration(DeclEnd);
 continue;
 }
 // Install the declarator into the current TagDecl.
 Decl *Field =
 Actions.ActOnField(getCurScope(), TagDecl,
 FD.D.getDeclSpec().getSourceRange().getBegin(),
 FD.D, FD.BitfieldSize);
-FieldDecls.push_back(Field);
 FD.complete(Field);
 };
 // Parse all the comma separated declarators.
 ParsingDeclSpec DS(*this);
 continue;
 }
 SmallVector<Decl *, 16> Fields;
 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
 Tok.getIdentifierInfo(), Fields);
-FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
 ConsumeToken();
 ExpectAndConsume(tok::r_paren);
 }
 if (TryConsumeToken(tok::semi))
 T.consumeClose();
 ParsedAttributes attrs(AttrFactory);
 // If attributes exist after struct contents, parse them.
 MaybeParseGNUAttributes(attrs);
+SmallVector<Decl *, 32> FieldDecls(TagDecl->field_begin(),
+TagDecl->field_end());
 Actions.ActOnFields(getCurScope(), RecordLoc, TagDecl, FieldDecls,
 T.getOpenLocation(), T.getCloseLocation(), attrs);
 StructScope.Exit();
 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, T.getRange());
 const ParsedTemplateInfo &TemplateInfo,
 AccessSpecifier AS, DeclSpecContext DSC) {
 // Parse the tag portion of this.
 if (Tok.is(tok::code_completion)) {
 // Code completion for an enum name.
+cutOffParsing();
 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
-return cutOffParsing();
+return;
 }
 // If attributes exist after tag, parse them.
 ParsedAttributesWithRange attrs(AttrFactory);
-MaybeParseGNUAttributes(attrs);
+MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs);
-MaybeParseCXX11Attributes(attrs);
-MaybeParseMicrosoftDeclSpecs(attrs);
 SourceLocation ScopedEnumKWLoc;
 bool IsScopedUsingClassTag = false;
 // In C++11, recognize 'enum class' and 'enum struct'.
 // Attributes are not allowed between these keywords.  Diagnose,
 // but then just treat them like they appeared in the right place.
 ProhibitAttributes(attrs);
 // They are allowed afterwards, though.
-MaybeParseGNUAttributes(attrs);
+MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs);
-MaybeParseCXX11Attributes(attrs);
-MaybeParseMicrosoftDeclSpecs(attrs);
 }
 // C++11 [temp.explicit]p12:
 //   The usual access controls do not apply to names used to specify
 //   explicit instantiations.
 // because under -fms-extensions,
 //   enum E : int *p;
 // declares 'enum E : int; E *p;' not 'enum E : int*; E p;'.
 DeclSpec DS(AttrFactory);
 ParseSpecifierQualifierList(DS, AS, DeclSpecContext::DSC_type_specifier);
-Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
+Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
 BaseType = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
 BaseRange = SourceRange(ColonLoc, DeclaratorInfo.getSourceRange().getEnd());
 if (!getLangOpts().ObjC) {
 //
 // MSVC and (for now at least) Objective-C permit a full enum-specifier
 // or opaque-enum-declaration anywhere.
 if (IsElaboratedTypeSpecifier && !getLangOpts().MicrosoftExt &&
 !getLangOpts().ObjC) {
-ProhibitAttributes(attrs);
+ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+/*DiagnoseEmptyAttrs=*/true);
 if (BaseType.isUsable())
 Diag(BaseRange.getBegin(), diag::ext_enum_base_in_type_specifier)
 << (AllowEnumSpecifier == AllowDefiningTypeSpec::Yes) << BaseRange;
 else if (ScopedEnumKWLoc.isValid())
 Diag(ScopedEnumKWLoc, diag::ext_elaborated_enum_class)
 SourceLocation IdentLoc = ConsumeToken();
 // If attributes exist after the enumerator, parse them.
 ParsedAttributesWithRange attrs(AttrFactory);
 MaybeParseGNUAttributes(attrs);
-ProhibitAttributes(attrs); // GNU-style attributes are prohibited.
 if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
 if (getLangOpts().CPlusPlus)
 Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
 ? diag::warn_cxx14_compat_ns_enum_attribute
 : diag::ext_ns_enum_attribute)
 case tok::kw_char8_t:
 case tok::kw_char16_t:
 case tok::kw_char32_t:
 case tok::kw_int:
 case tok::kw__ExtInt:
+case tok::kw___bf16:
 case tok::kw_half:
 case tok::kw_float:
 case tok::kw_double:
 case tok::kw__Accum:
 case tok::kw__Fract:
 case tok::kw_char16_t:
 case tok::kw_char32_t:
 case tok::kw_int:
 case tok::kw__ExtInt:
 case tok::kw_half:
+case tok::kw___bf16:
 case tok::kw_float:
 case tok::kw_double:
 case tok::kw__Accum:
 case tok::kw__Fract:
 case tok::kw__Float16:
 case tok::kw___pascal:
 case tok::kw___unaligned:
 case tok::kw__Nonnull:
 case tok::kw__Nullable:
+case tok::kw__Nullable_result:
 case tok::kw__Null_unspecified:
 case tok::kw___kindof:
 case tok::kw___private:
 bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
 switch (Tok.getKind()) {
 default: return false;
 case tok::kw_pipe:
-return (getLangOpts().OpenCL && getLangOpts().OpenCLVersion >= 200) ||
+return getLangOpts().OpenCLPipe;
-getLangOpts().OpenCLCPlusPlus;
 case tok::identifier:   // foo::bar
 // Unfortunate hack to support "Class.factoryMethod" notation.
 if (getLangOpts().ObjC && NextToken().is(tok::period))
 return false;
 case tok::kw_char32_t:
 case tok::kw_int:
 case tok::kw__ExtInt:
 case tok::kw_half:
+case tok::kw___bf16:
 case tok::kw_float:
 case tok::kw_double:
 case tok::kw__Accum:
 case tok::kw__Fract:
 case tok::kw__Float16:
 // friend keyword.
 case tok::kw_friend:
 // static_assert-declaration
+case tok::kw_static_assert:
 case tok::kw__Static_assert:
 // GNU typeof support.
 case tok::kw_typeof:
 case tok::kw___pascal:
 case tok::kw___unaligned:
 case tok::kw__Nonnull:
 case tok::kw__Nullable:
+case tok::kw__Nullable_result:
 case tok::kw__Null_unspecified:
 case tok::kw___kindof:
 case tok::kw___private:
 unsigned DiagID = 0;
 SourceLocation Loc = Tok.getLocation();
 switch (Tok.getKind()) {
 case tok::code_completion:
+cutOffParsing();
 if (CodeCompletionHandler)
 (*CodeCompletionHandler)();
 else
 Actions.CodeCompleteTypeQualifiers(DS);
-return cutOffParsing();
+return;
 case tok::kw_const:
 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const   , Loc, PrevSpec, DiagID,
 getLangOpts());
 break;
 goto DoneWithTypeQuals;
 // Nullability type specifiers.
 case tok::kw__Nonnull:
 case tok::kw__Nullable:
+case tok::kw__Nullable_result:
 case tok::kw__Null_unspecified:
 ParseNullabilityTypeSpecifiers(DS.getAttributes());
 continue;
 // Objective-C 'kindof' types.
 static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang,
 DeclaratorContext TheContext) {
 if (Kind == tok::star || Kind == tok::caret)
 return true;
-if (Kind == tok::kw_pipe &&
+if (Kind == tok::kw_pipe && Lang.OpenCLPipe)
-((Lang.OpenCL && Lang.OpenCLVersion >= 200) || Lang.OpenCLCPlusPlus))
 return true;
 if (!Lang.CPlusPlus)
 return false;
 // But we must not parse them in conversion-type-ids and new-type-ids, since
 // those can be legitimately followed by a && operator.
 // (The same thing can in theory happen after a trailing-return-type, but
 // since those are a C++11 feature, there is no rejects-valid issue there.)
 if (Kind == tok::ampamp)
-return Lang.CPlusPlus11 ||
+return Lang.CPlusPlus11 || (TheContext != DeclaratorContext::ConversionId &&
-(TheContext != DeclaratorContext::ConversionIdContext &&
+TheContext != DeclaratorContext::CXXNew);
-TheContext != DeclaratorContext::CXXNewContext);
 return false;
 }
 // Indicates whether the given declarator is a pipe declarator.
 if (getLangOpts().CPlusPlus &&
 (Tok.is(tok::coloncolon) || Tok.is(tok::kw_decltype) ||
 (Tok.is(tok::identifier) &&
 (NextToken().is(tok::coloncolon) || NextToken().is(tok::less))) ||
 Tok.is(tok::annot_cxxscope))) {
-bool EnteringContext =
+bool EnteringContext = D.getContext() == DeclaratorContext::File ||
-D.getContext() == DeclaratorContext::FileContext ||
+D.getContext() == DeclaratorContext::Member;
-D.getContext() == DeclaratorContext::MemberContext;
 CXXScopeSpec SS;
 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
 /*ObjectHadErrors=*/false, EnteringContext);
 if (SS.isNotEmpty()) {
 if (DirectDeclParser)
 (this->*DirectDeclParser)(D);
 return;
 }
+if (SS.isValid()) {
+checkCompoundToken(SS.getEndLoc(), tok::coloncolon,
+CompoundToken::MemberPtr);
+}
 SourceLocation StarLoc = ConsumeToken();
 D.SetRangeEnd(StarLoc);
 DeclSpec DS(AttrFactory);
 ParseTypeQualifierListOpt(DS);
 D.ExtendWithDeclSpec(DS);
 DeclSpec DS(AttrFactory);
 // GNU attributes are not allowed here in a new-type-id, but Declspec and
 // C++11 attributes are allowed.
 unsigned Reqs = AR_CXX11AttributesParsed | AR_DeclspecAttributesParsed |
-((D.getContext() != DeclaratorContext::CXXNewContext)
+((D.getContext() != DeclaratorContext::CXXNew)
 ? AR_GNUAttributesParsed
 : AR_GNUAttributesParsedAndRejected);
 ParseTypeQualifierListOpt(DS, Reqs, true, !D.mayOmitIdentifier());
 D.ExtendWithDeclSpec(DS);
 // Don't parse FOO:BAR as if it were a typo for FOO::BAR inside a class, in
 // this context it is a bitfield. Also in range-based for statement colon
 // may delimit for-range-declaration.
 ColonProtectionRAIIObject X(
-*this, D.getContext() == DeclaratorContext::MemberContext ||
+*this, D.getContext() == DeclaratorContext::Member ||
-(D.getContext() == DeclaratorContext::ForContext &&
+(D.getContext() == DeclaratorContext::ForInit &&
 getLangOpts().CPlusPlus11));
 // ParseDeclaratorInternal might already have parsed the scope.
 if (D.getCXXScopeSpec().isEmpty()) {
-bool EnteringContext =
+bool EnteringContext = D.getContext() == DeclaratorContext::File ||
-D.getContext() == DeclaratorContext::FileContext ||
+D.getContext() == DeclaratorContext::Member;
-D.getContext() == DeclaratorContext::MemberContext;
 ParseOptionalCXXScopeSpecifier(
 D.getCXXScopeSpec(), /*ObjectType=*/nullptr,
 /*ObjectHadErrors=*/false, EnteringContext);
 }
 //   the ellipsis is parsed as part of the abstract-declarator if the type
 //   of the parameter either names a template parameter pack that has not
 //   been expanded or contains auto; otherwise, it is parsed as part of the
 //   parameter-declaration-clause.
 if (Tok.is(tok::ellipsis) && D.getCXXScopeSpec().isEmpty() &&
-!((D.getContext() == DeclaratorContext::PrototypeContext ||
+!((D.getContext() == DeclaratorContext::Prototype ||
-D.getContext() == DeclaratorContext::LambdaExprParameterContext ||
+D.getContext() == DeclaratorContext::LambdaExprParameter ||
-D.getContext() == DeclaratorContext::BlockLiteralContext) &&
+D.getContext() == DeclaratorContext::BlockLiteral) &&
-NextToken().is(tok::r_paren) &&
+NextToken().is(tok::r_paren) && !D.hasGroupingParens() &&
-!D.hasGroupingParens() &&
 !Actions.containsUnexpandedParameterPacks(D) &&
 D.getDeclSpec().getTypeSpecType() != TST_auto)) {
 SourceLocation EllipsisLoc = ConsumeToken();
 if (isPtrOperatorToken(Tok.getKind(), getLangOpts(), D.getContext())) {
 // The ellipsis was put in the wrong place. Recover, and explain to
 bool AllowDeductionGuide;
 if (D.getDeclSpec().hasTypeSpecifier()) {
 AllowConstructorName = false;
 AllowDeductionGuide = false;
 } else if (D.getCXXScopeSpec().isSet()) {
-AllowConstructorName =
+AllowConstructorName = (D.getContext() == DeclaratorContext::File ||
-(D.getContext() == DeclaratorContext::FileContext ||
+D.getContext() == DeclaratorContext::Member);
-D.getContext() == DeclaratorContext::MemberContext);
 AllowDeductionGuide = false;
 } else {
-AllowConstructorName =
+AllowConstructorName = (D.getContext() == DeclaratorContext::Member);
-(D.getContext() == DeclaratorContext::MemberContext);
+AllowDeductionGuide = (D.getContext() == DeclaratorContext::File ||
-AllowDeductionGuide =
+D.getContext() == DeclaratorContext::Member);
-(D.getContext() == DeclaratorContext::FileContext ||
-D.getContext() == DeclaratorContext::MemberContext);
 }
 bool HadScope = D.getCXXScopeSpec().isValid();
 if (ParseUnqualifiedId(D.getCXXScopeSpec(),
 /*ObjectType=*/nullptr,
 bool DiagnoseIdentifier = false;
 if (D.hasGroupingParens())
 // An identifier within parens is unlikely to be intended to be anything
 // other than a name being "declared".
 DiagnoseIdentifier = true;
-else if (D.getContext() == DeclaratorContext::TemplateArgContext)
+else if (D.getContext() == DeclaratorContext::TemplateArg)
 // T<int N> is an accidental identifier; T<int N indicates a missing '>'.
 DiagnoseIdentifier =
 NextToken().isOneOf(tok::comma, tok::greater, tok::greatergreater);
-else if (D.getContext() == DeclaratorContext::AliasDeclContext ||
+else if (D.getContext() == DeclaratorContext::AliasDecl ||
-D.getContext() == DeclaratorContext::AliasTemplateContext)
+D.getContext() == DeclaratorContext::AliasTemplate)
 // The most likely error is that the ';' was forgotten.
 DiagnoseIdentifier = NextToken().isOneOf(tok::comma, tok::semi);
-else if ((D.getContext() == DeclaratorContext::TrailingReturnContext ||
+else if ((D.getContext() == DeclaratorContext::TrailingReturn ||
-D.getContext() == DeclaratorContext::TrailingReturnVarContext) &&
+D.getContext() == DeclaratorContext::TrailingReturnVar) &&
 !isCXX11VirtSpecifier(Tok))
 DiagnoseIdentifier = NextToken().isOneOf(
 tok::comma, tok::semi, tok::equal, tok::l_brace, tok::kw_try);
 if (DiagnoseIdentifier) {
 Diag(Tok.getLocation(), diag::err_unexpected_unqualified_id)
 } else {
 if (Tok.getKind() == tok::annot_pragma_parser_crash)
 LLVM_BUILTIN_TRAP;
 if (Tok.is(tok::l_square))
 return ParseMisplacedBracketDeclarator(D);
-if (D.getContext() == DeclaratorContext::MemberContext) {
+if (D.getContext() == DeclaratorContext::Member) {
 // Objective-C++: Detect C++ keywords and try to prevent further errors by
 // treating these keyword as valid member names.
 if (getLangOpts().ObjC && getLangOpts().CPlusPlus &&
 Tok.getIdentifierInfo() &&
 Tok.getIdentifierInfo()->isCPlusPlusKeyword(getLangOpts())) {
 //   template of a class X, the expression this is a prvalue of type
 //   "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
 //   and the end of the function-definition, member-declarator, or
 //   declarator.
 // FIXME: currently, "static" case isn't handled correctly.
-bool IsCXX11MemberFunction = getLangOpts().CPlusPlus11 &&
+bool IsCXX11MemberFunction =
-D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
+getLangOpts().CPlusPlus11 &&
-(D.getContext() == DeclaratorContext::MemberContext
+D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
-? !D.getDeclSpec().isFriendSpecified()
+(D.getContext() == DeclaratorContext::Member
-: D.getContext() == DeclaratorContext::FileContext &&
+? !D.getDeclSpec().isFriendSpecified()
-D.getCXXScopeSpec().isValid() &&
+: D.getContext() == DeclaratorContext::File &&
-Actions.CurContext->isRecord());
+D.getCXXScopeSpec().isValid() &&
+Actions.CurContext->isRecord());
 if (!IsCXX11MemberFunction)
 return;
 Qualifiers Q = Qualifiers::fromCVRUMask(DS.getTypeQualifiers());
 if (D.getDeclSpec().hasConstexprSpecifier() && !getLangOpts().CPlusPlus14)
 SmallVector<SourceRange, 2> DynamicExceptionRanges;
 ExprResult NoexceptExpr;
 CachedTokens *ExceptionSpecTokens = nullptr;
 ParsedAttributesWithRange FnAttrs(AttrFactory);
 TypeResult TrailingReturnType;
+SourceLocation TrailingReturnTypeLoc;
 /* LocalEndLoc is the end location for the local FunctionTypeLoc.
 EndLoc is the end location for the function declarator.
 They differ for trailing return types. */
 SourceLocation StartLoc, LocalEndLoc, EndLoc;
 llvm::Optional<Sema::CXXThisScopeRAII> ThisScope;
 InitCXXThisScopeForDeclaratorIfRelevant(D, DS, ThisScope);
 // Parse exception-specification[opt].
+// FIXME: Per [class.mem]p6, all exception-specifications at class scope
+// should be delayed, including those for non-members (eg, friend
+// declarations). But only applying this to member declarations is
+// consistent with what other implementations do.
 bool Delayed = D.isFirstDeclarationOfMember() &&
 D.isFunctionDeclaratorAFunctionDeclaration();
 if (Delayed && Actions.isLibstdcxxEagerExceptionSpecHack(D) &&
 GetLookAheadToken(0).is(tok::kw_noexcept) &&
 GetLookAheadToken(1).is(tok::l_paren) &&
 StartLoc = D.getDeclSpec().getTypeSpecTypeLoc();
 LocalEndLoc = Tok.getLocation();
 SourceRange Range;
 TrailingReturnType =
 ParseTrailingReturnType(Range, D.mayBeFollowedByCXXDirectInit());
+TrailingReturnTypeLoc = Range.getBegin();
 EndLoc = Range.getEnd();
 }
 } else if (standardAttributesAllowed()) {
 MaybeParseCXX11Attributes(FnAttrs);
 }
 /*MutableLoc=*/SourceLocation(),
 ESpecType, ESpecRange, DynamicExceptions.data(),
 DynamicExceptionRanges.data(), DynamicExceptions.size(),
 NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
 ExceptionSpecTokens, DeclsInPrototype, StartLoc,
-LocalEndLoc, D, TrailingReturnType, &DS),
+LocalEndLoc, D, TrailingReturnType, TrailingReturnTypeLoc,
+&DS),
 std::move(FnAttrs), EndLoc);
 }
 /// ParseRefQualifier - Parses a member function ref-qualifier. Returns
 /// true if a ref-qualifier is found.
 // Parse the declarator.  This is "PrototypeContext" or
 // "LambdaExprParameterContext", because we must accept either
 // 'declarator' or 'abstract-declarator' here.
 Declarator ParmDeclarator(
-DS, DeclaratorCtx == DeclaratorContext::RequiresExprContext
+DS, DeclaratorCtx == DeclaratorContext::RequiresExpr
-? DeclaratorContext::RequiresExprContext
+? DeclaratorContext::RequiresExpr
-: DeclaratorCtx == DeclaratorContext::LambdaExprContext
+: DeclaratorCtx == DeclaratorContext::LambdaExpr
-? DeclaratorContext::LambdaExprParameterContext
+? DeclaratorContext::LambdaExprParameter
-: DeclaratorContext::PrototypeContext);
+: DeclaratorContext::Prototype);
 ParseDeclarator(ParmDeclarator);
 // Parse GNU attributes, if present.
 MaybeParseGNUAttributes(ParmDeclarator);
 // C.
 if (Tok.is(tok::equal)) {
 SourceLocation EqualLoc = Tok.getLocation();
 // Parse the default argument
-if (DeclaratorCtx == DeclaratorContext::MemberContext) {
+if (DeclaratorCtx == DeclaratorContext::Member) {
 // If we're inside a class definition, cache the tokens
 // corresponding to the default argument. We'll actually parse
 // them when we see the end of the class definition.
 DefArgToks.reset(new CachedTokens);
 T.getOpenLocation(),
 T.getCloseLocation()),
 std::move(attrs), T.getCloseLocation());
 return;
 } else if (Tok.getKind() == tok::code_completion) {
+cutOffParsing();
 Actions.CodeCompleteBracketDeclarator(getCurScope());
-return cutOffParsing();
+return;
 }
 // If valid, this location is the position where we read the 'static' keyword.
 SourceLocation StaticLoc;
 TryConsumeToken(tok::kw_static, StaticLoc);
 case tok::kw_char:
 case tok::kw_int:
 case tok::kw_float:
 case tok::kw_double:
 case tok::kw_bool:
+case tok::kw__Bool:
 case tok::kw___bool:
 case tok::kw___pixel:
 Tok.setKind(tok::kw___vector);
 return true;
 case tok::identifier:
 if (Next.getIdentifierInfo() == Ident_pixel) {
 Tok.setKind(tok::kw___vector);
 return true;
 }
-if (Next.getIdentifierInfo() == Ident_bool) {
+if (Next.getIdentifierInfo() == Ident_bool ||
+Next.getIdentifierInfo() == Ident_Bool) {
 Tok.setKind(tok::kw___vector);
 return true;
 }
 return false;
 }
 case tok::kw_char:
 case tok::kw_int:
 case tok::kw_float:
 case tok::kw_double:
 case tok::kw_bool:
+case tok::kw__Bool:
 case tok::kw___bool:
 case tok::kw___pixel:
 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
 return true;
 case tok::identifier:
 if (Next.getIdentifierInfo() == Ident_pixel) {
 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
 return true;
 }
-if (Next.getIdentifierInfo() == Ident_bool) {
+if (Next.getIdentifierInfo() == Ident_bool ||
-isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
+Next.getIdentifierInfo() == Ident_Bool) {
+isInvalid =
+DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
 return true;
 }
 break;
 default:
 break;

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/Parse/ParseDecl.cpp @ 207:2e18cbf3894f