Only adding modules that are really in use

examples/sampleProject/BoProject.json

@@ -1,7 +1,7 @@
 {
   "name": "Sample Project",
   "description": "A description you can choose",
-  "main": "Mainaa.bo",
+  "main": "Main.bo",
   "modules": {
     "module1": "Module1.bo",
     "module2": "Module2.bo",

examples/sampleProject/Main.bo

@@ -1,5 +1,6 @@
 import module1;
 import module2;
+import module3;
 
 import trainprinter;
 

examples/sampleProject/Module3.bo

@@ -0,0 +1,7 @@
+module module3;
+
+// empty module never used!
+
+function shouldNotExist() {
+    return 1;
+}

src/main/java/com/diegokrupitza/bolang/syntaxtree/BuildAstVisitor.java

@@ -14,7 +14,9 @@
 import org.apache.commons.lang3.StringUtils;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import static java.util.function.Predicate.not;
@@ -26,6 +28,7 @@
  */
 public class BuildAstVisitor extends BoBaseVisitor<ExpressionNode> {
 
+    private final Set<String> usedModules = new HashSet<>();
     private BoSymbolTable symbolTable = null;
     private List<String> importedModules = new ArrayList<>();
     private String currentModuleName = "this";
@@ -40,7 +43,7 @@ public ExpressionNode visitNormalCode(BoParser.NormalCodeContext ctx) {
                 .map(this::visit)
                 .collect(Collectors.toList());
 
-        return new BoNode(processesStats);
+        return new BoNode(processesStats, usedModules);
     }
 
     @Override
@@ -67,7 +70,7 @@ public ExpressionNode visitModuleDef(BoParser.ModuleDefContext ctx) {
 
         ModuleNode moduleNode = new ModuleNode(moduleName, importsInModule, functions);
 
-        return new BoNode(List.of(moduleNode));
+        return new BoNode(List.of(moduleNode), usedModules);
     }
 
     @Override
@@ -150,6 +153,10 @@ public ExpressionNode visitFuncVal(BoParser.FuncValContext ctx) {
                     .collect(Collectors.toList());
         }
 
+        if (!FunctionFactory.getAllPredefinedModules().contains(moduleName)) {
+            usedModules.add(moduleName);
+        }
+
         return new CallFunctionNode(funcName, moduleName, params);
     }
 

src/main/java/com/diegokrupitza/bolang/syntaxtree/nodes/BoNode.java

@@ -1,21 +1,30 @@
 package com.diegokrupitza.bolang.syntaxtree.nodes;
 
-import lombok.AllArgsConstructor;
 import lombok.Data;
-import lombok.NoArgsConstructor;
 
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author Diego Krupitza
  * @version 1.0
  * @date 08.07.21
  */
 @Data
-@AllArgsConstructor
-@NoArgsConstructor
 public class BoNode extends ExpressionNode {
 
     private List<ExpressionNode> stats;
+    private Set<String> usedModules;
 
+    public BoNode() {
+    }
+
+    public BoNode(List<ExpressionNode> stats) {
+        this.stats = stats;
+    }
+
+    public BoNode(List<ExpressionNode> stats, Set<String> usedModules) {
+        this.stats = stats;
+        this.usedModules = usedModules;
+    }
 }

src/main/java/com/diegokrupitza/bolang/vm/ModulesImporter.java

@@ -59,15 +59,11 @@ public static HashMap<String, List<FunctionNode>> importModules(BoProject boProj
             }
 
             // getting the names of the modules we want to import
-            Set<String> namesOfModuleToImport = importModules.stream()
-                    .map(ImportNode::getModuleName)
-                    .collect(Collectors.toUnmodifiableSet());
+            Set<String> namesOfModuleToImport = head.getUsedModules();
 
             // populating the map with the list of all implemented functions in a module
             for (String nameOfModule : namesOfModuleToImport) {
-
                 moduleFunctionMap = performImportForModule(boProject, moduleFunctionMap, nameOfModule);
-
             }
 
         } catch (FileNotFoundException e) {
@@ -104,22 +100,20 @@ private static HashMap<String, List<FunctionNode>> performImportForModule(BoProj
         // adding the current imported module to the map
         moduleFunctionMap.put(nameOfModule, functionsOfModule);
 
-        // import module that the module imported
-        List<ImportNode> importsOfModule = moduleHead.getImports();
+        // getting the names of the modules we want to import
+        Set<String> namesOfModuleToImport = moduleBoNode.getUsedModules();
 
-        if (boProject.isExternalModule(nameOfModule)) {
-            if (CollectionUtils.isNotEmpty(importsOfModule)) {
-                throw new BoProjectException("External dependencies are not allowed to have imports! Please properly export the module you want to use!");
-            }
+        if (boProject.isExternalModule(nameOfModule) && CollectionUtils.isNotEmpty(namesOfModuleToImport)) {
+            throw new BoProjectException("External dependencies are not allowed to have imports! Please properly export the module you want to use!");
         }
 
-        if (CollectionUtils.isNotEmpty(importsOfModule)) {
+        if (CollectionUtils.isNotEmpty(namesOfModuleToImport)) {
             // we have imports to do!
             // circular dependencies are not a problem since as soon as its once seen its get added before
             // see few lines above
 
-            for (ImportNode importNodeOfModule : importsOfModule) {
-                moduleFunctionMap = performImportForModule(boProject, moduleFunctionMap, importNodeOfModule.getModuleName());
+            for (String nameOfModuleIteration : namesOfModuleToImport) {
+                moduleFunctionMap = performImportForModule(boProject, moduleFunctionMap, nameOfModuleIteration);
             }
         }