Add option to report missing types for expressions

Signed-off-by: Roberto Raggi <[email protected]>

Author: robertoraggi

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

@@ -100,6 +100,13 @@ export function gen_ast_h({ ast, output }: { ast: AST; output: string }) {
     });
   });
 
+  emit(`
+template <typename T>
+[[nodiscard]] auto ast_cast(AST* ast) -> T* {
+  return ast && ast->kind() == T::Kind ? static_cast<T*>(ast) : nullptr;
+}
+`);
+
   by_bases.forEach((nodes, base) => {
     if (base === "AST") return;
     if (!Array.isArray(nodes)) throw new Error("not an array");
@@ -116,15 +123,17 @@ export function gen_ast_h({ ast, output }: { ast: AST; output: string }) {
     emit(`    default: cxx_runtime_error("unexpected ${variantName}");`);
     emit(`  } // switch`);
     emit(`}`);
+
     emit();
-    emit(`[[nodiscard]] inline auto is${variantName}(AST* ast) -> bool {`);
-    emit(`  if (!ast) return false;`);
+    emit(`template <>`);
+    emit(`[[nodiscard]] inline auto ast_cast<${base}>(AST* ast) -> ${base}* {`);
+    emit(`  if (!ast) return nullptr;`);
     emit(`  switch (ast->kind()) {`);
     nodes.forEach(({ name }) => {
       emit(`  case ${name}::Kind: `);
     });
-    emit(`  return true;`);
-    emit(`    default: return false;`);
+    emit(`    return static_cast<${base}*>(ast);`);
+    emit(`    default: return nullptr;`);
     emit(`  } // switch`);
     emit(`}`);
   });
@@ -253,11 +262,6 @@ template <typename T>
 
 ${code.join("\n")}
 
-template <typename T>
-[[nodiscard]] auto ast_cast(AST* ast) -> T* {
-  return ast && ast->kind() == T::Kind ? static_cast<T*>(ast) : nullptr;
-}
-
 } // namespace cxx
 `;
 

src/frontend/cxx/frontend.cc

@@ -19,6 +19,7 @@
 // SOFTWARE.
 
 #include <cxx/ast.h>
+#include <cxx/ast_cursor.h>
 #include <cxx/ast_visitor.h>
 #include <cxx/cli.h>
 #include <cxx/control.h>
@@ -43,7 +44,6 @@
 #include <cxx/mlir/cxx_dialect.h>
 #endif
 
-#include <cassert>
 #include <format>
 #include <fstream>
 #include <iostream>
@@ -55,8 +55,45 @@
 #include "verify_diagnostics_client.h"
 
 namespace {
+
 using namespace cxx;
 
+struct CheckExpressionTypes {
+  [[nodiscard]] auto operator()(TranslationUnit* unit) {
+    std::size_t missingTypes = 0;
+
+    // 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;
+
+      if (!std::holds_alternative<AST*>(current.node)) {
+        // skip non-AST nodes
+        continue;
+      }
+
+      auto ast = std::get<AST*>(current.node);
+      auto expression = ast_cast<ExpressionAST>(ast);
+      if (!expression) {
+        // skip non-expression nodes
+        continue;
+      }
+
+      auto type = expression->type;
+      if (type) {
+        // the expression has a type
+        continue;
+      }
+
+      auto loc = expression->firstSourceLocation();
+      unit->warning(loc, std::format("missing type for expression"));
+      ++missingTypes;
+    }
+
+    return missingTypes == 0;
+  }
+};
+
 auto readAll(const std::string& fileName, std::istream& in)
     -> std::optional<std::string> {
   std::string code;
@@ -282,6 +319,11 @@ auto runOnFile(const CLI& cli, const std::string& fileName) -> bool {
         .templates = cli.opt_ftemplates,
     });
 
+    if (cli.opt_freport_missing_types) {
+      CheckExpressionTypes checkExpressionTypes;
+      const auto missingTypes = checkExpressionTypes(&unit);
+    }
+
     if (cli.opt_dump_symbols && unit.globalScope()) {
       dump(std::cout, unit.globalScope()->owner());
     }