Rename ImportStmt to ImportDef (#438)

src-bootstrap/ast/ast-nodes.spice

@@ -149,6 +149,13 @@ public type ASTExtDeclNode struct /*: IVisitable*/ {
 
 }
 
+// ========================================================= ImportDefNode =======================================================
+
+public type ASTImportDefNode struct /*: IVisitable*/ {
+    compose public ASTNode node
+
+}
+
 // ========================================================== UnsafeBlockNode ========================================================
 
 public type ASTUnsafeBlockNode struct /*: IVisitable*/ {
@@ -343,13 +350,6 @@ public type ASTAttrNode struct /*: IVisitable*/ {
 
 }
 
-// ========================================================= ImportStmtNode ======================================================
-
-public type ASTImportStmtNode struct /*: IVisitable*/ {
-    compose public ASTNode node
-
-}
-
 // ========================================================= ReturnStmtNode ======================================================
 
 public type ASTReturnStmtNode struct /*: IVisitable*/ {

src-bootstrap/parser/parser.spice

@@ -385,6 +385,21 @@ f<ASTExtDeclNode*> Parser.parseExtDecl() {
     return this.concludeNode(extDeclNode);
 }
 
+f<ASTImportDefNode*> Parser.parseImportDef() {
+    dyn importDefNode = this.createNode<ASTImportDefNode>();
+
+    this.lexer.expect(TokenType::IMPORT);
+    this.lexer.expect(TokenType::STRING_LIT);
+
+    if this.currentTokenIs(TokenType::AS) {
+        this.lexer.expect(TokenType::AS);
+        this.lexer.expect(TokenType::IDENTIFIER);
+    }
+    this.lexer.expect(TokenType::SEMICOLON);
+
+    return this.concludeNode(importDefNode);
+}
+
 f<ASTUnsafeBlockNode*> Parser.parseUnsafeBlock() {
     dyn unsafeBlockNode = this.createNode<ASTUnsafeBlockNode>();
 
@@ -858,21 +873,6 @@ f<ASTAttrNode*> Parser.parseAttr() {
     return this.concludeNode(attrNode);
 }
 
-f<ASTImportStmtNode*> Parser.parseImportStmt() {
-    dyn importStmtNode = this.createNode<ASTImportStmtNode>();
-
-    this.lexer.expect(TokenType::IMPORT);
-    this.lexer.expect(TokenType::STRING_LIT);
-
-    if this.currentTokenIs(TokenType::AS) {
-        this.lexer.expect(TokenType::AS);
-        this.lexer.expect(TokenType::IDENTIFIER);
-    }
-    this.lexer.expect(TokenType::SEMICOLON);
-
-    return this.concludeNode(importStmtNode);
-}
-
 f<ASTReturnStmtNode*> Parser.parseReturnStmt() {
     dyn returnStmtNode = this.createNode<ASTReturnStmtNode>();
 

src/Spice.g4

@@ -3,7 +3,7 @@
 grammar Spice;
 
 // Top level definitions and declarations
-entry: (mainFunctionDef | functionDef | procedureDef | structDef | interfaceDef | enumDef | genericTypeDef | aliasDef | globalVarDef | importStmt | extDecl | modAttr)*;
+entry: (mainFunctionDef | functionDef | procedureDef | structDef | interfaceDef | enumDef | genericTypeDef | aliasDef | globalVarDef | importDef | extDecl | modAttr)*;
 mainFunctionDef: topLevelDefAttr? F LESS TYPE_INT GREATER MAIN LPAREN paramLst? RPAREN stmtLst;
 functionDef: topLevelDefAttr? specifierLst? F LESS dataType GREATER fctName (LESS typeLst GREATER)? LPAREN paramLst? RPAREN stmtLst;
 procedureDef: topLevelDefAttr? specifierLst? P fctName (LESS typeLst GREATER)? LPAREN paramLst? RPAREN stmtLst;
@@ -15,6 +15,7 @@ genericTypeDef: TYPE TYPE_IDENTIFIER typeAltsLst SEMICOLON;
 aliasDef: specifierLst? TYPE TYPE_IDENTIFIER ALIAS dataType SEMICOLON;
 globalVarDef: dataType TYPE_IDENTIFIER (ASSIGN constant)? SEMICOLON;
 extDecl: topLevelDefAttr? EXT (F LESS dataType GREATER | P) (IDENTIFIER | TYPE_IDENTIFIER) LPAREN (typeLst ELLIPSIS?)? RPAREN SEMICOLON;
+importDef: IMPORT STRING_LIT (AS IDENTIFIER)? SEMICOLON;
 
 // Control structures
 unsafeBlock: UNSAFE stmtLst;
@@ -51,7 +52,6 @@ lambdaAttr: LBRACKET LBRACKET attrLst RBRACKET RBRACKET;
 attrLst: attr (COMMA attr)*;
 attr: IDENTIFIER (DOT IDENTIFIER)* (ASSIGN constant)?;
 constantLst: constant (COMMA constant)*;
-importStmt: IMPORT STRING_LIT (AS IDENTIFIER)? SEMICOLON;
 returnStmt: RETURN assignExpr?;
 breakStmt: BREAK INT_LIT?;
 continueStmt: CONTINUE INT_LIT?;

src/ast/ASTBuilder.cpp

@@ -234,6 +234,19 @@ std::any ASTBuilder::visitExtDecl(SpiceParser::ExtDeclContext *ctx) {
   return concludeNode(extDeclNode);
 }
 
+std::any ASTBuilder::visitImportDef(SpiceParser::ImportDefContext *ctx) {
+  auto importDefNode = createNode<ImportDefNode>(ctx);
+
+  // Extract path
+  const std::string pathStr = ctx->STRING_LIT()->getText();
+  importDefNode->importPath = pathStr.substr(1, pathStr.size() - 2);
+
+  // If no name is given, use the path as name
+  importDefNode->importName = ctx->AS() ? getIdentifier(ctx->IDENTIFIER()) : importDefNode->importPath;
+
+  return concludeNode(importDefNode);
+}
+
 std::any ASTBuilder::visitUnsafeBlock(SpiceParser::UnsafeBlockContext *ctx) {
   auto unsafeBlockDefNode = createNode<UnsafeBlockNode>(ctx);
 
@@ -614,19 +627,6 @@ std::any ASTBuilder::visitConstantLst(SpiceParser::ConstantLstContext *ctx) {
   return concludeNode(constantLstNode);
 }
 
-std::any ASTBuilder::visitImportStmt(SpiceParser::ImportStmtContext *ctx) {
-  auto importStmtNode = createNode<ImportStmtNode>(ctx);
-
-  // Extract path
-  const std::string pathStr = ctx->STRING_LIT()->getText();
-  importStmtNode->importPath = pathStr.substr(1, pathStr.size() - 2);
-
-  // If no name is given, use the path as name
-  importStmtNode->importName = ctx->AS() ? getIdentifier(ctx->IDENTIFIER()) : importStmtNode->importPath;
-
-  return concludeNode(importStmtNode);
-}
-
 std::any ASTBuilder::visitReturnStmt(SpiceParser::ReturnStmtContext *ctx) {
   auto returnStmtNode = createNode<ReturnStmtNode>(ctx);
 

src/ast/ASTBuilder.h

@@ -38,13 +38,14 @@ class ASTBuilder : private CompilerPass, public SpiceVisitor {
   std::any visitFunctionDef(SpiceParser::FunctionDefContext *ctx) override;
   std::any visitProcedureDef(SpiceParser::ProcedureDefContext *ctx) override;
   std::any visitFctName(SpiceParser::FctNameContext *ctx) override;
-  std::any visitExtDecl(SpiceParser::ExtDeclContext *ctx) override;
   std::any visitGenericTypeDef(SpiceParser::GenericTypeDefContext *ctx) override;
   std::any visitAliasDef(SpiceParser::AliasDefContext *ctx) override;
   std::any visitStructDef(SpiceParser::StructDefContext *ctx) override;
   std::any visitInterfaceDef(SpiceParser::InterfaceDefContext *ctx) override;
   std::any visitEnumDef(SpiceParser::EnumDefContext *ctx) override;
   std::any visitGlobalVarDef(SpiceParser::GlobalVarDefContext *ctx) override;
+  std::any visitExtDecl(SpiceParser::ExtDeclContext *ctx) override;
+  std::any visitImportDef(SpiceParser::ImportDefContext *ctx) override;
   std::any visitUnsafeBlock(SpiceParser::UnsafeBlockContext *ctx) override;
   std::any visitForLoop(SpiceParser::ForLoopContext *ctx) override;
   std::any visitForHead(SpiceParser::ForHeadContext *ctx) override;
@@ -77,7 +78,6 @@ class ASTBuilder : private CompilerPass, public SpiceVisitor {
   std::any visitAttrLst(SpiceParser::AttrLstContext *ctx) override;
   std::any visitAttr(SpiceParser::AttrContext *ctx) override;
   std::any visitConstantLst(SpiceParser::ConstantLstContext *ctx) override;
-  std::any visitImportStmt(SpiceParser::ImportStmtContext *ctx) override;
   std::any visitReturnStmt(SpiceParser::ReturnStmtContext *ctx) override;
   std::any visitBreakStmt(SpiceParser::BreakStmtContext *ctx) override;
   std::any visitContinueStmt(SpiceParser::ContinueStmtContext *ctx) override;

src/ast/ASTNodes.h

@@ -176,7 +176,7 @@ class EntryNode : public ASTNode {
 
   // Public get methods
   [[nodiscard]] std::vector<ModAttrNode *> modAttrs() const { return getChildren<ModAttrNode>(); }
-  [[nodiscard]] std::vector<ImportStmtNode *> importStmts() const { return getChildren<ImportStmtNode>(); }
+  [[nodiscard]] std::vector<ImportDefNode *> importDefs() const { return getChildren<ImportDefNode>(); }
 };
 
 // ======================================================== MainFctDefNode =======================================================
@@ -486,6 +486,23 @@ class ExtDeclNode : public ASTNode {
   bool hasReturnType = false;
 };
 
+// ======================================================== ImportDefNode ========================================================
+
+class ImportDefNode : public ASTNode {
+public:
+  // Constructors
+  using ASTNode::ASTNode;
+
+  // Visitor methods
+  std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitImportDef(this); }
+  std::any accept(ParallelizableASTVisitor *visitor) const override { return visitor->visitImportDef(this); }
+
+  // Public members
+  std::string importPath;
+  std::string importName;
+  SymbolTableEntry *entry = nullptr;
+};
+
 // ======================================================== UnsafeBlockNode ======================================================
 
 class UnsafeBlockNode : public ASTNode {
@@ -1130,23 +1147,6 @@ class ConstantLstNode : public ASTNode {
   [[nodiscard]] std::vector<ConstantNode *> constants() const { return getChildren<ConstantNode>(); }
 };
 
-// ======================================================== ImportStmtNode =======================================================
-
-class ImportStmtNode : public ASTNode {
-public:
-  // Constructors
-  using ASTNode::ASTNode;
-
-  // Visitor methods
-  std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitImportStmt(this); }
-  std::any accept(ParallelizableASTVisitor *visitor) const override { return visitor->visitImportStmt(this); }
-
-  // Public members
-  std::string importPath;
-  std::string importName;
-  SymbolTableEntry *entry = nullptr;
-};
-
 // ======================================================== ReturnStmtNode =======================================================
 
 class ReturnStmtNode : public ASTNode {

src/ast/ASTVisitor.cpp

@@ -32,6 +32,8 @@ std::any ASTVisitor::visitGlobalVarDef(GlobalVarDefNode *node) { return visitChi
 
 std::any ASTVisitor::visitExtDecl(ExtDeclNode *node) { return visitChildren(node); }
 
+std::any ASTVisitor::visitImportDef(ImportDefNode *node) { return visitChildren(node); }
+
 std::any ASTVisitor::visitUnsafeBlock(UnsafeBlockNode *node) { return visitChildren(node); }
 
 std::any ASTVisitor::visitForLoop(ForLoopNode *node) { return visitChildren(node); }
@@ -92,8 +94,6 @@ std::any ASTVisitor::visitAttr(AttrNode *node) { return visitChildren(node); }
 
 std::any ASTVisitor::visitConstantLst(ConstantLstNode *node) { return visitChildren(node); }
 
-std::any ASTVisitor::visitImportStmt(ImportStmtNode *node) { return visitChildren(node); }
-
 std::any ASTVisitor::visitReturnStmt(ReturnStmtNode *node) { return visitChildren(node); }
 
 std::any ASTVisitor::visitBreakStmt(BreakStmtNode *node) { return visitChildren(node); }

src/ast/ASTVisitor.h

@@ -21,6 +21,7 @@ class ASTVisitor : public AbstractASTVisitor {
   std::any visitAliasDef(AliasDefNode *node) override;
   std::any visitGlobalVarDef(GlobalVarDefNode *node) override;
   std::any visitExtDecl(ExtDeclNode *node) override;
+  std::any visitImportDef(ImportDefNode *node) override;
   std::any visitUnsafeBlock(UnsafeBlockNode *node) override;
   std::any visitForLoop(ForLoopNode *node) override;
   std::any visitForeachLoop(ForeachLoopNode *node) override;
@@ -51,7 +52,6 @@ class ASTVisitor : public AbstractASTVisitor {
   std::any visitAttrLst(AttrLstNode *node) override;
   std::any visitAttr(AttrNode *node) override;
   std::any visitConstantLst(ConstantLstNode *node) override;
-  std::any visitImportStmt(ImportStmtNode *node) override;
   std::any visitReturnStmt(ReturnStmtNode *node) override;
   std::any visitBreakStmt(BreakStmtNode *node) override;
   std::any visitContinueStmt(ContinueStmtNode *node) override;

src/ast/AbstractASTVisitor.h

@@ -20,6 +20,7 @@ class GenericTypeDefNode;
 class AliasDefNode;
 class GlobalVarDefNode;
 class ExtDeclNode;
+class ImportDefNode;
 class UnsafeBlockNode;
 class ForLoopNode;
 class ForeachLoopNode;
@@ -50,7 +51,6 @@ class LambdaAttrNode;
 class AttrLstNode;
 class AttrNode;
 class ConstantLstNode;
-class ImportStmtNode;
 class ReturnStmtNode;
 class BreakStmtNode;
 class ContinueStmtNode;
@@ -109,6 +109,7 @@ class AbstractASTVisitor {
   virtual std::any visitAliasDef(AliasDefNode *node) = 0;
   virtual std::any visitGlobalVarDef(GlobalVarDefNode *node) = 0;
   virtual std::any visitExtDecl(ExtDeclNode *node) = 0;
+  virtual std::any visitImportDef(ImportDefNode *node) = 0;
   virtual std::any visitUnsafeBlock(UnsafeBlockNode *node) = 0;
   virtual std::any visitForLoop(ForLoopNode *node) = 0;
   virtual std::any visitForeachLoop(ForeachLoopNode *node) = 0;
@@ -139,7 +140,6 @@ class AbstractASTVisitor {
   virtual std::any visitAttrLst(AttrLstNode *node) = 0;
   virtual std::any visitAttr(AttrNode *node) = 0;
   virtual std::any visitConstantLst(ConstantLstNode *node) = 0;
-  virtual std::any visitImportStmt(ImportStmtNode *node) = 0;
   virtual std::any visitReturnStmt(ReturnStmtNode *node) = 0;
   virtual std::any visitBreakStmt(BreakStmtNode *node) = 0;
   virtual std::any visitContinueStmt(ContinueStmtNode *node) = 0;

src/ast/ParallelizableASTVisitor.cpp

@@ -41,6 +41,8 @@ std::any ParallelizableASTVisitor::visitGlobalVarDef(const GlobalVarDefNode *nod
 
 std::any ParallelizableASTVisitor::visitExtDecl(const ExtDeclNode *node) { return visitChildren(node); }
 
+std::any ParallelizableASTVisitor::visitImportDef(const ImportDefNode *node) { return visitChildren(node); }
+
 std::any ParallelizableASTVisitor::visitUnsafeBlockDef(const UnsafeBlockNode *node) { return visitChildren(node); }
 
 std::any ParallelizableASTVisitor::visitForLoop(const ForLoopNode *node) { return visitChildren(node); }
@@ -103,8 +105,6 @@ std::any ParallelizableASTVisitor::visitAttr(const AttrNode *node) { return visi
 
 std::any ParallelizableASTVisitor::visitConstantLst(const ConstantLstNode *node) { return visitChildren(node); }
 
-std::any ParallelizableASTVisitor::visitImportStmt(const ImportStmtNode *node) { return visitChildren(node); }
-
 std::any ParallelizableASTVisitor::visitReturnStmt(const ReturnStmtNode *node) { return visitChildren(node); }
 
 std::any ParallelizableASTVisitor::visitBreakStmt(const BreakStmtNode *node) { return visitChildren(node); }

src/ast/ParallelizableASTVisitor.h

@@ -51,7 +51,7 @@ class LambdaAttrNode;
 class AttrLstNode;
 class AttrNode;
 class ConstantLstNode;
-class ImportStmtNode;
+class ImportDefNode;
 class ReturnStmtNode;
 class BreakStmtNode;
 class ContinueStmtNode;
@@ -109,6 +109,7 @@ class ParallelizableASTVisitor {
   virtual std::any visitAliasDef(const AliasDefNode *node);
   virtual std::any visitGlobalVarDef(const GlobalVarDefNode *node);
   virtual std::any visitExtDecl(const ExtDeclNode *node);
+  virtual std::any visitImportDef(const ImportDefNode *node);
   virtual std::any visitUnsafeBlockDef(const UnsafeBlockNode *node);
   virtual std::any visitForLoop(const ForLoopNode *node);
   virtual std::any visitForeachLoop(const ForeachLoopNode *node);
@@ -139,7 +140,6 @@ class ParallelizableASTVisitor {
   virtual std::any visitAttrLst(const AttrLstNode *node);
   virtual std::any visitAttr(const AttrNode *node);
   virtual std::any visitConstantLst(const ConstantLstNode *node);
-  virtual std::any visitImportStmt(const ImportStmtNode *node);
   virtual std::any visitReturnStmt(const ReturnStmtNode *node);
   virtual std::any visitBreakStmt(const BreakStmtNode *node);
   virtual std::any visitContinueStmt(const ContinueStmtNode *node);

src/importcollector/ImportCollector.cpp

@@ -16,14 +16,14 @@ std::any ImportCollector::visitEntry(EntryNode *node) {
   for (ModAttrNode *attr : node->modAttrs())
     visit(attr);
 
-  // Visit all import statements
-  for (ImportStmtNode *importStmt : node->importStmts())
-    visit(importStmt);
+  // Visit all import defs
+  for (ImportDefNode *importDef : node->importDefs())
+    visit(importDef);
 
   return nullptr;
 }
 
-std::any ImportCollector::visitImportStmt(ImportStmtNode *node) {
+std::any ImportCollector::visitImportDef(ImportDefNode *node) {
   const bool isStd = node->importPath.starts_with("std/");
 
   std::filesystem::path basePath;

src/importcollector/ImportCollector.h

@@ -19,7 +19,7 @@ class ImportCollector : private CompilerPass, public ASTVisitor {
 
   // Public methods
   std::any visitEntry(EntryNode *node) override;
-  std::any visitImportStmt(ImportStmtNode *node) override;
+  std::any visitImportDef(ImportDefNode *node) override;
   std::any visitModAttr(ModAttrNode *node) override;
 };
 

src/typechecker/TypeChecker.cpp

@@ -106,6 +106,12 @@ std::any TypeChecker::visitExtDecl(ExtDeclNode *node) {
   return nullptr;
 }
 
+std::any TypeChecker::visitImportDef(ImportDefNode *node) {
+  if (typeCheckerMode == TC_MODE_PRE)
+    return visitImportDefPrepare(node);
+  return nullptr;
+}
+
 std::any TypeChecker::visitUnsafeBlock(UnsafeBlockNode *node) {
   // Change to unsafe block body scope
   ScopeHandle scopeHandle(this, node->getScopeId(), ScopeType::UNSAFE_BODY);
@@ -594,12 +600,6 @@ std::any TypeChecker::visitDeclStmt(DeclStmtNode *node) {
   return node->setEvaluatedSymbolType(localVarType, manIdx);
 }
 
-std::any TypeChecker::visitImportStmt(ImportStmtNode *node) {
-  if (typeCheckerMode == TC_MODE_PRE)
-    return visitImportStmtPrepare(node);
-  return nullptr;
-}
-
 std::any TypeChecker::visitReturnStmt(ReturnStmtNode *node) {
   // Retrieve return variable entry
   SymbolTableEntry *returnVar = currentScope->lookup(RETURN_VARIABLE_NAME);

src/typechecker/TypeChecker.h

@@ -61,6 +61,8 @@ class TypeChecker : private CompilerPass, public ASTVisitor {
   std::any visitGlobalVarDefPrepare(GlobalVarDefNode *node);
   std::any visitExtDecl(ExtDeclNode *node) override;
   std::any visitExtDeclPrepare(ExtDeclNode *node);
+  std::any visitImportDef(ImportDefNode *node) override;
+  std::any visitImportDefPrepare(ImportDefNode *node);
   std::any visitUnsafeBlock(UnsafeBlockNode *node) override;
   std::any visitForLoop(ForLoopNode *node) override;
   std::any visitForeachLoop(ForeachLoopNode *node) override;
@@ -77,8 +79,6 @@ class TypeChecker : private CompilerPass, public ASTVisitor {
   std::any visitField(FieldNode *node) override;
   std::any visitSignature(SignatureNode *node) override;
   std::any visitDeclStmt(DeclStmtNode *node) override;
-  std::any visitImportStmt(ImportStmtNode *node) override;
-  std::any visitImportStmtPrepare(ImportStmtNode *node);
   std::any visitReturnStmt(ReturnStmtNode *node) override;
   std::any visitBreakStmt(BreakStmtNode *node) override;
   std::any visitContinueStmt(ContinueStmtNode *node) override;