fix: Set the virt specifier attributes

Author: robertoraggi

src/frontend/cxx/ast_printer.cc

@@ -1942,6 +1942,24 @@ void ASTPrinter::visit(PtrToMemberOperatorAST* ast) {
 
 void ASTPrinter::visit(FunctionDeclaratorAST* ast) {
   fmt::print(out_, "{}\n", "function-declarator");
+  if (ast->isFinal) {
+    ++indent_;
+    fmt::print(out_, "{:{}}", "", indent_ * 2);
+    fmt::print(out_, "is-final: {}\n", ast->isFinal);
+    --indent_;
+  }
+  if (ast->isOverride) {
+    ++indent_;
+    fmt::print(out_, "{:{}}", "", indent_ * 2);
+    fmt::print(out_, "is-override: {}\n", ast->isOverride);
+    --indent_;
+  }
+  if (ast->isPure) {
+    ++indent_;
+    fmt::print(out_, "{:{}}", "", indent_ * 2);
+    fmt::print(out_, "is-pure: {}\n", ast->isPure);
+    --indent_;
+  }
   accept(ast->parametersAndQualifiers, "parameters-and-qualifiers");
   accept(ast->trailingReturnType, "trailing-return-type");
 }

src/parser/cxx/ast.h

@@ -3094,6 +3094,9 @@ class FunctionDeclaratorAST final : public DeclaratorModifierAST {
 
   ParametersAndQualifiersAST* parametersAndQualifiers = nullptr;
   TrailingReturnTypeAST* trailingReturnType = nullptr;
+  bool isFinal = false;
+  bool isOverride = false;
+  bool isPure = false;
 
   void accept(ASTVisitor* visitor) override { visitor->visit(this); }
 

src/parser/cxx/ast_cloner.cc

@@ -3539,6 +3539,12 @@ void ASTCloner::visit(FunctionDeclaratorAST* ast) {
   copy->parametersAndQualifiers = accept(ast->parametersAndQualifiers);
 
   copy->trailingReturnType = accept(ast->trailingReturnType);
+
+  copy->isFinal = ast->isFinal;
+
+  copy->isOverride = ast->isOverride;
+
+  copy->isPure = ast->isPure;
 }
 
 void ASTCloner::visit(ArrayDeclaratorAST* ast) {

src/parser/cxx/parser.cc

@@ -3664,7 +3664,7 @@ auto Parser::parse_notypespec_function_definition(
 
   const auto has_requires_clause = parse_requires_clause(requiresClause);
 
-  if (!has_requires_clause) parse_virt_specifier_seq();
+  if (!has_requires_clause) parse_virt_specifier_seq(functionDeclarator);
 
   SourceLocation semicolonLoc;
 
@@ -5513,12 +5513,11 @@ auto Parser::parse_expr_or_braced_init_list(ExpressionAST*& yyast) -> bool {
   return true;
 }
 
-auto Parser::parse_virt_specifier_seq() -> bool {
-  SourceLocation finalLoc;
-
-  if (!parse_virt_specifier(finalLoc)) return false;
+auto Parser::parse_virt_specifier_seq(FunctionDeclaratorAST* functionDeclarator)
+    -> bool {
+  if (!parse_virt_specifier(functionDeclarator)) return false;
 
-  while (parse_virt_specifier(finalLoc)) {
+  while (parse_virt_specifier(functionDeclarator)) {
     //
   }
 
@@ -6996,12 +6995,14 @@ auto Parser::parse_member_declaration_helper(DeclarationAST*& yyast) -> bool {
 
   const auto hasDeclarator = parse_declarator(declarator);
 
-  if (hasDeclarator && getFunctionDeclarator(declarator)) {
+  auto functionDeclarator = getFunctionDeclarator(declarator);
+
+  if (hasDeclarator && functionDeclarator) {
     RequiresClauseAST* requiresClause = nullptr;
 
     const auto has_requires_clause = parse_requires_clause(requiresClause);
 
-    if (!has_requires_clause) parse_virt_specifier_seq();
+    if (!has_requires_clause) parse_virt_specifier_seq(functionDeclarator);
 
     if (lookat_function_body()) {
       FunctionBodyAST* functionBody = nullptr;
@@ -7125,14 +7126,20 @@ auto Parser::parse_member_declarator(InitDeclaratorAST*& yyast,
 
   ast->declarator = declarator;
 
-  if (getFunctionDeclarator(declarator)) {
+  if (auto functionDeclarator = getFunctionDeclarator(declarator)) {
     RequiresClauseAST* requiresClause = nullptr;
 
     if (parse_requires_clause(requiresClause)) {
       ast->requiresClause = requiresClause;
     } else {
-      parse_virt_specifier_seq();
-      parse_pure_specifier();
+      parse_virt_specifier_seq(functionDeclarator);
+
+      SourceLocation equalLoc;
+      SourceLocation zeroLoc;
+
+      const auto isPure = parse_pure_specifier(equalLoc, zeroLoc);
+
+      functionDeclarator->isPure = isPure;
     }
 
     return true;
@@ -7143,24 +7150,30 @@ auto Parser::parse_member_declarator(InitDeclaratorAST*& yyast,
   return true;
 }
 
-auto Parser::parse_virt_specifier(SourceLocation& loc) -> bool {
-  if (parse_final(loc)) return true;
+auto Parser::parse_virt_specifier(FunctionDeclaratorAST* functionDeclarator)
+    -> bool {
+  SourceLocation loc;
+
+  if (parse_final(loc)) {
+    functionDeclarator->isFinal = true;
+    return true;
+  }
 
-  if (parse_override(loc)) return true;
+  if (parse_override(loc)) {
+    functionDeclarator->isOverride = true;
+    return true;
+  }
 
   return false;
 }
 
-auto Parser::parse_pure_specifier() -> bool {
-  SourceLocation equalLoc;
-
+auto Parser::parse_pure_specifier(SourceLocation& equalLoc,
+                                  SourceLocation& zeroLoc) -> bool {
   if (!match(TokenKind::T_EQUAL, equalLoc)) return false;
 
-  SourceLocation literalLoc;
-
-  if (!match(TokenKind::T_INTEGER_LITERAL, literalLoc)) return false;
+  if (!match(TokenKind::T_INTEGER_LITERAL, zeroLoc)) return false;
 
-  const auto& number = unit->tokenText(literalLoc);
+  const auto& number = unit->tokenText(zeroLoc);
 
   if (number != "0") return false;
 

src/parser/cxx/parser.h

@@ -330,7 +330,8 @@ class Parser final {
       DesignatedInitializerClauseAST*& yyast) -> bool;
   auto parse_designator(DesignatorAST*& yyast) -> bool;
   auto parse_expr_or_braced_init_list(ExpressionAST*& yyast) -> bool;
-  auto parse_virt_specifier_seq() -> bool;
+  auto parse_virt_specifier_seq(FunctionDeclaratorAST* functionDeclarator)
+      -> bool;
   auto lookat_function_body() -> bool;
   auto parse_function_body(FunctionBodyAST*& yyast) -> bool;
   auto parse_enum_specifier(SpecifierAST*& yyast) -> bool;
@@ -398,8 +399,9 @@ class Parser final {
                                     const DeclSpecs& specs) -> bool;
   auto parse_member_declarator(InitDeclaratorAST*& yyast,
                                const DeclSpecs& specs) -> bool;
-  auto parse_virt_specifier(SourceLocation& loc) -> bool;
-  auto parse_pure_specifier() -> bool;
+  auto parse_virt_specifier(FunctionDeclaratorAST* functionDeclarator) -> bool;
+  auto parse_pure_specifier(SourceLocation& equalLoc, SourceLocation& zeroLoc)
+      -> bool;
   auto parse_conversion_function_id(NameAST*& yyast) -> bool;
   auto parse_base_clause(BaseClauseAST*& yyast) -> bool;
   auto parse_base_specifier_list(List<BaseSpecifierAST*>*& yyast) -> bool;