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

comparison clang/lib/Parse/ParseDeclCXX.cpp @ 252:1f2b6ac9f198 llvm-original

LLVM16-1

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Fri, 18 Aug 2023 09:04:13 +0900
parents	c4bab56944e8
children

comparison

equal deleted inserted replaced

-:c80f45b162ad
+:1f2b6ac9f198
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TokenKinds.h"
+#include "clang/Lex/LiteralSupport.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
+#include "clang/Sema/EnterExpressionEvaluationContext.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/TimeProfiler.h"
+#include <optional>
 using namespace clang;
 /// ParseNamespace - We know that the current token is a namespace keyword. This
 /// may either be a top level namespace or a block-level namespace alias. If
 ParseScope NamespaceScope(this, Scope::DeclScope);
 UsingDirectiveDecl *ImplicitUsingDirectiveDecl = nullptr;
 Decl *NamespcDecl = Actions.ActOnStartNamespaceDef(
 getCurScope(), InlineLoc, NamespaceLoc, IdentLoc, Ident,
-T.getOpenLocation(), attrs, ImplicitUsingDirectiveDecl);
+T.getOpenLocation(), attrs, ImplicitUsingDirectiveDecl, false);
 PrettyDeclStackTraceEntry CrashInfo(Actions.Context, NamespcDecl,
 NamespaceLoc, "parsing namespace");
 // Parse the contents of the namespace.  This includes parsing recovery on
 ParsedAttributes &attrs,
 BalancedDelimiterTracker &Tracker) {
 if (index == InnerNSs.size()) {
 while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
 Tok.isNot(tok::eof)) {
-ParsedAttributes Attrs(AttrFactory);
+ParsedAttributes DeclAttrs(AttrFactory);
-MaybeParseCXX11Attributes(Attrs);
+MaybeParseCXX11Attributes(DeclAttrs);
-ParseExternalDeclaration(Attrs);
+ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+ParseExternalDeclaration(DeclAttrs, EmptyDeclSpecAttrs);
 }
 // The caller is what called check -- we are simply calling
 // the close for it.
 Tracker.consumeClose();
 ParseScope NamespaceScope(this, Scope::DeclScope);
 UsingDirectiveDecl *ImplicitUsingDirectiveDecl = nullptr;
 Decl *NamespcDecl = Actions.ActOnStartNamespaceDef(
 getCurScope(), InnerNSs[index].InlineLoc, InnerNSs[index].NamespaceLoc,
 InnerNSs[index].IdentLoc, InnerNSs[index].Ident,
-Tracker.getOpenLocation(), attrs, ImplicitUsingDirectiveDecl);
+Tracker.getOpenLocation(), attrs, ImplicitUsingDirectiveDecl, true);
 assert(!ImplicitUsingDirectiveDecl &&
 "nested namespace definition cannot define anonymous namespace");
 ParseInnerNamespace(InnerNSs, ++index, InlineLoc, attrs, Tracker);
 ///         'extern' string-literal '{' declaration-seq[opt] '}'
 ///         'extern' string-literal declaration
 ///
 Decl *Parser::ParseLinkage(ParsingDeclSpec &DS, DeclaratorContext Context) {
 assert(isTokenStringLiteral() && "Not a string literal!");
-ExprResult Lang = ParseStringLiteralExpression(false);
+ExprResult Lang = ParseUnevaluatedStringLiteralExpression();
 ParseScope LinkageScope(this, Scope::DeclScope);
 Decl *LinkageSpec =
 Lang.isInvalid()
 ? nullptr
 : Actions.ActOnStartLinkageSpecification(
 getCurScope(), DS.getSourceRange().getBegin(), Lang.get(),
 Tok.is(tok::l_brace) ? Tok.getLocation() : SourceLocation());
 ParsedAttributes DeclAttrs(AttrFactory);
-MaybeParseCXX11Attributes(DeclAttrs);
+ParsedAttributes DeclSpecAttrs(AttrFactory);
+while (MaybeParseCXX11Attributes(DeclAttrs) ||
+MaybeParseGNUAttributes(DeclSpecAttrs))
+;
 if (Tok.isNot(tok::l_brace)) {
 // Reset the source range in DS, as the leading "extern"
 // does not really belong to the inner declaration ...
 DS.SetRangeStart(SourceLocation());
 DS.SetRangeEnd(SourceLocation());
 // ... but anyway remember that such an "extern" was seen.
 DS.setExternInLinkageSpec(true);
-ParseExternalDeclaration(DeclAttrs, &DS);
+ParseExternalDeclaration(DeclAttrs, DeclSpecAttrs, &DS);
 return LinkageSpec ? Actions.ActOnFinishLinkageSpecification(
 getCurScope(), LinkageSpec, SourceLocation())
 : nullptr;
 }
 case tok::r_brace:
 if (!NestedModules)
 break;
 [[fallthrough]];
 default:
-ParsedAttributes Attrs(AttrFactory);
+ParsedAttributes DeclAttrs(AttrFactory);
-MaybeParseCXX11Attributes(Attrs);
+MaybeParseCXX11Attributes(DeclAttrs);
-ParseExternalDeclaration(Attrs);
+ParseExternalDeclaration(DeclAttrs, DeclSpecAttrs);
 continue;
 }
 break;
 }
 return LinkageSpec ? Actions.ActOnFinishLinkageSpecification(
 getCurScope(), LinkageSpec, T.getCloseLocation())
 : nullptr;
 }
-/// Parse a C++ Modules TS export-declaration.
+/// Parse a standard C++ Modules export-declaration.
 ///
 ///       export-declaration:
 ///         'export' declaration
 ///         'export' '{' declaration-seq[opt] '}'
 ///
 getCurScope(), ExportLoc,
 Tok.is(tok::l_brace) ? Tok.getLocation() : SourceLocation());
 if (Tok.isNot(tok::l_brace)) {
 // FIXME: Factor out a ParseExternalDeclarationWithAttrs.
-ParsedAttributes Attrs(AttrFactory);
+ParsedAttributes DeclAttrs(AttrFactory);
-MaybeParseCXX11Attributes(Attrs);
+MaybeParseCXX11Attributes(DeclAttrs);
-ParseExternalDeclaration(Attrs);
+ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+ParseExternalDeclaration(DeclAttrs, EmptyDeclSpecAttrs);
 return Actions.ActOnFinishExportDecl(getCurScope(), ExportDecl,
 SourceLocation());
 }
 BalancedDelimiterTracker T(*this, tok::l_brace);
 T.consumeOpen();
-// The Modules TS draft says "An export-declaration shall declare at least one
-// entity", but the intent is that it shall contain at least one declaration.
-if (Tok.is(tok::r_brace) && getLangOpts().ModulesTS) {
-Diag(ExportLoc, diag::err_export_empty)
-<< SourceRange(ExportLoc, Tok.getLocation());
-}
 while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
 Tok.isNot(tok::eof)) {
-ParsedAttributes Attrs(AttrFactory);
+ParsedAttributes DeclAttrs(AttrFactory);
-MaybeParseCXX11Attributes(Attrs);
+MaybeParseCXX11Attributes(DeclAttrs);
-ParseExternalDeclaration(Attrs);
+ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+ParseExternalDeclaration(DeclAttrs, EmptyDeclSpecAttrs);
 }
 T.consumeClose();
 return Actions.ActOnFinishExportDecl(getCurScope(), ExportDecl,
 T.getCloseLocation());
 //   constructor.
 if (getLangOpts().CPlusPlus11 && Context == DeclaratorContext::Member &&
 Tok.is(tok::identifier) &&
 (NextToken().is(tok::semi) || NextToken().is(tok::comma) ||
 NextToken().is(tok::ellipsis) || NextToken().is(tok::l_square) ||
+NextToken().isRegularKeywordAttribute() ||
 NextToken().is(tok::kw___attribute)) &&
 D.SS.isNotEmpty() && LastII == Tok.getIdentifierInfo() &&
 !D.SS.getScopeRep()->getAsNamespace() &&
 !D.SS.getScopeRep()->getAsNamespaceAlias()) {
 SourceLocation IdLoc = ConsumeToken();
 MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs);
 // If we had any misplaced attributes from earlier, this is where they
 // should have been written.
 if (MisplacedAttrs.Range.isValid()) {
-Diag(MisplacedAttrs.Range.getBegin(), diag::err_attributes_not_allowed)
+auto *FirstAttr =
+MisplacedAttrs.empty() ? nullptr : &MisplacedAttrs.front();
+auto &Range = MisplacedAttrs.Range;
+(FirstAttr && FirstAttr->isRegularKeywordAttribute()
+? Diag(Range.getBegin(), diag::err_keyword_not_allowed) << FirstAttr
+: Diag(Range.getBegin(), diag::err_attributes_not_allowed))
 << FixItHint::CreateInsertionFromRange(
-Tok.getLocation(),
+Tok.getLocation(), CharSourceRange::getTokenRange(Range))
-CharSourceRange::getTokenRange(MisplacedAttrs.Range))
+<< FixItHint::CreateRemoval(Range);
-<< FixItHint::CreateRemoval(MisplacedAttrs.Range);
 Attrs.takeAllFrom(MisplacedAttrs);
 }
 // Maybe this is an alias-declaration.
 if (Tok.is(tok::equal) || InInitStatement) {
 ///
 Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd) {
 assert(Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert) &&
 "Not a static_assert declaration");
-// Save the token used for static assertion.
+// Save the token name used for static assertion.
-Token SavedTok = Tok;
+const char *TokName = Tok.getName();
 if (Tok.is(tok::kw__Static_assert) && !getLangOpts().C11)
 Diag(Tok, diag::ext_c11_feature) << Tok.getName();
 if (Tok.is(tok::kw_static_assert)) {
 if (!getLangOpts().CPlusPlus) {
-if (!getLangOpts().C2x)
+if (getLangOpts().C23)
+Diag(Tok, diag::warn_c23_compat_keyword) << Tok.getName();
+else
 Diag(Tok, diag::ext_ms_static_assert) << FixItHint::CreateReplacement(
 Tok.getLocation(), "_Static_assert");
 } else
 Diag(Tok, diag::warn_cxx98_compat_static_assert);
 }
 unsigned DiagVal;
 if (getLangOpts().CPlusPlus17)
 DiagVal = diag::warn_cxx14_compat_static_assert_no_message;
 else if (getLangOpts().CPlusPlus)
 DiagVal = diag::ext_cxx_static_assert_no_message;
-else if (getLangOpts().C2x)
+else if (getLangOpts().C23)
 DiagVal = diag::warn_c17_compat_static_assert_no_message;
 else
 DiagVal = diag::ext_c_static_assert_no_message;
 Diag(Tok, DiagVal) << getStaticAssertNoMessageFixIt(AssertExpr.get(),
 Tok.getLocation());
 if (ExpectAndConsume(tok::comma)) {
 SkipUntil(tok::semi);
 return nullptr;
 }
-if (!isTokenStringLiteral()) {
+bool ParseAsExpression = false;
+if (getLangOpts().CPlusPlus26) {
+for (unsigned I = 0;; ++I) {
+const Token &T = GetLookAheadToken(I);
+if (T.is(tok::r_paren))
+break;
+if (!tokenIsLikeStringLiteral(T, getLangOpts())) {
+ParseAsExpression = true;
+break;
+}
+}
+}
+if (ParseAsExpression)
+AssertMessage = ParseConstantExpressionInExprEvalContext();
+else if (tokenIsLikeStringLiteral(Tok, getLangOpts()))
+AssertMessage = ParseUnevaluatedStringLiteralExpression();
+else {
 Diag(Tok, diag::err_expected_string_literal)
 << /*Source='static_assert'*/ 1;
 SkipMalformedDecl();
 return nullptr;
 }
-AssertMessage = ParseStringLiteralExpression();
 if (AssertMessage.isInvalid()) {
 SkipMalformedDecl();
 return nullptr;
 }
 }
 T.consumeClose();
 DeclEnd = Tok.getLocation();
-// Passing the token used to the error message.
+ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert, TokName);
-ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert,
-SavedTok.getName());
 return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc, AssertExpr.get(),
 AssertMessage.get(),
 T.getCloseLocation());
 }
 }
 // Check for C++1y 'decltype(auto)'.
 if (Tok.is(tok::kw_auto) && NextToken().is(tok::r_paren)) {
 // the typename-specifier in a function-style cast expression may
-// be 'auto' since C++2b.
+// be 'auto' since C++23.
 Diag(Tok.getLocation(),
 getLangOpts().CPlusPlus14
 ? diag::warn_cxx11_compat_decltype_auto_type_specifier
 : diag::ext_decltype_auto_type_specifier);
 ConsumeToken();
 void Parser::ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs) {
 while (Tok.isOneOf(tok::kw___single_inheritance,
 tok::kw___multiple_inheritance,
 tok::kw___virtual_inheritance)) {
 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
+auto Kind = Tok.getKind();
 SourceLocation AttrNameLoc = ConsumeToken();
-attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
+attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0, Kind);
-ParsedAttr::AS_Keyword);
 }
 }
 /// Determine whether the following tokens are valid after a type-specifier
 /// which could be a standalone declaration. This will conservatively return
 /// true if there's any doubt, and is appropriate for insert-';' fixits.
 bool Parser::isValidAfterTypeSpecifier(bool CouldBeBitfield) {
 // This switch enumerates the valid "follow" set for type-specifiers.
 switch (Tok.getKind()) {
 default:
+if (Tok.isRegularKeywordAttribute())
+return true;
 break;
 case tok::semi:              // struct foo {...} ;
 case tok::star:              // struct foo {...} *         P;
 case tok::amp:               // struct foo {...} &         R = ...
 case tok::ampamp:            // struct foo {...} &&        R = ...
 tok::kw___is_scoped_enum,
 tok::kw___is_sealed,
 tok::kw___is_signed,
 tok::kw___is_standard_layout,
 tok::kw___is_trivial,
+tok::kw___is_trivially_equality_comparable,
 tok::kw___is_trivially_assignable,
 tok::kw___is_trivially_constructible,
 tok::kw___is_trivially_copyable,
 tok::kw___is_unbounded_array,
 tok::kw___is_union,
 // "FOO : BAR" is not a potential typo for "FOO::BAR".  In this context it
 // is a base-specifier-list.
 ColonProtectionRAIIObject X(*this);
 CXXScopeSpec Spec;
+if (TemplateInfo.TemplateParams)
+Spec.setTemplateParamLists(*TemplateInfo.TemplateParams);
 bool HasValidSpec = true;
 if (ParseOptionalCXXScopeSpecifier(Spec, /*ObjectType=*/nullptr,
 /*ObjectHasErrors=*/false,
 EnteringContext)) {
 DS.SetTypeSpecError();
 TUK = Sema::TUK_Definition;
 }
 } else if (isClassCompatibleKeyword() &&
 (NextToken().is(tok::l_square) ||
 NextToken().is(tok::kw_alignas) ||
+NextToken().isRegularKeywordAttribute() ||
 isCXX11VirtSpecifier(NextToken()) != VirtSpecifiers::VS_None)) {
 // We can't tell if this is a definition or reference
 // until we skipped the 'final' and C++11 attribute specifiers.
 TentativeParsingAction PA(*this);
 } else if (Tok.is(tok::kw_alignas) && NextToken().is(tok::l_paren)) {
 ConsumeToken();
 ConsumeParen();
 if (!SkipUntil(tok::r_paren, StopAtSemi))
 break;
+} else if (Tok.isRegularKeywordAttribute()) {
+ConsumeToken();
 } else {
 break;
 }
 }
 // is between class-key and class-name. If there are
 // any attributes after class-name, we try a fixit to move
 // them to the right place.
 SourceRange AttrRange = Attributes.Range;
 if (AttrRange.isValid()) {
-Diag(AttrRange.getBegin(), diag::err_attributes_not_allowed)
+auto *FirstAttr = Attributes.empty() ? nullptr : &Attributes.front();
+auto Loc = AttrRange.getBegin();
+(FirstAttr && FirstAttr->isRegularKeywordAttribute()
+? Diag(Loc, diag::err_keyword_not_allowed) << FirstAttr
+: Diag(Loc, diag::err_attributes_not_allowed))
 << AttrRange
 << FixItHint::CreateInsertionFromRange(
 AttrFixitLoc, CharSourceRange(AttrRange, true))
 << FixItHint::CreateRemoval(AttrRange);
 // Can't build the declaration.
 } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
 TUK == Sema::TUK_Declaration) {
 // This is an explicit instantiation of a class template.
 ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+diag::err_keyword_not_allowed,
 /*DiagnoseEmptyAttrs=*/true);
 TagOrTempResult = Actions.ActOnExplicitInstantiation(
 getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc,
 TagType, StartLoc, SS, TemplateId->Template,
 // We diagnose this error in ActOnClassTemplateSpecialization.
 } else if (TUK == Sema::TUK_Reference ||
 (TUK == Sema::TUK_Friend &&
 TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) {
 ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+diag::err_keyword_not_allowed,
 /*DiagnoseEmptyAttrs=*/true);
 TypeResult = Actions.ActOnTagTemplateIdType(
 TUK, TagType, StartLoc, SS, TemplateId->TemplateKWLoc,
 TemplateId->Template, TemplateId->TemplateNameLoc,
 TemplateId->LAngleLoc, TemplateArgsPtr, TemplateId->RAngleLoc);
 // Create a fake template parameter list that contains only
 // "template<>", so that we treat this construct as a class
 // template specialization.
 FakedParamLists.push_back(Actions.ActOnTemplateParameterList(
-0, SourceLocation(), TemplateInfo.TemplateLoc, LAngleLoc, None,
+0, SourceLocation(), TemplateInfo.TemplateLoc, LAngleLoc,
-LAngleLoc, nullptr));
+std::nullopt, LAngleLoc, nullptr));
 TemplateParams = &FakedParamLists;
 }
 }
 // Build the class template specialization.
 getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc,
 TagType, StartLoc, SS, Name, NameLoc, attrs);
 } else if (TUK == Sema::TUK_Friend &&
 TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) {
 ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+diag::err_keyword_not_allowed,
 /*DiagnoseEmptyAttrs=*/true);
 TagOrTempResult = Actions.ActOnTemplatedFriendTag(
 getCurScope(), DS.getFriendSpecLoc(), TagType, StartLoc, SS, Name,
 NameLoc, attrs,
 MultiTemplateParamsArg(TemplateParams ? &(*TemplateParams)[0] : nullptr,
 TemplateParams ? TemplateParams->size() : 0));
 } else {
 if (TUK != Sema::TUK_Declaration && TUK != Sema::TUK_Definition)
 ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+diag::err_keyword_not_allowed,
 /* DiagnoseEmptyAttrs=*/true);
 if (TUK == Sema::TUK_Definition &&
 TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
 // If the declarator-id is not a template-id, issue a diagnostic and
 DS.getModulePrivateSpecLoc(), TParams, Owned, IsDependent,
 SourceLocation(), false, clang::TypeResult(),
 DSC == DeclSpecContext::DSC_type_specifier,
 DSC == DeclSpecContext::DSC_template_param ||
 DSC == DeclSpecContext::DSC_template_type_arg,
-&SkipBody);
+OffsetOfState, &SkipBody);
 // If ActOnTag said the type was dependent, try again with the
 // less common call.
 if (IsDependent) {
 assert(TUK == Sema::TUK_Reference || TUK == Sema::TUK_Friend);
 ProhibitAttributes(DeclAttrs);
 RecordDecl *AnonRecord = nullptr;
 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
 getCurScope(), AS, DS, DeclAttrs, TemplateParams, false, AnonRecord);
+Actions.ActOnDefinedDeclarationSpecifier(TheDecl);
 DS.complete(TheDecl);
 if (AnonRecord) {
 Decl *decls[] = {AnonRecord, TheDecl};
 return Actions.BuildDeclaratorGroup(decls);
 }
 return Actions.ConvertDeclToDeclGroup(TheDecl);
 }
+if (DS.hasTagDefinition())
+Actions.ActOnDefinedDeclarationSpecifier(DS.getRepAsDecl());
 ParsingDeclarator DeclaratorInfo(*this, DS, DeclAttrs,
 DeclaratorContext::Member);
 if (TemplateInfo.TemplateParams)
 DeclaratorInfo.setTemplateParameterLists(TemplateParams);
 // C++11 [dcl.attr.grammar] p4: If an attribute-specifier-seq appertains
 // to a friend declaration, that declaration shall be a definition.
 //
 // Diagnose attributes that appear in a friend member function declarator:
 //   friend int foo [[]] ();
-SmallVector<SourceRange, 4> Ranges;
+for (const ParsedAttr &AL : DeclaratorInfo.getAttributes())
-DeclaratorInfo.getCXX11AttributeRanges(Ranges);
+if (AL.isCXX11Attribute() || AL.isRegularKeywordAttribute()) {
-for (SmallVectorImpl<SourceRange>::iterator I = Ranges.begin(),
+auto Loc = AL.getRange().getBegin();
-E = Ranges.end();
+(AL.isRegularKeywordAttribute()
-I != E; ++I)
+? Diag(Loc, diag::err_keyword_not_allowed) << AL
-Diag((*I).getBegin(), diag::err_attributes_not_allowed) << *I;
+: Diag(Loc, diag::err_attributes_not_allowed))
+<< AL.getRange();
+}
 ThisDecl = Actions.ActOnFriendFunctionDecl(getCurScope(), DeclaratorInfo,
 TemplateParams);
 } else {
 ThisDecl = Actions.ActOnCXXMemberDeclarator(
 SourceLocation &EqualLoc) {
 assert(Tok.isOneOf(tok::equal, tok::l_brace) &&
 "Data member initializer not starting with '=' or '{'");
 EnterExpressionEvaluationContext Context(
-Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, D);
+Actions,
+isa_and_present<FieldDecl>(D)
+? Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed
+: Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
+D);
+Actions.ExprEvalContexts.back().InImmediateEscalatingFunctionContext = true;
 if (TryConsumeToken(tok::equal, EqualLoc)) {
 if (Tok.is(tok::kw_delete)) {
 // In principle, an initializer of '= delete p;' is legal, but it will
 // never type-check. It's better to diagnose it as an ill-formed
 // expression than as an ill-formed deleted non-function member. An
 BalancedDelimiterTracker T(*this, tok::l_paren);
 T.consumeOpen();
 // Parse the optional expression-list.
 ExprVector ArgExprs;
-CommaLocsTy CommaLocs;
 auto RunSignatureHelp = [&] {
 if (TemplateTypeTy.isInvalid())
 return QualType();
 QualType PreferredType = Actions.ProduceCtorInitMemberSignatureHelp(
 ConstructorDecl, SS, TemplateTypeTy.get(), ArgExprs, II,
 T.getOpenLocation(), /*Braced=*/false);
 CalledSignatureHelp = true;
 return PreferredType;
 };
-if (Tok.isNot(tok::r_paren) &&
+if (Tok.isNot(tok::r_paren) && ParseExpressionList(ArgExprs, [&] {
-ParseExpressionList(ArgExprs, CommaLocs, [&] {
 PreferredType.enterFunctionArgument(Tok.getLocation(),
 RunSignatureHelp);
 })) {
 if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
 RunSignatureHelp();
 Scope::FunctionDeclarationScope |
 Scope::FunctionPrototypeScope);
 Actions.ActOnStartTrailingRequiresClause(getCurScope(), D);
-llvm::Optional<Sema::CXXThisScopeRAII> ThisScope;
+std::optional<Sema::CXXThisScopeRAII> ThisScope;
 InitCXXThisScopeForDeclaratorIfRelevant(D, D.getDeclSpec(), ThisScope);
 TrailingRequiresClause =
 ParseConstraintLogicalOrExpression(/*IsTrailingRequiresClause=*/true);
 return nullptr;
 case tok::code_completion:
 cutOffParsing();
 Actions.CodeCompleteAttribute(getLangOpts().CPlusPlus ? ParsedAttr::AS_CXX11
-: ParsedAttr::AS_C2x,
+: ParsedAttr::AS_C23,
 Completion, Scope);
 return nullptr;
 case tok::numeric_constant: {
 // If we got a numeric constant, check to see if it comes from a macro that
 ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
 SourceLocation ScopeLoc, CachedTokens &OpenMPTokens) {
 assert(Tok.is(tok::l_paren) && "Not a C++11 attribute argument list");
 SourceLocation LParenLoc = Tok.getLocation();
 const LangOptions &LO = getLangOpts();
-ParsedAttr::Syntax Syntax =
+ParsedAttr::Form Form =
-LO.CPlusPlus ? ParsedAttr::AS_CXX11 : ParsedAttr::AS_C2x;
+LO.CPlusPlus ? ParsedAttr::Form::CXX11() : ParsedAttr::Form::C23();
 // Try parsing microsoft attributes
 if (getLangOpts().MicrosoftExt || getLangOpts().HLSL) {
 if (hasAttribute(AttributeCommonInfo::Syntax::AS_Microsoft, ScopeName,
 AttrName, getTargetInfo(), getLangOpts()))
-Syntax = ParsedAttr::AS_Microsoft;
+Form = ParsedAttr::Form::Microsoft();
 }
 // If the attribute isn't known, we will not attempt to parse any
 // arguments.
-if (Syntax != ParsedAttr::AS_Microsoft &&
+if (Form.getSyntax() != ParsedAttr::AS_Microsoft &&
 !hasAttribute(LO.CPlusPlus ? AttributeCommonInfo::Syntax::AS_CXX11
-: AttributeCommonInfo::Syntax::AS_C2x,
+: AttributeCommonInfo::Syntax::AS_C23,
 ScopeName, AttrName, getTargetInfo(), getLangOpts())) {
 if (getLangOpts().MicrosoftExt || getLangOpts().HLSL) {
 }
 // Eat the left paren, then skip to the ending right paren.
 ConsumeParen();
 if (ScopeName && (ScopeName->isStr("gnu") || ScopeName->isStr("__gnu__"))) {
 // GNU-scoped attributes have some special cases to handle GNU-specific
 // behaviors.
 ParseGNUAttributeArgs(AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
-ScopeLoc, Syntax, nullptr);
+ScopeLoc, Form, nullptr);
 return true;
 }
 if (ScopeName && ScopeName->isStr("omp")) {
 Diag(AttrNameLoc, getLangOpts().OpenMP >= 51
 unsigned NumArgs;
 // Some Clang-scoped attributes have some special parsing behavior.
 if (ScopeName && (ScopeName->isStr("clang") || ScopeName->isStr("_Clang")))
 NumArgs = ParseClangAttributeArgs(AttrName, AttrNameLoc, Attrs, EndLoc,
-ScopeName, ScopeLoc, Syntax);
+ScopeName, ScopeLoc, Form);
 else
 NumArgs = ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc,
-ScopeName, ScopeLoc, Syntax);
+ScopeName, ScopeLoc, Form);
 if (!Attrs.empty() &&
 IsBuiltInOrStandardCXX11Attribute(AttrName, ScopeName)) {
 ParsedAttr &Attr = Attrs.back();
 // If the attribute is a standard or built-in attribute and we are
 }
 }
 return true;
 }
-/// Parse a C++11 or C2x attribute-specifier.
+/// Parse a C++11 or C23 attribute-specifier.
 ///
 /// [C++11] attribute-specifier:
 ///         '[' '[' attribute-list ']' ']'
 ///         alignment-specifier
 ///
 ///         identifier
 void Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs,
 CachedTokens &OpenMPTokens,
 SourceLocation *EndLoc) {
 if (Tok.is(tok::kw_alignas)) {
-Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas);
+if (getLangOpts().C23)
+Diag(Tok, diag::warn_c23_compat_keyword) << Tok.getName();
+else
+Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas);
 ParseAlignmentSpecifier(Attrs, EndLoc);
 return;
 }
+if (Tok.isRegularKeywordAttribute()) {
+SourceLocation Loc = Tok.getLocation();
+IdentifierInfo *AttrName = Tok.getIdentifierInfo();
+Attrs.addNew(AttrName, Loc, nullptr, Loc, nullptr, 0, Tok.getKind());
+ConsumeToken();
+return;
+}
 assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square) &&
 "Not a double square bracket attribute list");
 SourceLocation OpenLoc = Tok.getLocation();
-Diag(OpenLoc, diag::warn_cxx98_compat_attribute);
+if (getLangOpts().CPlusPlus) {
+Diag(OpenLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_attribute
+: diag::warn_ext_cxx11_attributes);
+} else {
+Diag(OpenLoc, getLangOpts().C23 ? diag::warn_pre_c23_compat_attributes
+: diag::warn_ext_c23_attributes);
+}
 ConsumeBracket();
 checkCompoundToken(OpenLoc, tok::l_square, CompoundToken::AttrBegin);
 ConsumeBracket();
 SkipUntil(tok::r_square, tok::colon, StopBeforeMatch);
 }
 if (!TryConsumeToken(tok::colon) && CommonScopeName)
 Diag(Tok.getLocation(), diag::err_expected) << tok::colon;
 }
-llvm::SmallDenseMap<IdentifierInfo *, SourceLocation, 4> SeenAttrs;
 bool AttrParsed = false;
 while (!Tok.isOneOf(tok::r_square, tok::semi, tok::eof)) {
 if (AttrParsed) {
 // If we parsed an attribute, a comma is required before parsing any
 if (!AttrParsed) {
 Attrs.addNew(
 AttrName,
 SourceRange(ScopeLoc.isValid() ? ScopeLoc : AttrLoc, AttrLoc),
 ScopeName, ScopeLoc, nullptr, 0,
-getLangOpts().CPlusPlus ? ParsedAttr::AS_CXX11 : ParsedAttr::AS_C2x);
+getLangOpts().CPlusPlus ? ParsedAttr::Form::CXX11()
+: ParsedAttr::Form::C23());
 AttrParsed = true;
 }
 if (TryConsumeToken(tok::ellipsis))
 Diag(Tok, diag::err_cxx11_attribute_forbids_ellipsis) << AttrName;
 *EndLoc = Tok.getLocation();
 if (ExpectAndConsume(tok::r_square))
 SkipUntil(tok::r_square);
 }
-/// ParseCXX11Attributes - Parse a C++11 or C2x attribute-specifier-seq.
+/// ParseCXX11Attributes - Parse a C++11 or C23 attribute-specifier-seq.
 ///
 /// attribute-specifier-seq:
 ///       attribute-specifier-seq[opt] attribute-specifier
 void Parser::ParseCXX11Attributes(ParsedAttributes &Attrs) {
-assert(standardAttributesAllowed());
 SourceLocation StartLoc = Tok.getLocation();
 SourceLocation EndLoc = StartLoc;
 do {
 ParseCXX11AttributeSpecifier(Attrs, &EndLoc);
-} while (isCXX11AttributeSpecifier());
+} while (isAllowedCXX11AttributeSpecifier());
 Attrs.Range = SourceRange(StartLoc, EndLoc);
 }
 void Parser::DiagnoseAndSkipCXX11Attributes() {
+auto Keyword =
+Tok.isRegularKeywordAttribute() ? Tok.getIdentifierInfo() : nullptr;
 // Start and end location of an attribute or an attribute list.
 SourceLocation StartLoc = Tok.getLocation();
 SourceLocation EndLoc = SkipCXX11Attributes();
 if (EndLoc.isValid()) {
 SourceRange Range(StartLoc, EndLoc);
-Diag(StartLoc, diag::err_attributes_not_allowed) << Range;
+(Keyword ? Diag(StartLoc, diag::err_keyword_not_allowed) << Keyword
+: Diag(StartLoc, diag::err_attributes_not_allowed))
+<< Range;
 }
 }
 SourceLocation Parser::SkipCXX11Attributes() {
 SourceLocation EndLoc;
 if (Tok.is(tok::l_square)) {
 BalancedDelimiterTracker T(*this, tok::l_square);
 T.consumeOpen();
 T.skipToEnd();
 EndLoc = T.getCloseLocation();
+} else if (Tok.isRegularKeywordAttribute()) {
+EndLoc = Tok.getLocation();
+ConsumeToken();
 } else {
 assert(Tok.is(tok::kw_alignas) && "not an attribute specifier");
 ConsumeToken();
 BalancedDelimiterTracker T(*this, tok::l_paren);
 if (!T.consumeOpen())
 }
 if (!T.consumeClose()) {
 Attrs.addNew(UuidIdent, SourceRange(UuidLoc, T.getCloseLocation()), nullptr,
 SourceLocation(), ArgExprs.data(), ArgExprs.size(),
-ParsedAttr::AS_Microsoft);
+ParsedAttr::Form::Microsoft());
 }
 }
 /// ParseMicrosoftAttributes - Parse Microsoft attributes [Attr]
 ///
 SourceLocation(), OpenMPTokens);
 ReplayOpenMPAttributeTokens(OpenMPTokens);
 }
 if (!AttrParsed) {
 Attrs.addNew(II, NameLoc, nullptr, SourceLocation(), nullptr, 0,
-ParsedAttr::AS_Microsoft);
+ParsedAttr::Form::Microsoft());
 }
 }
 }
 }

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/Parse/ParseDeclCXX.cpp @ 252:1f2b6ac9f198 llvm-original