AST cleanups and extend codegen

Author: tschuett

CMakeLists.txt

@@ -7,6 +7,9 @@ message(STATUS "Using LLVM in: ${LLVM_DIR}")
 set (CMAKE_CXX_STANDARD 20)
 set (CMAKE_CXX_EXTENSIONS OFF)
 
+#add_compile_options(-fsanitize=address)
+#add_link_options(-fsanitize=address)
+
 include(CheckTypeSize)
 
 check_type_size("__int128" SIZEOF_INT128)

code/ast/Item.cpp

@@ -11,10 +11,6 @@ void Item::setOuterAttributes(std::span<OuterAttribute> outer) {
   outerAttributes = {outer.begin(), outer.end()};
 }
 
-void Item::setVisItem(std::shared_ptr<VisItem> _visItem) { visItem = _visItem; }
-
-std::shared_ptr<VisItem> Item::getVisItem() const { return visItem; }
-
 std::span<OuterAttribute> Item::getOuterAttributes()  {
   return outerAttributes;
 }

code/crate_builder/CrateBuilder.cpp

@@ -21,7 +21,7 @@ namespace rust_compiler::crate_builder {
 void CrateBuilder::emitCrate(rust_compiler::ast::Crate *crate) {
 
   for (auto &i : crate->getItems()) {
-    emitItem(i);
+    emitItem(i.get());
   }
 }
 

code/crate_builder/Function.cpp

@@ -16,8 +16,6 @@ using namespace rust_compiler::adt;
 namespace rust_compiler::crate_builder {
 
 mlir::FunctionType CrateBuilder::getFunctionType(ast::Function *fun) {
-  assert(false);
-
   llvm::SmallVector<mlir::Type> parameterType;
   FunctionParameters params = fun->getParams();
   std::vector<FunctionParam> parms = params.getParams();
@@ -49,13 +47,13 @@ mlir::FunctionType CrateBuilder::getFunctionType(ast::Function *fun) {
 }
 
 /// FIXME set visibility: { sym_visibility = "public" }
-void CrateBuilder::emitFunction(std::shared_ptr<ast::Function> f) {
+void CrateBuilder::emitFunction(ast::Function* f) {
 
   ScopedHashTableScope<std::string, mlir::Value> scope(symbolTable);
 
   builder.setInsertionPointToEnd(theModule.getBody());
 
-  mlir::FunctionType funType = getFunctionType(f.get());
+  mlir::FunctionType funType = getFunctionType(f);
 
   mlir::func::FuncOp fun = builder.create<mlir::func::FuncOp>(
       getLocation(f->getLocation()), "foo", funType);

code/crate_builder/Item.cpp

@@ -1,3 +1,5 @@
+#include "AST/Item.h"
+
 #include "AST/Module.h"
 #include "AST/VisItem.h"
 #include "CrateBuilder/CrateBuilder.h"
@@ -8,16 +10,23 @@ using namespace rust_compiler::ast;
 
 namespace rust_compiler::crate_builder {
 
-void CrateBuilder::emitItem(std::shared_ptr<Item> &item) {
-
-  emitVisItem(item->getVisItem());
+void CrateBuilder::emitItem(Item *item) {
+  switch (item->getItemKind()) {
+  case ItemKind::VisItem: {
+    emitVisItem(static_cast<VisItem *>(item));
+    break;
+  }
+  case ItemKind::MacroItem: {
+    assert(false && "to be implemented");
+  }
+  }
 }
 
-void CrateBuilder::emitVisItem(std::shared_ptr<VisItem> visItem) {
+void CrateBuilder::emitVisItem(VisItem *visItem) {
 
   switch (visItem->getKind()) {
   case VisItemKind::Module: {
-    emitModule(std::static_pointer_cast<ast::Module>(visItem));
+    emitModule(static_cast<ast::Module *>(visItem));
     break;
   }
   case VisItemKind::ExternCrate: {
@@ -27,7 +36,7 @@ void CrateBuilder::emitVisItem(std::shared_ptr<VisItem> visItem) {
     break;
   }
   case VisItemKind::Function: {
-    emitFunction(std::static_pointer_cast<ast::Function>(visItem));
+    emitFunction(static_cast<ast::Function *>(visItem));
     break;
   }
   case VisItemKind::TypeAlias: {

code/crate_builder/Module.cpp

@@ -4,11 +4,9 @@
 
 namespace rust_compiler::crate_builder {
 
-void CrateBuilder::emitModule(std::shared_ptr<ast::Module> module) {
-
-  for (auto &mod : module->getItems()) {
-    emitItem(mod);
-  }
+void CrateBuilder::emitModule(ast::Module *module) {
+  for (auto &mod : module->getItems())
+    emitItem(mod.get());
 }
 
 } // namespace rust_compiler::crate_builder

code/crate_builder/Types.cpp

@@ -1,8 +1,79 @@
+#include "AST/Types/TypeExpression.h"
+#include "AST/Types/TypeNoBounds.h"
 #include "CrateBuilder/CrateBuilder.h"
 
+using namespace rust_compiler::ast::types;
+
 namespace rust_compiler::crate_builder {
 
-mlir::Type CrateBuilder::getType(ast::types::TypeExpression *) {
+mlir::Type CrateBuilder::getType(ast::types::TypeExpression *type) {
+  switch (type->getKind()) {
+  case TypeExpressionKind::TypeNoBounds: {
+    assert(false && "to be implemented");
+  }
+  case TypeExpressionKind::ImplTraitType: {
+    assert(false && "to be implemented");
+  }
+  case TypeExpressionKind::TraitObjectType: {
+    return getTypeNoBounds(static_cast<TypeNoBounds *>(type));
+  }
+  }
+}
+
+mlir::Type CrateBuilder::getTypeNoBounds(ast::types::TypeNoBounds *noBounds) {
+  assert(false);
+  switch (noBounds->getKind()) {
+  case TypeNoBoundsKind::ParenthesizedType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::ImplTraitType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::ImplTraitTypeOneBound: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::TraitObjectTypeOneBound: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::TypePath: {
+    return getTypePath(static_cast<TypePath *>(noBounds));
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::TupleType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::NeverType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::RawPointerType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::ReferenceType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::ArrayType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::SliceType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::InferredType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::QualifiedPathInType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::BareFunctionType: {
+    assert(false && "to be implemented");
+  }
+  case TypeNoBoundsKind::MacroInvocation: {
+    assert(false && "to be implemented");
+  }
+  }
+  assert(false);
+}
+
+mlir::Type CrateBuilder::getTypePath(ast::types::TypePath *path) {
   assert(false);
 }
 

code/include/AST/Item.h

@@ -24,12 +24,10 @@ class Item : public Node {
   explicit Item(Location loc, ItemKind kind) : Node(loc), kind(kind) {}
 
   void setOuterAttributes(std::span<OuterAttribute> outer);
-  void setVisItem(std::shared_ptr<VisItem> visItem);
 
   std::span<OuterAttribute> getOuterAttributes() ;
 
   ItemKind getItemKind() const { return kind; }
-  std::shared_ptr<VisItem> getVisItem() const;
 };
 
 } // namespace rust_compiler::ast

code/include/CrateBuilder/CrateBuilder.h

@@ -13,10 +13,12 @@
 #include "AST/MethodCallExpression.h"
 #include "AST/OperatorExpression.h"
 #include "AST/Types/TypeExpression.h"
+#include "AST/Types/TypeNoBounds.h"
 #include "AST/VariableDeclaration.h"
 #include "CrateBuilder/Target.h"
 #include "Hir/HirDialect.h"
 #include "AST/ReturnExpression.h"
+#include "AST/Types/TypePath.h"
 
 #include <llvm/MC/TargetRegistry.h>
 #include <llvm/Remarks/YAMLRemarkSerializer.h>
@@ -99,10 +101,10 @@ class CrateBuilder {
   mlir::ModuleOp getModule() const { return theModule; };
 
 private:
-  void emitItem(std::shared_ptr<ast::Item> &);
-  void emitVisItem(std::shared_ptr<ast::VisItem>);
-  void emitFunction(std::shared_ptr<ast::Function>);
-  void emitModule(std::shared_ptr<ast::Module>);
+  void emitItem(ast::Item *item);
+  void emitVisItem(ast::VisItem *vis);
+  void emitFunction(ast::Function *fun);
+  void emitModule(ast::Module*);
   std::optional<mlir::Value> emitBlockExpression(ast::BlockExpression *);
   std::optional<mlir::Value> emitStatements(ast::Statements);
   mlir::Value emitExpression(ast::Expression* expr);
@@ -126,6 +128,8 @@ class CrateBuilder {
   mlir::FunctionType getFunctionType(ast::Function *);
 
   mlir::Type getType(ast::types::TypeExpression *);
+  mlir::Type getTypeNoBounds(ast::types::TypeNoBounds *);
+  mlir::Type getTypePath(ast::types::TypePath *);
 
   /// Helper conversion for a Rust AST location to an MLIR location.
   mlir::Location getLocation(const Location &loc) {

code/sema/Item.cpp

@@ -1,6 +1,8 @@
 #include "AST/Module.h"
 #include "Sema/Sema.h"
 
+#include <memory>
+
 using namespace rust_compiler::ast;
 
 namespace rust_compiler::sema {
@@ -9,7 +11,15 @@ void Sema::walkItem(std::shared_ptr<ast::Item> item) {
 
   walkOuterAttributes(item->getOuterAttributes());
 
-  walkVisItem(item->getVisItem());
+  switch (item->getItemKind()) {
+  case ItemKind::VisItem: {
+    walkVisItem(std::static_pointer_cast<VisItem>(item));
+    break;
+  }
+  case ItemKind::MacroItem: {
+    break;
+  }
+  }
 }
 
 void Sema::analyzeItemDeclaration(std::shared_ptr<ast::Node> item) {