Merge 2cbbe3f into 65e468a

build.xml

@@ -56,6 +56,7 @@
     <target name="clobber" description="Do clean, and also clean truffle build" depends="clean,clean-truffle">
         <delete dir="${kompos.dir}/out"/>
         <delete dir="${kompos.dir}/node_modules"/>
+        <ant dir="${bd.dir}" useNativeBasedir="true" target="clean" inheritAll="false"/>
     </target>
 
     <target name="check-java">

src/som/VM.java

@@ -23,6 +23,7 @@
 import com.oracle.truffle.tools.Profiler;
 import com.oracle.truffle.tools.ProfilerInstrument;
 
+import bd.inlining.InlinableNodes;
 import coveralls.truffle.Coverage;
 import som.compiler.MixinDefinition;
 import som.compiler.SourcecodeCompiler;
@@ -44,6 +45,7 @@
 import som.vm.VmSettings;
 import som.vm.constants.KernelObj;
 import som.vmobjects.SObjectWithClass.SObjectWithoutFields;
+import som.vmobjects.SSymbol;
 import tools.concurrency.ActorExecutionTrace;
 import tools.concurrency.TracingActors;
 import tools.debugger.Tags;
@@ -54,6 +56,7 @@
 import tools.superinstructions.CandidateIdentifier;
 
 
+@SuppressWarnings("deprecation")
 public final class VM {
 
   @CompilationFinal private PolyglotEngine engine;
@@ -153,6 +156,10 @@ public Primitives getPrimitives() {
     return objectSystem.getPrimitives();
   }
 
+  public InlinableNodes<SSymbol> getInlinableNodes() {
+    return objectSystem.getInlinableNodes();
+  }
+
   public static void thisMethodNeedsToBeOptimized(final String msg) {
     if (VmSettings.FAIL_ON_MISSING_OPTIMIZATIONS) {
       CompilerAsserts.neverPartOfCompilation(msg);
@@ -180,7 +187,6 @@ public static void insertInstrumentationWrapper(final Node node) {
     }
   }
 
-  @SuppressWarnings("deprecation")
   private static void outputToIGV(final Method method) {
     GraphPrintVisitor graphPrinter = new GraphPrintVisitor();
 

src/som/compiler/MethodBuilder.java

@@ -25,6 +25,7 @@
 package som.compiler;
 
 import static som.interpreter.SNodeFactory.createCatchNonLocalReturn;
+import static som.vm.Symbols.symbolFor;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -35,15 +36,17 @@
 import com.oracle.truffle.api.frame.FrameSlotKind;
 import com.oracle.truffle.api.source.SourceSection;
 
+import bd.inlining.ScopeAdaptationVisitor;
+import bd.inlining.ScopeBuilder;
+import bd.inlining.nodes.Inlinable;
 import som.compiler.MixinBuilder.MixinDefinitionError;
 import som.compiler.MixinBuilder.MixinDefinitionId;
-import som.compiler.ProgramDefinitionError.SemanticDefinitionError;
+import som.compiler.Variable.AccessNodeState;
 import som.compiler.Variable.Argument;
 import som.compiler.Variable.ImmutableLocal;
 import som.compiler.Variable.Internal;
 import som.compiler.Variable.Local;
 import som.compiler.Variable.MutableLocal;
-import som.interpreter.InliningVisitor;
 import som.interpreter.LexicalScope.MethodScope;
 import som.interpreter.LexicalScope.MixinScope;
 import som.interpreter.Method;
@@ -52,15 +55,17 @@
 import som.interpreter.nodes.ExpressionNode;
 import som.interpreter.nodes.OuterObjectReadNodeGen;
 import som.interpreter.nodes.ReturnNonLocalNode;
+import som.interpreter.nodes.literals.BlockNode;
 import som.vm.Symbols;
 import som.vm.constants.Nil;
 import som.vmobjects.SInvokable;
 import som.vmobjects.SInvokable.SInitializer;
 import som.vmobjects.SSymbol;
+import tools.SourceCoordinate;
 import tools.language.StructuralProbe;
 
 
-public final class MethodBuilder {
+public final class MethodBuilder implements ScopeBuilder<MethodBuilder> {
 
   /** To get to an indirect outer, use outerBuilder. */
   private final MixinBuilder  directOuterMixin;
@@ -180,6 +185,24 @@ public void mergeIntoScope(final MethodScope scope, final SInvokable outer) {
     currentScope.removeMerged(scope);
   }
 
+  @Override
+  public bd.inlining.Variable<?> introduceTempForInlinedVersion(
+      final Inlinable<MethodBuilder> blockOrVal, final SourceSection source)
+      throws MethodDefinitionError {
+    Local loopIdx;
+    if (blockOrVal instanceof BlockNode) {
+      Argument[] args = ((BlockNode) blockOrVal).getArguments();
+      assert args.length == 2;
+      loopIdx = getLocal(args[1].getQualifiedName());
+    } else {
+      // if it is a literal, we still need a memory location for counting, so,
+      // add a synthetic local
+      loopIdx = addLocalAndUpdateScope(
+          symbolFor("!i" + SourceCoordinate.getLocationQualifier(source)), false, source);
+    }
+    return loopIdx;
+  }
+
   public void addEmbeddedBlockMethod(final SInvokable blockMethod) {
     embeddedBlockMethods.add(blockMethod);
     currentScope.addEmbeddedScope(((Method) blockMethod.getInvokable()).getLexicalScope());
@@ -254,7 +277,7 @@ public SInitializer splitBodyAndAssembleInitializerAs(final SSymbol signature,
       final ExpressionNode body, final AccessModifier accessModifier,
       final SourceSection sourceSection) {
     MethodScope splitScope = currentScope.split();
-    ExpressionNode splitBody = InliningVisitor.doInline(body, splitScope, 0, false);
+    ExpressionNode splitBody = ScopeAdaptationVisitor.adapt(body, splitScope, 0, false);
     Method truffleMeth = assembleInvokable(splitBody, splitScope, sourceSection);
 
     // TODO: not sure whether it is safe to use the embeddedBlockMethods here,
@@ -388,7 +411,7 @@ public Local addLocal(final SSymbol name, final boolean immutable,
     return l;
   }
 
-  public Local addLocalAndUpdateScope(final SSymbol name, final boolean immutable,
+  private Local addLocalAndUpdateScope(final SSymbol name, final boolean immutable,
       final SourceSection source) throws MethodDefinitionError {
     Local l = addLocal(name, immutable, source);
     currentScope.addVariable(l);
@@ -507,14 +530,15 @@ public ExpressionNode getSuperReadNode(final SourceSection source) {
     assert source != null;
     MixinBuilder holder = getEnclosingMixinBuilder();
     return getSelf().getSuperReadNode(getOuterSelfContextLevel(),
-        holder.getMixinId(), holder.isClassSide(), source);
+        new AccessNodeState(holder.getMixinId(), holder.isClassSide()), source);
   }
 
   public ExpressionNode getSelfRead(final SourceSection source) {
     assert source != null;
     MixinBuilder holder = getEnclosingMixinBuilder();
     MixinDefinitionId mixinId = holder == null ? null : holder.getMixinId();
-    return getSelf().getSelfReadNode(getContextLevel(Symbols.SELF), mixinId, source);
+    return getSelf().getThisReadNode(getContextLevel(Symbols.SELF),
+        new AccessNodeState(mixinId), source);
   }
 
   public ExpressionNode getReadNode(final SSymbol variableName,

src/som/compiler/MixinBuilder.java

@@ -37,7 +37,6 @@
 import som.compiler.MixinDefinition.ClassSlotDefinition;
 import som.compiler.MixinDefinition.SlotDefinition;
 import som.compiler.MixinDefinition.SlotMutator;
-import som.compiler.ProgramDefinitionError.SemanticDefinitionError;
 import som.compiler.Variable.Argument;
 import som.interpreter.LexicalScope.MethodScope;
 import som.interpreter.LexicalScope.MixinScope;

src/som/compiler/Parser.java

@@ -77,11 +77,11 @@
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
 
+import bd.basic.ProgramDefinitionError;
+import bd.inlining.InlinableNodes;
 import som.Output;
 import som.compiler.Lexer.Peek;
-import som.compiler.MethodBuilder.MethodDefinitionError;
 import som.compiler.MixinBuilder.MixinDefinitionError;
-import som.compiler.Variable.Argument;
 import som.compiler.Variable.Local;
 import som.interpreter.SomLanguage;
 import som.interpreter.nodes.ExpressionNode;
@@ -100,14 +100,6 @@
 import som.interpreter.nodes.literals.ObjectLiteralNode;
 import som.interpreter.nodes.literals.StringLiteralNode;
 import som.interpreter.nodes.literals.SymbolLiteralNode;
-import som.interpreter.nodes.specialized.BooleanInlinedLiteralNode.AndInlinedLiteralNode;
-import som.interpreter.nodes.specialized.BooleanInlinedLiteralNode.OrInlinedLiteralNode;
-import som.interpreter.nodes.specialized.IfInlinedLiteralNode;
-import som.interpreter.nodes.specialized.IfTrueIfFalseInlinedLiteralsNode;
-import som.interpreter.nodes.specialized.IntDownToDoInlinedLiteralsNodeGen;
-import som.interpreter.nodes.specialized.IntTimesRepeatLiteralNodeGen;
-import som.interpreter.nodes.specialized.IntToDoInlinedLiteralsNodeGen;
-import som.interpreter.nodes.specialized.whileloops.WhileInlinedLiteralsNode;
 import som.vm.Symbols;
 import som.vm.VmSettings;
 import som.vmobjects.SInvokable;
@@ -142,6 +134,8 @@ public class Parser {
   private final Set<SourceSection> syntaxAnnotations;
   private final StructuralProbe    structuralProbe;
 
+  private final InlinableNodes<SSymbol> inlinableNodes;
+
   /**
    * TODO: fix AST inlining while parsing locals/slots, and remove the disabling.
    */
@@ -288,6 +282,12 @@ public Parser(final String content, final long fileSize, final Source source,
 
     this.syntaxAnnotations = new HashSet<>();
     this.structuralProbe = structuralProbe;
+
+    if (language.getVM() != null) {
+      this.inlinableNodes = language.getVM().getInlinableNodes();
+    } else {
+      this.inlinableNodes = null;
+    }
   }
 
   Set<SourceSection> getSyntaxAnnotations() {
@@ -1347,17 +1347,12 @@ protected ExpressionNode unaryMessage(final ExpressionNode receiver,
 
   private ExpressionNode tryInliningBinaryMessage(final MethodBuilder builder,
       final ExpressionNode receiver, final SourceCoordinate coord, final SSymbol msg,
-      final ExpressionNode operand) {
+      final ExpressionNode operand) throws ProgramDefinitionError {
     List<ExpressionNode> arguments = new ArrayList<ExpressionNode>();
     arguments.add(receiver);
     arguments.add(operand);
     SourceSection source = getSource(coord);
-    ExpressionNode node = inlineControlStructureIfPossible(builder, arguments, msg.getString(),
-        msg.getNumberOfSignatureArguments(), source);
-    if (node != null) {
-      node.initialize(source);
-    }
-    return node;
+    return inlineControlStructureIfPossible(builder, arguments, msg, source);
   }
 
   protected ExpressionNode binaryMessage(final MethodBuilder builder,
@@ -1431,17 +1426,14 @@ protected ExpressionNode keywordMessage(final MethodBuilder builder,
     String msgStr = kw.toString();
     SSymbol msg = symbolFor(msgStr);
 
+    SourceSection source = getSource(coord);
     if (!eventualSend) {
-      SourceSection source = getSource(coord);
-      ExpressionNode node = inlineControlStructureIfPossible(builder, arguments,
-          msgStr, msg.getNumberOfSignatureArguments(), source);
+      ExpressionNode node = inlineControlStructureIfPossible(builder, arguments, msg, source);
       if (node != null) {
-        node.initialize(source);
         return node;
       }
     }
 
-    SourceSection source = getSource(coord);
     ExpressionNode[] args = arguments.toArray(new ExpressionNode[0]);
     if (explicitRcvr) {
       return createMessageSend(
@@ -1454,118 +1446,14 @@ protected ExpressionNode keywordMessage(final MethodBuilder builder,
     }
   }
 
-  protected ExpressionNode inlineControlStructureIfPossible(
-      final MethodBuilder builder, final List<ExpressionNode> arguments,
-      final String msgStr, final int numberOfArguments, final SourceSection source) {
+  protected ExpressionNode inlineControlStructureIfPossible(final MethodBuilder builder,
+      final List<ExpressionNode> arguments, final SSymbol msg, final SourceSection source)
+      throws ProgramDefinitionError {
     if (parsingSlotDefs > 0) {
       return null;
     }
 
-    if (numberOfArguments == 2) {
-      if (arguments.get(1) instanceof LiteralNode) {
-        if ("ifTrue:".equals(msgStr)) {
-          ExpressionNode condition = arguments.get(0);
-          condition.markAsControlFlowCondition();
-          ExpressionNode inlinedBody = ((LiteralNode) arguments.get(1)).inline(builder);
-          return new IfInlinedLiteralNode(condition, true, inlinedBody,
-              arguments.get(1));
-        } else if ("ifFalse:".equals(msgStr)) {
-          ExpressionNode condition = arguments.get(0);
-          condition.markAsControlFlowCondition();
-          ExpressionNode inlinedBody = ((LiteralNode) arguments.get(1)).inline(builder);
-          return new IfInlinedLiteralNode(condition, false, inlinedBody,
-              arguments.get(1));
-        } else if ("whileTrue:".equals(msgStr)) {
-          if (!(arguments.get(0) instanceof LiteralNode)
-              || !(arguments.get(1) instanceof LiteralNode)) {
-            return null;
-          }
-          ExpressionNode inlinedCondition = ((LiteralNode) arguments.get(0)).inline(builder);
-          inlinedCondition.markAsControlFlowCondition();
-          ExpressionNode inlinedBody = ((LiteralNode) arguments.get(1)).inline(builder);
-          inlinedBody.markAsLoopBody();
-          return new WhileInlinedLiteralsNode(inlinedCondition, inlinedBody,
-              true, arguments.get(0), arguments.get(1));
-        } else if ("whileFalse:".equals(msgStr)) {
-          if (!(arguments.get(0) instanceof LiteralNode)
-              || !(arguments.get(1) instanceof LiteralNode)) {
-            return null;
-          }
-          ExpressionNode inlinedCondition = ((LiteralNode) arguments.get(0)).inline(builder);
-          inlinedCondition.markAsControlFlowCondition();
-          ExpressionNode inlinedBody = ((LiteralNode) arguments.get(1)).inline(builder);
-          inlinedBody.markAsLoopBody();
-          return new WhileInlinedLiteralsNode(inlinedCondition, inlinedBody,
-              false, arguments.get(0), arguments.get(1));
-        } else if ("or:".equals(msgStr) || "||".equals(msgStr)) {
-          ExpressionNode inlinedArg = ((LiteralNode) arguments.get(1)).inline(builder);
-          return new OrInlinedLiteralNode(arguments.get(0), inlinedArg, arguments.get(1));
-        } else if ("and:".equals(msgStr) || "&&".equals(msgStr)) {
-          ExpressionNode inlinedArg = ((LiteralNode) arguments.get(1)).inline(builder);
-          return new AndInlinedLiteralNode(arguments.get(0), inlinedArg, arguments.get(1));
-        } else if (!VmSettings.DYNAMIC_METRICS && "timesRepeat:".equals(msgStr)) {
-          ExpressionNode inlinedBody = ((LiteralNode) arguments.get(1)).inline(builder);
-          inlinedBody.markAsLoopBody();
-          return IntTimesRepeatLiteralNodeGen.create(inlinedBody, arguments.get(1),
-              arguments.get(0));
-        }
-      }
-    } else if (numberOfArguments == 3) {
-      if ("ifTrue:ifFalse:".equals(msgStr) &&
-          arguments.get(1) instanceof LiteralNode && arguments.get(2) instanceof LiteralNode) {
-        LiteralNode blockOrVal = (LiteralNode) arguments.get(2);
-        ExpressionNode condition = arguments.get(0);
-        condition.markAsControlFlowCondition();
-        ExpressionNode inlinedTrueNode = ((LiteralNode) arguments.get(1)).inline(builder);
-        ExpressionNode inlinedFalseNode = blockOrVal.inline(builder);
-        return new IfTrueIfFalseInlinedLiteralsNode(condition,
-            inlinedTrueNode, inlinedFalseNode, arguments.get(1), arguments.get(2));
-      } else if (!VmSettings.DYNAMIC_METRICS && "to:do:".equals(msgStr) &&
-          arguments.get(2) instanceof LiteralNode) {
-        LiteralNode blockOrVal = (LiteralNode) arguments.get(2);
-        try {
-          ExpressionNode inlinedBody = blockOrVal.inline(builder);
-          inlinedBody.markAsLoopBody();
-
-          Local loopIdx = getLoopIdx(builder, blockOrVal, source);
-          return IntToDoInlinedLiteralsNodeGen.create(inlinedBody, loopIdx, arguments.get(2),
-              arguments.get(0), arguments.get(1));
-        } catch (MethodDefinitionError e) {
-          throw new RuntimeException(e);
-        }
-      } else if (!VmSettings.DYNAMIC_METRICS && "downTo:do:".equals(msgStr) &&
-          arguments.get(2) instanceof LiteralNode) {
-        LiteralNode blockOrVal = (LiteralNode) arguments.get(2);
-        try {
-          ExpressionNode inlinedBody = blockOrVal.inline(builder);
-          inlinedBody.markAsLoopBody();
-
-          Local loopIdx = getLoopIdx(builder, blockOrVal, source);
-          return IntDownToDoInlinedLiteralsNodeGen.create(inlinedBody, loopIdx,
-              arguments.get(2), arguments.get(0), arguments.get(1));
-        } catch (MethodDefinitionError e) {
-          throw new RuntimeException(e);
-        }
-      }
-    }
-    return null;
-  }
-
-  private Local getLoopIdx(final MethodBuilder builder,
-      final LiteralNode blockOrVal, final SourceSection source)
-      throws MethodDefinitionError {
-    Local loopIdx;
-    if (blockOrVal instanceof BlockNode) {
-      Argument[] args = ((BlockNode) blockOrVal).getArguments();
-      assert args.length == 2;
-      loopIdx = builder.getLocal(args[1].getQualifiedName());
-    } else {
-      // if it is a literal, we still need a memory location for counting, so,
-      // add a synthetic local
-      loopIdx = builder.addLocalAndUpdateScope(
-          symbolFor("!i" + SourceCoordinate.getLocationQualifier(source)), false, source);
-    }
-    return loopIdx;
+    return inlinableNodes.inline(msg, arguments, builder, source);
   }
 
   private ExpressionNode formula(final MethodBuilder builder)