[RDY] Evaluation in context with dynsem generated interpreter

org.metaborg.spoofax.shell.core/pom.xml

@@ -19,6 +19,16 @@
          order to build our code standalone (which is not only easier for testing locally, but
          required on TravisCI). -->
     <repositories>
+        <repository>
+            <id>custom-snapshot-repo</id>
+            <url>http://fokkema-ict.nl/maven2</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+            <snapshots>
+                <enabled>true</enabled>
+            </snapshots>
+        </repository>
         <repository>
             <id>metaborg-snapshot-repo</id>
             <url>http://artifacts.metaborg.org/content/repositories/snapshots/</url>
@@ -57,6 +67,22 @@
             <artifactId>org.strategoxt.strj</artifactId>
             <version>${metaborg-version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.metaborg</groupId>
+            <artifactId>org.metaborg.meta.interpreter.framework</artifactId>
+            <version>${metaborg-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.metaborg</groupId>
+            <artifactId>org.metaborg.meta.lang.dynsem.interpreter</artifactId>
+            <version>${metaborg-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.oracle.truffle</groupId>
+            <artifactId>truffle-api</artifactId>
+            <version>0.11</version>
+            <type>jar</type>
+        </dependency>
 
         <!-- From here on, all dependencies are inherited. -->
         <dependency>
@@ -89,7 +115,7 @@
             <version>1.10.19</version>
             <scope>test</scope>
         </dependency>
-        
+
         <!-- From here on, all test dependencies are inherited. -->
         <dependency>
             <groupId>junit</groupId>
@@ -132,13 +158,38 @@
             </plugins>
         </pluginManagement>
         <plugins>
+            <!-- Generate sources from annotations. -->
+            <plugin>
+                <groupId>org.bsc.maven</groupId>
+                <artifactId>maven-processor-plugin</artifactId>
+                <version>3.1.0</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>process-test</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>target/generated-sources/annotations</outputDirectory>
+                            <!--processor>com.oracle.truffle.dsl.processor.LanguageRegistrationProcessor</processor-->
+                        </configuration>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>com.oracle.truffle</groupId>
+                        <artifactId>truffle-dsl-processor</artifactId>
+                        <version>0.11</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
             <!-- Compile Java 8 sources. -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
+                    <compilerArgument>-proc:none</compilerArgument>
                 </configuration>
             </plugin>
             <!-- Checkstyle -->

org.metaborg.spoofax.shell.core/src/main/java/org/metaborg/spoofax/shell/commands/EvaluateCommand.java

@@ -0,0 +1,132 @@
+package org.metaborg.spoofax.shell.commands;
+
+import java.io.IOException;
+import java.util.Map;
+
+import org.metaborg.core.MetaborgException;
+import org.metaborg.core.context.IContext;
+import org.metaborg.core.context.IContextService;
+import org.metaborg.core.language.ILanguageImpl;
+import org.metaborg.core.project.IProject;
+import org.metaborg.spoofax.core.shell.ShellFacet;
+import org.metaborg.spoofax.shell.core.IEvaluationStrategy;
+import org.metaborg.spoofax.shell.hooks.IResultHook;
+import org.metaborg.spoofax.shell.invoker.ICommandFactory;
+import org.metaborg.spoofax.shell.output.AnalyzeResult;
+import org.metaborg.spoofax.shell.output.EvaluateResult;
+import org.metaborg.spoofax.shell.output.IResultFactory;
+import org.metaborg.spoofax.shell.output.InputResult;
+import org.metaborg.spoofax.shell.output.ParseResult;
+import org.spoofax.interpreter.terms.IStrategoTerm;
+
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+
+/**
+ * Represents an evaluate command sent to Spoofax.
+ */
+public class EvaluateCommand extends SpoofaxCommand {
+    private static final String DESCRIPTION = "Evaluate an expression";
+
+    private IContextService contextService;
+    private ParseCommand parseCommand;
+    private AnalyzeCommand analyzeCommand;
+    private IResultFactory unitFactory;
+
+    @Inject
+    private Map<String, IEvaluationStrategy> evaluationStrategies;
+    private EvaluationInvocationStrategy invocationStrategy;
+
+    /**
+     * Interface for what happens before evaluation of parsed input (i.e. either analyze or evaluate
+     * as-is).
+     */
+    private interface EvaluationInvocationStrategy {
+        EvaluateResult performEvaluation(IContext context, ParseResult parsed,
+                                         IEvaluationStrategy evalStrategy)
+            throws MetaborgException;
+    }
+
+    /**
+     * Analyze before invoking the evaluation strategy.
+     */
+    private class AnalyzedInvocationStrategy implements EvaluationInvocationStrategy {
+        @Override
+        public EvaluateResult performEvaluation(IContext context, ParseResult parsed,
+                                                IEvaluationStrategy evalStrategy)
+            throws MetaborgException {
+            AnalyzeResult analyzed = analyzeCommand.analyze(parsed);
+            IStrategoTerm ast = evalStrategy.evaluate(analyzed, context);
+            return unitFactory.createEvaluateResult(analyzed, ast);
+        }
+    }
+
+    /**
+     * Analyze before invoking the evaluation strategy.
+     */
+    private class NonAnalyzedInvocationStrategy implements EvaluationInvocationStrategy {
+        @Override
+        public EvaluateResult performEvaluation(IContext context, ParseResult parsed,
+                                                IEvaluationStrategy evalStrategy)
+            throws MetaborgException {
+            IStrategoTerm ast = evalStrategy.evaluate(parsed, context);
+            return unitFactory.createEvaluateResult(parsed, ast);
+        }
+    }
+
+    /**
+     * Instantiate an {@link EvaluateCommand}.
+     *
+     * @param contextService
+     *            The {@link IContextService}.
+     * @param commandFactory
+     *            The {@link ICommandFactory} for creating delegate commands.
+     * @param resultHook
+     *            Called upon success of evaluation of this command.
+     * @param project
+     *            The project in which this command should operate.
+     * @param lang
+     *            The language to which this command applies.
+     */
+    @Inject
+    // CHECKSTYLE.OFF: |
+    public EvaluateCommand(IContextService contextService, ICommandFactory commandFactory,
+                           IResultFactory unitFactory, IResultHook resultHook,
+                           @Assisted IProject project, @Assisted ILanguageImpl lang,
+                           @Assisted boolean analyzed) {
+        // CHECKSTYLE.ON: |
+        super(resultHook, unitFactory, project, lang);
+        this.contextService = contextService;
+        this.parseCommand = commandFactory.createParse(project, lang);
+        this.analyzeCommand = commandFactory.createAnalyze(project, lang);
+        this.unitFactory = unitFactory;
+
+        this.invocationStrategy =
+            analyzed ? new AnalyzedInvocationStrategy() : new NonAnalyzedInvocationStrategy();
+    }
+
+    @Override
+    public String description() {
+        return DESCRIPTION;
+    }
+
+    private EvaluateResult evaluate(ParseResult parsed) throws MetaborgException {
+        IContext context =
+            parsed.context().orElse(contextService.get(parsed.source(), project, lang));
+        ShellFacet facet = context.language().facet(ShellFacet.class);
+        IEvaluationStrategy evalStrategy = evaluationStrategies.get(facet.getEvaluationMethod());
+        return invocationStrategy.performEvaluation(context, parsed, evalStrategy);
+    }
+
+    @Override
+    public void execute(String... args) throws MetaborgException {
+        try {
+            InputResult input = unitFactory.createInputResult(lang, write(args[0]), args[0]);
+            ParseResult parse = parseCommand.parse(input);
+            EvaluateResult result = this.evaluate(parse);
+            resultHook.accept(result);
+        } catch (IOException e) {
+            throw new MetaborgException("Cannot write to temporary source file.");
+        }
+    }
+}

org.metaborg.spoofax.shell.core/src/main/java/org/metaborg/spoofax/shell/commands/LanguageCommand.java

@@ -99,6 +99,8 @@ public void execute(String... args) throws MetaborgException {
             invoker.addCommand("analyze", commandFactory.createAnalyze(project, lang));
         }
 
+        invoker.addCommand("eval", commandFactory.createEvaluate(project, lang, analyze));
+
         messageHook.accept(new StyledText("Loaded language" + lang));
     }
 

org.metaborg.spoofax.shell.core/src/main/java/org/metaborg/spoofax/shell/commands/ParseCommand.java

@@ -3,11 +3,14 @@
 import java.io.IOException;
 import java.util.stream.Collectors;
 
+import org.apache.commons.vfs2.FileObject;
 import org.metaborg.core.MetaborgException;
 import org.metaborg.core.language.ILanguageImpl;
 import org.metaborg.core.messages.IMessage;
 import org.metaborg.core.project.IProject;
+import org.metaborg.spoofax.core.shell.ShellFacet;
 import org.metaborg.spoofax.core.syntax.ISpoofaxSyntaxService;
+import org.metaborg.spoofax.core.syntax.JSGLRParserConfiguration;
 import org.metaborg.spoofax.core.syntax.SpoofaxSyntaxService;
 import org.metaborg.spoofax.core.unit.ISpoofaxParseUnit;
 import org.metaborg.spoofax.shell.hooks.IResultHook;
@@ -75,8 +78,18 @@ public ParseResult parse(InputResult unit) throws MetaborgException {
     @Override
     public void execute(String... args) throws MetaborgException {
         try {
-            InputResult input = resultFactory.createInputResult(lang, write(args[0]), args[0]);
-            resultHook.accept(parse(input));
+            String source = args[0];
+            FileObject file = write(args[0]);
+            ShellFacet shellFacet = lang.facet(ShellFacet.class);
+
+            InputResult input = resultFactory
+                .createInputResult(lang, file, source,
+                                   new JSGLRParserConfiguration(shellFacet.getShellStartSymbol()));
+            try {
+                resultHook.accept(parse(input));
+            } catch (MetaborgException e) {
+                resultHook.accept(parse(resultFactory.createInputResult(lang, file, source)));
+            }
         } catch (IOException e) {
             throw new MetaborgException("Cannot write to temporary source file.");
         }