Collect reference hierarchy for SCL values

[simantics/platform.git] / bundles / org.simantics.scl.compiler / src / org / simantics / scl / compiler / compilation / SCLCompiler.java

diff --git a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/compilation/SCLCompiler.java b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/compilation/SCLCompiler.java
index b5bd4ef312c997038e5856164d2ef34dfbe69cb7..0da48676ad0088cda95db8c4a5a53ae5942be191 100644 (file)
--- a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/compilation/SCLCompiler.java
+++ b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/compilation/SCLCompiler.java
@@ -7,10 +7,12 @@ import java.util.Map;
 
 import org.simantics.scl.compiler.environment.EnvironmentFactory;
 import org.simantics.scl.compiler.errors.ErrorLog;
-import org.simantics.scl.compiler.internal.codegen.types.JavaReferenceValidator;
+import org.simantics.scl.compiler.internal.codegen.types.JavaReferenceValidatorFactory;
+import org.simantics.scl.compiler.internal.header.ModuleHeader;
 import org.simantics.scl.compiler.internal.parsing.declarations.DeclarationAst;
 import org.simantics.scl.compiler.internal.parsing.exceptions.SCLSyntaxErrorException;
 import org.simantics.scl.compiler.internal.parsing.parser.SCLParserImpl;
+import org.simantics.scl.compiler.internal.parsing.parser.SCLParserOptions;
 import org.simantics.scl.compiler.module.ConcreteModule;
 import org.simantics.scl.compiler.module.options.ModuleCompilationOptions;
 import org.simantics.scl.compiler.top.ModuleInitializer;
@@ -18,8 +20,8 @@ import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
 import org.simantics.scl.compiler.top.StandardModuleInitializer;
 
 public class SCLCompiler {
-    ErrorLog errorLog = new ErrorLog();
-    DeclarationClassification declarations = new DeclarationClassification(errorLog);
+    CompilationContext compilationContext = new CompilationContext();
+    DeclarationClassification declarations = new DeclarationClassification(compilationContext);
     
     // publishable results
     Map<String, byte[]> classes;
@@ -29,8 +31,11 @@ public class SCLCompiler {
     private CompilationTimer timer;
     private ModuleCompilationOptions options;
     
-    public SCLCompiler(ModuleCompilationOptions options) {
+    JavaReferenceValidatorFactory jrvFactory;
+    
+    public SCLCompiler(ModuleCompilationOptions options, JavaReferenceValidatorFactory jrvFactory) {
         this.options = options == null ? ModuleCompilationOptions.STANDARD_OPTIONS : options;
+        this.jrvFactory = jrvFactory;
     }
 
     @SuppressWarnings("unchecked")
@@ -38,13 +43,15 @@ public class SCLCompiler {
         if(SCLCompilerConfiguration.ENABLE_TIMING) initializeTiming();
         try {
             SCLParserImpl parser = new SCLParserImpl(sourceReader);
+            parser.setParserOptions(SCLParserOptions.MODULE_DEFAULT);
+            parser.setCompilationContext(compilationContext);
             if(!parser.isEmpty())
             for(DeclarationAst declaration : (ArrayList<DeclarationAst>)parser.parseModule())
                 declarations.handle(declaration);
         } catch(SCLSyntaxErrorException e) {
-            errorLog.log(e.location, e.getMessage());
+            compilationContext.errorLog.log(e.location, e.getMessage());
         } catch(Exception e) {
-            errorLog.log(e);
+            compilationContext.errorLog.log(e);
         } finally {
             try {
                 sourceReader.close();
@@ -55,41 +62,50 @@ public class SCLCompiler {
         if(SCLCompilerConfiguration.ENABLE_TIMING) phaseFinished("Parsing");
     }
     
+    private boolean hasErrors() {
+        return !compilationContext.errorLog.hasNoErrors();
+    }
+    
     public void compile(
             EnvironmentFactory localEnvironmentFactory,
-            String moduleName,
-            JavaReferenceValidator<?, ?, ?, ?> javaReferenceValidator) {
+            String moduleName) {
         try {
-            if(!errorLog.isEmpty()) return;
-            Elaboration elaboration = new Elaboration(errorLog,
+            if(hasErrors()) return;
+            Elaboration elaboration = new Elaboration(compilationContext,
                     timer,
                     localEnvironmentFactory,
                     moduleName,
+                    compilationContext.header,
                     declarations.importsAst,
-                    javaReferenceValidator,
+                    jrvFactory,
                     declarations.valueDefinitionsAst,
                     declarations.relationDefinitionsAst);
             if(options.computeCoverage)
                 elaboration.addCoverageBranchPoints();
+            if(options.collectDebugInfo)
+                elaboration.collectDebugInfo();
             // Elaboration
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             elaboration.addTypesToEnvironment(
                     declarations.dataTypesAst,
                     declarations.typeAliasesAst,
-                    declarations.effectsAst);
-            if(!errorLog.isEmpty()) return;
+                    declarations.effectsAst,
+                    declarations.rulesetsAst);
+            if(hasErrors()) return;
             elaboration.processTypeAliases(declarations.typeAliasesAst);
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             elaboration.processDataTypes(declarations.dataTypesAst);
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             elaboration.processTypeClasses(declarations.typeClassesAst);
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             elaboration.processDerivingInstances(declarations.derivingInstancesAst, declarations.instancesAst);
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             elaboration.processInstances(declarations.instancesAst);
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             elaboration.processJavaMethods(declarations.javaMethodDeclarations);
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
+            elaboration.processRulesets(declarations.rulesetsAst);
+            if(hasErrors()) return;
             elaboration.addDataTypesToEnvironment();
             elaboration.addTypeClassesToEnvironment();
             elaboration.preprocessValueDefinitions(declarations.typeAnnotationsAst);
@@ -101,9 +117,9 @@ public class SCLCompiler {
             if(SCLCompilerConfiguration.ENABLE_TIMING) phaseFinished("Elaboration");
             
             // Type checking
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             //new TypeChecking(errorLog, elaboration.environment, elaboration.module).typeCheck();
-            new TypeChecking(errorLog, elaboration.environment, elaboration.module).typeCheck();
+            new TypeChecking(compilationContext, elaboration.module).typeCheck();
             
             if(SCLCompilerConfiguration.ENABLE_TIMING) phaseFinished("Type checking");
             
@@ -125,53 +141,53 @@ public class SCLCompiler {
             this.declarations = null;
             
             // Code generation
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             CodeGeneration codeGeneration = new CodeGeneration(
-                    errorLog,
-                    elaboration.environment,
-                    elaboration.namingPolicy,
-                    elaboration.javaTypeTranslator,
+                    compilationContext,
                     elaboration.javaReferenceValidator,
                     elaboration.module);
             codeGeneration.simplifyValues();
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             codeGeneration.convertToSSA();
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             codeGeneration.optimizeSSA();
             
             if(SCLCompilerConfiguration.ENABLE_TIMING) phaseFinished("SSA conversion and optimization");
             
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             codeGeneration.generateCode();
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             codeGeneration.generateDataTypes(elaboration.dataTypes);
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             codeGeneration.generateTypeClasses();
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
             codeGeneration.generateTypeClassInstances();
-            if(!errorLog.isEmpty()) return;
+            if(hasErrors()) return;
 
             classes = codeGeneration.classes;
             module =  codeGeneration.module;
             moduleInitializer = StandardModuleInitializer.create(
-                    codeGeneration.namingPolicy.getModuleClassName(),
+                    compilationContext.namingPolicy.getModuleClassName(),
                     codeGeneration.externalConstants);
             
             module.setClasses(classes);
+            module.setParentClassLoader(elaboration.javaReferenceValidator.getClassLoader());
             module.setModuleInitializer(moduleInitializer);
             module.setBranchPoints(elaboration.branchPoints);
+            if(compilationContext.errorLog.hasErrorsOrWarnings())
+                module.setWarnings(compilationContext.errorLog.getErrors());
             
             if(SCLCompilerConfiguration.ENABLE_TIMING) {
                 phaseFinished("Code generation");
                 reportTiming(moduleName);
             }
         } catch(Exception e) {
-            errorLog.log(e);
+            compilationContext.errorLog.log(e);
         }
     }
 
     public ErrorLog getErrorLog() {
-        return errorLog;
+        return compilationContext.errorLog;
     }
     
     public Map<String, byte[]> getClasses() {