Make it possible to debug SCL compiler in production builds

[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 a5b9a65417e79e095acc83149f49d40ffa47690d..f14a3be967438af2e93d134e9e1024513e5eb193 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
@@ -42,12 +42,12 @@ 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;
 import org.simantics.scl.compiler.internal.parsing.parser.SCLParserImpl;
 import org.simantics.scl.compiler.internal.parsing.parser.SCLParserOptions;
+import org.simantics.scl.compiler.internal.parsing.utils.LineLocators;
 import org.simantics.scl.compiler.runtime.MutableClassLoader;
 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
 import org.simantics.scl.compiler.types.TVar;
@@ -58,11 +58,15 @@ import org.simantics.scl.compiler.types.util.Polarity;
 import org.simantics.scl.compiler.types.util.ProcedureType;
 import org.simantics.scl.runtime.function.FunctionImpl1;
 import org.simantics.scl.runtime.tuple.Tuple0;
+import org.slf4j.LoggerFactory;
+import org.slf4j.Logger;
 
 import gnu.trove.set.hash.THashSet;
 
 public class ExpressionEvaluator {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(ExpressionEvaluator.class);
+
     public static final boolean TRACE_INTERPRETATION_VS_COMPILATION = false;
     private static final String COMPUTATION_METHOD_NAME = "main";
     
@@ -203,6 +207,7 @@ public class ExpressionEvaluator {
         
         // Parse expression
         if(expressionText != null) {
+            compilationContext.lineLocator = LineLocators.createLineLocator(expressionText);
             try {
                 switch(parseMode) {
                 case BLOCK: {
@@ -224,13 +229,15 @@ public class ExpressionEvaluator {
                 }
             } catch(SCLSyntaxErrorException e) {
                 errorLog.log(e.location, e.getMessage());
-                //System.out.println(errorLog.getErrorsAsString());
+                //LOGGER.info(errorLog.getErrorsAsString());
                 throw new SCLExpressionCompilationException(errorLog.getErrors());
             } catch(Exception e) {
                 errorLog.log(e);
                 throw new SCLExpressionCompilationException(errorLog.getErrors());
             }
         }
+        else
+            compilationContext.lineLocator = LineLocators.DUMMY_LOCATOR;
         
         // Store local variables
         ArrayList<Type> lvTypes = new ArrayList<Type>(); 
@@ -270,7 +277,7 @@ public class ExpressionEvaluator {
         
         // Elaboration
         {
-            TranslationContext context = new TranslationContext(compilationContext, localEnvironment);
+            TranslationContext context = new TranslationContext(compilationContext, localEnvironment, "expression");
             expression = expression.resolve(context);
             if(!errorLog.hasNoErrors())
                 throw new SCLExpressionCompilationException(errorLog.getErrors());
@@ -300,9 +307,9 @@ public class ExpressionEvaluator {
             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();
@@ -345,7 +352,7 @@ public class ExpressionEvaluator {
             throw new SCLExpressionCompilationException(errorLog.getErrors());
         
         if(SCLCompilerConfiguration.SHOW_EXPRESSION_BEFORE_EVALUATION)
-            System.out.println(expression);
+            LOGGER.info("{}", expression);
         
         if(interpretIfPossible) {
         // Try to interpret
@@ -355,9 +362,9 @@ public class ExpressionEvaluator {
                             new TransientClassBuilder(classLoader, javaTypeTranslator));
             IExpression iexp = expression.toIExpression(expressionInterpretationContext);
                 if(TRACE_INTERPRETATION_VS_COMPILATION)
-                System.out.println("INTERPRETED " + expressionText);
+                LOGGER.info("INTERPRETED " + expressionText);
                 if(SCLCompilerConfiguration.SHOW_INTERPRETED_EXPRESSION)
-                    System.out.println("INTERPRETED AS: " + iexp);
+                    LOGGER.info("INTERPRETED AS: " + iexp);
             return iexp.execute(new Object[expressionInterpretationContext.getMaxVariableId()]);
         } catch(UnsupportedOperationException e) {
             // This is normal when expression cannot be interpreted. We compile it instead.
@@ -365,9 +372,9 @@ public class ExpressionEvaluator {
         }
         
         // Convert to SSA
-        ModuleWriter mw = new ModuleWriter(namingPolicy.getModuleClassName());
+        ModuleWriter mw = new ModuleWriter(namingPolicy.getModuleClassName(), compilationContext.lineLocator);
         DecomposedExpression decomposed = 
-                DecomposedExpression.decompose(expression);
+                DecomposedExpression.decompose(errorLog, expression);
 
         SCLConstant constant = new SCLConstant(
                 Name.create(moduleName, COMPUTATION_METHOD_NAME),
@@ -388,16 +395,17 @@ 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.location, decomposed.body.toVal(compilationContext, w));
         } catch(RuntimeException e) {
             errorLog.setExceptionPosition(expression.location);
+            errorLog.log(e);
             throw new SCLExpressionCompilationException(errorLog.getErrors());
         }
 
         SSAModule ssaModule = mw.getModule();
         if(SCLCompilerConfiguration.SHOW_SSA_BEFORE_OPTIMIZATION) {
-            System.out.println("=== SSA before optimization ==================================");
-            System.out.println(ssaModule);            
+            LOGGER.info("=== SSA before optimization ==================================");
+            LOGGER.info("{}", ssaModule);
         }
         if(SCLCompilerConfiguration.DEBUG)
             ssaModule.validate();
@@ -408,12 +416,12 @@ public class ExpressionEvaluator {
         for(int phase=0;phase<CodeGeneration.OPTIMIZATION_PHASES;++phase) {
             int optCount = 0;
             while(optCount++ < 4 && ssaModule.simplify(environment, phase)) {
-                //System.out.println("simplify " + optCount);
+                //LOGGER.info("simplify " + optCount);
             }
         }
         if(SCLCompilerConfiguration.SHOW_SSA_BEFORE_LAMBDA_LIFTING) {
-            System.out.println("=== SSA before lambda lifting ==================================");
-            System.out.println(ssaModule);            
+            LOGGER.info("=== SSA before lambda lifting ==================================");
+            LOGGER.info("{}", ssaModule);
         }
         //ssaModule.saveInlinableDefinitions();
         ssaModule.lambdaLift(errorLog);
@@ -422,7 +430,7 @@ public class ExpressionEvaluator {
         
         // Generate code
         if(SCLCompilerConfiguration.SHOW_FINAL_SSA)
-            System.out.println(ssaModule);
+            LOGGER.info("{}", ssaModule);
         try {
             ssaModule.generateCode(moduleBuilder);
         } catch (CodeBuildingException e) {
@@ -430,6 +438,7 @@ public class ExpressionEvaluator {
             throw new SCLExpressionCompilationException(errorLog.getErrors());
         }
         Map<String, byte[]> classes = moduleBuilder.getClasses();
+        ssaModule.cleanup();
         
         // Load generated code and execute
         try {