Collect reference hierarchy for SCL values

[simantics/platform.git] / bundles / org.simantics.scl.compiler / src / org / simantics / scl / compiler / top / ExpressionEvaluator.java

diff --git a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/top/ExpressionEvaluator.java b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/top/ExpressionEvaluator.java
index 5c8f59bb2dcee005fc5c006f72c4f453fa987990..36994d136533435522642855fdf5a8817203fd57 100644 (file)
--- a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/top/ExpressionEvaluator.java
+++ b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/top/ExpressionEvaluator.java
@@ -8,6 +8,7 @@ import java.util.Map;
 
 import org.simantics.scl.compiler.common.names.Name;
 import org.simantics.scl.compiler.compilation.CodeGeneration;
+import org.simantics.scl.compiler.compilation.CompilationContext;
 import org.simantics.scl.compiler.constants.JavaStaticMethod;
 import org.simantics.scl.compiler.constants.SCLConstant;
 import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
@@ -26,6 +27,7 @@ import org.simantics.scl.compiler.elaboration.expressions.block.Statement;
 import org.simantics.scl.compiler.elaboration.java.Builtins;
 import org.simantics.scl.compiler.environment.Environment;
 import org.simantics.scl.compiler.environment.LocalEnvironment;
+import org.simantics.scl.compiler.errors.CompilationError;
 import org.simantics.scl.compiler.errors.ErrorLog;
 import org.simantics.scl.compiler.internal.codegen.references.IVal;
 import org.simantics.scl.compiler.internal.codegen.ssa.SSAModule;
@@ -40,7 +42,6 @@ import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;
 import org.simantics.scl.compiler.internal.codegen.writer.ExternalConstant;
 import org.simantics.scl.compiler.internal.codegen.writer.ModuleWriter;
 import org.simantics.scl.compiler.internal.elaboration.decomposed.DecomposedExpression;
-import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;
 import org.simantics.scl.compiler.internal.interpreted.IExpression;
 import org.simantics.scl.compiler.internal.parsing.exceptions.SCLSyntaxErrorException;
 import org.simantics.scl.compiler.internal.parsing.parser.SCLBlockParser;
@@ -76,6 +77,7 @@ public class ExpressionEvaluator {
     private LocalStorage localStorage;
     private boolean interpretIfPossible = true;
     private ExpressionParseMode parseMode = ExpressionParseMode.EXPRESSION;
+    private boolean validateOnly;
     
     public ExpressionEvaluator(RuntimeEnvironment runtimeEnvironment,
             String expressionText) {
@@ -114,6 +116,11 @@ public class ExpressionEvaluator {
         return this;
     }
     
+    public ExpressionEvaluator validateOnly(boolean validateOnly) {
+        this.validateOnly = validateOnly;
+        return this;
+    }
+    
     /**
      * Sets a local environment that can arbitrarily modify the resolving of the expression.
      */
@@ -174,12 +181,24 @@ public class ExpressionEvaluator {
             return "store_" + name;
         }
     }
+    
+    public CompilationError[] validate() {
+        try {
+            validateOnly = true;
+            eval();
+            return CompilationError.EMPTY_ARRAY;
+        } catch(SCLExpressionCompilationException e) {
+            return e.getErrors();
+        }
+    }
 
     public Object eval() throws SCLExpressionCompilationException {
         fillDefaults();
         
-        final ErrorLog errorLog = new ErrorLog();
+        final CompilationContext compilationContext = new CompilationContext();
+        final ErrorLog errorLog = compilationContext.errorLog;
         final Environment environment = runtimeEnvironment.getEnvironment();
+        compilationContext.environment = environment;
         
         // Parse expression
         if(expressionText != null) {
@@ -216,7 +235,7 @@ public class ExpressionEvaluator {
         ArrayList<Type> lvTypes = new ArrayList<Type>(); 
         if(expression instanceof EBlock) {
             EBlock block = (EBlock)expression;
-            if(localStorage != null && !(block.getStatements().getLast() instanceof GuardStatement)) {
+            if(localStorage != null && !(block.getLast() instanceof GuardStatement)) {
                 THashSet<String> localVariables = new THashSet<String>();
                 ListIterator<Statement> it = block.getStatements().listIterator();
                 while(it.hasNext()) {
@@ -240,18 +259,19 @@ public class ExpressionEvaluator {
                                     Types.functionE(type, Types.PROC, Types.UNIT)),
                                     new EVar(variableName)
                             )));
+                    if(validateOnly)
+                        localStorage.store(variableName, null, type);
                 }
             }
-            if(!(block.getStatements().getLast() instanceof GuardStatement))
+            if(!(block.getLast() instanceof GuardStatement))
                 block.addStatement(new GuardStatement(new EConstant(Builtins.TUPLE_CONSTRUCTORS[0])));
         }
         
         // Elaboration
         {
-            TranslationContext context = new TranslationContext(errorLog,
-                    environment, localEnvironment);
+            TranslationContext context = new TranslationContext(compilationContext, localEnvironment, "expression");
             expression = expression.resolve(context);
-            if(!errorLog.isEmpty())
+            if(!errorLog.hasNoErrors())
                 throw new SCLExpressionCompilationException(errorLog.getErrors());
         }
         
@@ -265,7 +285,7 @@ public class ExpressionEvaluator {
         
         // Type checking
         {
-            TypingContext context = new TypingContext(errorLog, environment);
+            TypingContext context = new TypingContext(compilationContext);
 
             context.pushEffectUpperBound(expression.location, expectedEffect);
             expression = expression.checkType(context, expectedType);
@@ -276,21 +296,24 @@ public class ExpressionEvaluator {
             
             expectedType.addPolarity(Polarity.POSITIVE);
             context.solveSubsumptions(expression.location);
-            if(!errorLog.isEmpty())
+            if(!errorLog.hasNoErrors())
                 throw new SCLExpressionCompilationException(errorLog.getErrors());
             if(decorateExpression && Types.canonical(expectedEffect) != Types.NO_EFFECTS) {
-                ExpressionDecorator decorator =
+                ToplevelEffectDecorator decorator =
                         new ToplevelEffectDecorator(errorLog, environment);
-                expression = expression.decorate(decorator);
+                expression = expression.accept(decorator);
             }
             expression = context.solveConstraints(environment, expression);
             expressionType = expression.getType();
             
-            if(!errorLog.isEmpty())
+            if(!errorLog.hasNoErrors())
                 throw new SCLExpressionCompilationException(errorLog.getErrors());
 
             if(localEnvironment != null)
                 expression = localEnvironment.postDecorateExpression(expression);
+            
+            if(validateOnly)
+                return null;
 
             Type type = expression.getType();
             type = type.convertMetaVarsToVars();
@@ -306,17 +329,18 @@ public class ExpressionEvaluator {
         MutableClassLoader classLoader = runtimeEnvironment.getMutableClassLoader();
         String moduleName = classLoader.getFreshPackageName();
         JavaTypeTranslator javaTypeTranslator = new JavaTypeTranslator(environment);
+        compilationContext.javaTypeTranslator = javaTypeTranslator;
         JavaNamingPolicy namingPolicy = new JavaNamingPolicy(moduleName);
+        compilationContext.namingPolicy = namingPolicy;
 
         ModuleBuilder moduleBuilder = new ModuleBuilder(namingPolicy, javaTypeTranslator);
         
         // Simplify
         SimplificationContext context = 
-                new SimplificationContext(environment, errorLog, 
-                        javaTypeTranslator, DummyJavaReferenceValidator.INSTANCE);
+                new SimplificationContext(compilationContext, DummyJavaReferenceValidator.INSTANCE);
         expression = expression.simplify(context);
         
-        if(!errorLog.isEmpty())
+        if(!errorLog.hasNoErrors())
             throw new SCLExpressionCompilationException(errorLog.getErrors());
         
         if(SCLCompilerConfiguration.SHOW_EXPRESSION_BEFORE_EVALUATION)
@@ -342,7 +366,7 @@ public class ExpressionEvaluator {
         // Convert to SSA
         ModuleWriter mw = new ModuleWriter(namingPolicy.getModuleClassName());
         DecomposedExpression decomposed = 
-                DecomposedExpression.decompose(expression);
+                DecomposedExpression.decompose(errorLog, expression);
 
         SCLConstant constant = new SCLConstant(
                 Name.create(moduleName, COMPUTATION_METHOD_NAME),
@@ -363,7 +387,7 @@ public class ExpressionEvaluator {
             IVal[] parameterVals = w.getParameters();
             for(int i=0;i<decomposed.parameters.length;++i)
                 decomposed.parameters[i].setVal(parameterVals[i]);
-            w.return_(decomposed.body.toVal(environment, w));
+            w.return_(decomposed.body.toVal(compilationContext, w));
         } catch(RuntimeException e) {
             errorLog.setExceptionPosition(expression.location);
             throw new SCLExpressionCompilationException(errorLog.getErrors());
@@ -405,6 +429,7 @@ public class ExpressionEvaluator {
             throw new SCLExpressionCompilationException(errorLog.getErrors());
         }
         Map<String, byte[]> classes = moduleBuilder.getClasses();
+        ssaModule.cleanup();
         
         // Load generated code and execute
         try {