Implement default traversal for the entire AST

Author: robertoraggi

packages/cxx-gen-ast/src/gen.ts

@@ -31,6 +31,7 @@ import { gen_ast_slot_cc } from "./gen_ast_slot_cc.js";
 import { gen_ast_slot_h } from "./get_ast_slot_h.js";
 import { gen_ast_ts } from "./gen_ast_ts.js";
 import { gen_ast_visitor_h } from "./gen_ast_visitor_h.js";
+import { gen_ast_visitor_cc } from "./gen_ast_visitor_cc.js";
 import { gen_ast_visitor_ts } from "./gen_ast_visitor_ts.js";
 import { parseAST } from "./parseAST.js";
 import { gen_ast_kind_ts } from "./gen_ast_kind_ts.js";
@@ -67,6 +68,10 @@ gen_ast_visitor_h({
   ast,
   output: path.join(outdir, "src/parser/cxx/ast_visitor.h"),
 });
+gen_ast_visitor_cc({
+  ast,
+  output: path.join(outdir, "src/parser/cxx/ast_visitor.cc"),
+});
 gen_ast_printer_h({
   ast,
   output: path.join(outdir, "src/parser/cxx/ast_printer.h"),

packages/cxx-gen-ast/src/gen_ast_visitor_cc.ts

@@ -0,0 +1,91 @@
+// Copyright (c) 2024 Roberto Raggi <[email protected]>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+import { groupNodesByBaseType } from "./groupNodesByBaseType.js";
+import { AST, getASTNodes } from "./parseAST.js";
+import { cpy_header } from "./cpy_header.js";
+import * as fs from "fs";
+
+export function gen_ast_visitor_cc({
+  ast,
+  output,
+}: {
+  ast: AST;
+  output: string;
+}) {
+  const code: string[] = [];
+  const emit = (line = "") => code.push(line);
+
+  const by_base = groupNodesByBaseType(ast);
+
+  const types = new Set<string>();
+
+  ast.nodes.forEach((node) => {
+    node.members.forEach((m) => {
+      if (m.kind === "node" || m.kind === "node-list") types.add(m.type);
+    });
+  });
+
+  by_base.forEach((nodes) => {
+    nodes.forEach(({ name, members }) => {
+      members = getASTNodes(members);
+
+      emit();
+      emit(`void ASTVisitor::visit(${name}* ast) {`);
+      members.forEach((m) => {
+        if (m.kind === "node") {
+          emit(`accept(ast->${m.name});`);
+        } else if (m.kind === "node-list") {
+          emit(`for (auto node : ListView{ast->${m.name}}) {`);
+          emit(`accept(node);`);
+          emit(`}`);
+        }
+      });
+      emit(`}`);
+    });
+  });
+
+  const out = `${cpy_header}
+#include <cxx/ast_visitor.h>
+
+// cxx
+#include <cxx/ast.h>
+
+namespace cxx {
+
+auto ASTVisitor::preVisit(AST*) -> bool {
+  return true;
+}
+
+void ASTVisitor::postVisit(AST*) {}
+
+void ASTVisitor::accept(AST* ast) {
+    if (!ast) return;
+    if (preVisit(ast)) ast->accept(this);
+    postVisit(ast);
+}
+
+${code.join("\n")}
+
+} // namespace cxx
+`;
+
+  fs.writeFileSync(output, out);
+}

packages/cxx-gen-ast/src/gen_ast_visitor_h.ts

@@ -40,7 +40,7 @@ export function gen_ast_visitor_h({
     emit();
     emit(`  // ${base}`);
     nodes.forEach(({ name }) => {
-      emit(`  virtual void visit(${name}* ast) = 0;`);
+      emit(`  virtual void visit(${name}* ast);`);
     });
   });
 
@@ -55,6 +55,12 @@ namespace cxx {
 class ASTVisitor {
 public:
   virtual ~ASTVisitor() = default;
+
+  void accept(AST* ast);
+
+  [[nodiscard]] virtual bool preVisit(AST* ast);
+  virtual void postVisit(AST* ast);
+
 ${code.join("\n")}
 };
 

src/frontend/cxx/frontend.cc

@@ -19,7 +19,6 @@
 // SOFTWARE.
 
 #include <cxx/ast.h>
-#include <cxx/ast_cursor.h>
 #include <cxx/ast_pretty_printer.h>
 #include <cxx/ast_printer.h>
 #include <cxx/ast_visitor.h>
@@ -56,43 +55,48 @@ namespace {
 
 using namespace cxx;
 
-struct CheckExpressionTypes {
+class CheckExpressionTypes final : private ASTVisitor {
+ public:
   [[nodiscard]] auto operator()(TranslationUnit* unit) {
     std::size_t missingTypes = 0;
+    std::swap(unit_, unit);
+    std::swap(missingTypes_, missingTypes);
 
-    // iterate over all expressions and check if they have a type
-    for (auto cursor = ASTCursor{unit->ast(), "unit"}; cursor;
-         cursor = ++cursor) {
-      const auto& current = *cursor;
+    accept(unit_->ast());
 
-      if (!std::holds_alternative<AST*>(current.node)) {
-        // skip non-AST nodes
-        continue;
-      }
+    std::swap(unit_, unit);
+    std::swap(missingTypes_, missingTypes);
 
-      auto ast = std::get<AST*>(current.node);
-      auto expression = ast_cast<ExpressionAST>(ast);
-      if (!expression) {
-        // skip non-expression nodes
-        continue;
-      }
+    return missingTypes == 0;
+  }
 
-      auto type = expression->type;
-      if (type) {
-        // the expression has a type
-        continue;
-      }
+ private:
+  using ASTVisitor::visit;
 
-      const auto loc = expression->firstSourceLocation();
+  auto preVisit(AST* ast) -> bool override {
+    if (ast_cast<TemplateDeclarationAST>(ast)) {
+      // skip template declarations, as they are not instantiated yet
+      return false;
+    }
+
+    if (auto expression = ast_cast<ExpressionAST>(ast)) {
+      if (!expression->type) {
+        const auto loc = expression->firstSourceLocation();
 
-      unit->warning(loc, std::format("untyped expression of kind '{}'",
-                                     to_string(expression->kind())));
+        unit_->warning(loc, std::format("untyped expression of kind '{}'",
+                                        to_string(expression->kind())));
 
-      ++missingTypes;
+        ++missingTypes_;
+        return false;
+      }
     }
 
-    return missingTypes == 0;
+    return true;  // visit children
   }
+
+ private:
+  TranslationUnit* unit_ = nullptr;
+  std::size_t missingTypes_ = 0;
 };
 
 auto readAll(const std::string& fileName, std::istream& in)

src/parser/CMakeLists.txt

@@ -27,6 +27,7 @@ add_library(cxx-parser
     cxx/ast_printer.cc
     cxx/ast_rewriter.cc
     cxx/ast_slot.cc
+    cxx/ast_visitor.cc
     cxx/ast.cc
     cxx/base_classes.cc
     cxx/binder.cc