Adding supernodes

.settings/org.eclipse.jdt.core.prefs

@@ -11,9 +11,9 @@ org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled
 org.eclipse.jdt.core.classpath.outputOverlappingAnotherSource=error
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=17
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=19
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=17
+org.eclipse.jdt.core.compiler.compliance=19
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
@@ -24,7 +24,7 @@ org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
 org.eclipse.jdt.core.compiler.processAnnotations=enabled
 org.eclipse.jdt.core.compiler.release=disabled
-org.eclipse.jdt.core.compiler.source=17
+org.eclipse.jdt.core.compiler.source=19
 org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=1
 org.eclipse.jdt.core.formatter.align_type_members_on_columns=true
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16

src/bdt/inlining/Variable.java

@@ -2,6 +2,8 @@
 
 import com.oracle.truffle.api.nodes.Node;
 
+import trufflesom.compiler.Variable.Local;
+
 
 /**
  * A {@link Variable} represents a variable most often in the user code, or sometimes internal
@@ -37,6 +39,13 @@ public interface Variable<N extends Node> {
    */
   N getReadNode(int contextLevel, long coord);
 
+  N getIncNode(int contextLevel, long incValue, long coord);
+
+  N getSquareNode(int contextLevel, long coord);
+
+  N getReadSquareWriteNode(int writeContextLevel, long coord, Local readLocal,
+      int readContextLevel);
+
   /**
    * Create a node to write to this variable.
    *

src/trufflesom/compiler/MethodGenerationContext.java

@@ -50,13 +50,22 @@
 import trufflesom.interpreter.nodes.ExpressionNode;
 import trufflesom.interpreter.nodes.FieldNode;
 import trufflesom.interpreter.nodes.FieldNode.FieldReadNode;
-import trufflesom.interpreter.nodes.FieldNode.UninitFieldIncNode;
 import trufflesom.interpreter.nodes.FieldNodeFactory.FieldWriteNodeGen;
+import trufflesom.interpreter.nodes.LocalVariableNode.LocalVariableReadNode;
+import trufflesom.interpreter.nodes.NonLocalVariableNode.NonLocalVariableReadNode;
 import trufflesom.interpreter.nodes.ReturnNonLocalNode;
 import trufflesom.interpreter.nodes.ReturnNonLocalNode.CatchNonLocalReturnNode;
+import trufflesom.interpreter.nodes.UninitializedMessageSendNode;
 import trufflesom.interpreter.nodes.literals.BlockNode;
-import trufflesom.interpreter.nodes.specialized.IntIncrementNode;
+import trufflesom.interpreter.supernodes.IntIncrementNode;
+import trufflesom.interpreter.supernodes.LocalVarReadUnaryMsgWriteNode;
+import trufflesom.interpreter.supernodes.LocalVariableSquareNode;
+import trufflesom.interpreter.supernodes.NonLocalVarReadUnaryMsgWriteNode;
+import trufflesom.interpreter.supernodes.NonLocalVariableSquareNode;
+import trufflesom.interpreter.supernodes.UninitIncFieldNode;
 import trufflesom.primitives.Primitives;
+import trufflesom.primitives.arithmetic.AdditionPrim;
+import trufflesom.vm.NotYetImplementedException;
 import trufflesom.vmobjects.SClass;
 import trufflesom.vmobjects.SInvokable;
 import trufflesom.vmobjects.SInvokable.SMethod;
@@ -401,7 +410,56 @@ public ExpressionNode getLocalReadNode(final Variable variable, final long coord
 
   public ExpressionNode getLocalWriteNode(final Variable variable,
       final ExpressionNode valExpr, final long coord) {
-    return variable.getWriteNode(getContextLevel(variable), valExpr, coord);
+    int ctxLevel = getContextLevel(variable);
+
+    if (valExpr instanceof IntIncrementNode
+        && ((IntIncrementNode) valExpr).doesAccessVariable(variable)) {
+      return ((IntIncrementNode) valExpr).createIncNode((Local) variable, ctxLevel);
+    }
+
+    if (ctxLevel == 0) {
+      if (valExpr instanceof LocalVariableSquareNode l) {
+        return variable.getReadSquareWriteNode(ctxLevel, coord, l.getLocal(), 0);
+      }
+      if (valExpr instanceof NonLocalVariableSquareNode) {
+        throw new NotYetImplementedException(
+            "a missing read/square/write combination, used in a benchmark?");
+      }
+
+      if (valExpr instanceof UninitializedMessageSendNode) {
+        UninitializedMessageSendNode val = (UninitializedMessageSendNode) valExpr;
+        ExpressionNode[] args = val.getArguments();
+        if (args.length == 1 && args[0] instanceof LocalVariableReadNode) {
+          LocalVariableReadNode var = (LocalVariableReadNode) args[0];
+          if (var.getLocal() == variable) {
+            return new LocalVarReadUnaryMsgWriteNode((Local) variable,
+                val.getInvocationIdentifier());
+          }
+        }
+      }
+    } else {
+      if (valExpr instanceof NonLocalVariableSquareNode nl) {
+        return variable.getReadSquareWriteNode(ctxLevel, coord,
+            nl.getLocal(), nl.getContextLevel());
+      }
+
+      if (valExpr instanceof LocalVariableSquareNode l) {
+        return variable.getReadSquareWriteNode(ctxLevel, coord, l.getLocal(), 0);
+      }
+
+      if (valExpr instanceof UninitializedMessageSendNode) {
+        UninitializedMessageSendNode val = (UninitializedMessageSendNode) valExpr;
+        ExpressionNode[] args = val.getArguments();
+        if (args.length == 1 && args[0] instanceof NonLocalVariableReadNode) {
+          NonLocalVariableReadNode var = (NonLocalVariableReadNode) args[0];
+          if (var.getLocal() == variable) {
+            return new NonLocalVarReadUnaryMsgWriteNode(ctxLevel, (Local) variable,
+                val.getInvocationIdentifier());
+          }
+        }
+      }
+    }
+    return variable.getWriteNode(ctxLevel, valExpr, coord);
   }
 
   protected Local getLocal(final SSymbol varName) {
@@ -451,7 +509,22 @@ public FieldNode getObjectFieldWrite(final SSymbol fieldName, final ExpressionNo
     ExpressionNode self = getSelfRead(coord);
     if (exp instanceof IntIncrementNode
         && ((IntIncrementNode) exp).doesAccessField(fieldIndex)) {
-      return new UninitFieldIncNode(self, fieldIndex, coord);
+      return ((IntIncrementNode) exp).createFieldIncNode(self, fieldIndex, coord);
+    }
+
+    if (exp instanceof AdditionPrim) {
+      AdditionPrim add = (AdditionPrim) exp;
+      ExpressionNode rcvr = add.getReceiver();
+      ExpressionNode arg = add.getArgument();
+
+      if (rcvr instanceof FieldReadNode
+          && fieldIndex == ((FieldReadNode) rcvr).getFieldIndex()) {
+        return new UninitIncFieldNode(self, arg, true, fieldIndex, coord);
+      }
+      if (arg instanceof FieldReadNode
+          && fieldIndex == ((FieldReadNode) arg).getFieldIndex()) {
+        return new UninitIncFieldNode(self, rcvr, false, fieldIndex, coord);
+      }
     }
 
     return FieldWriteNodeGen.create(fieldIndex, self, exp).initialize(coord);

src/trufflesom/compiler/ParserAst.java

@@ -27,20 +27,36 @@
 import bdt.basic.ProgramDefinitionError;
 import bdt.inlining.InlinableNodes;
 import bdt.tools.structure.StructuralProbe;
+import trufflesom.interpreter.nodes.ArgumentReadNode.LocalArgumentReadNode;
+import trufflesom.interpreter.nodes.ArgumentReadNode.NonLocalArgumentReadNode;
 import trufflesom.interpreter.nodes.ExpressionNode;
 import trufflesom.interpreter.nodes.FieldNode;
+import trufflesom.interpreter.nodes.FieldNode.FieldReadNode;
 import trufflesom.interpreter.nodes.GlobalNode;
+import trufflesom.interpreter.nodes.LocalVariableNode.LocalVariableReadNode;
 import trufflesom.interpreter.nodes.MessageSendNode;
+import trufflesom.interpreter.nodes.NonLocalVariableNode.NonLocalVariableReadNode;
 import trufflesom.interpreter.nodes.SequenceNode;
 import trufflesom.interpreter.nodes.literals.BlockNode;
 import trufflesom.interpreter.nodes.literals.BlockNode.BlockNodeWithContext;
 import trufflesom.interpreter.nodes.literals.DoubleLiteralNode;
 import trufflesom.interpreter.nodes.literals.GenericLiteralNode;
 import trufflesom.interpreter.nodes.literals.IntegerLiteralNode;
 import trufflesom.interpreter.nodes.literals.LiteralNode;
-import trufflesom.interpreter.nodes.specialized.IntIncrementNodeGen;
+import trufflesom.interpreter.nodes.specialized.IfInlinedLiteralNode;
+import trufflesom.interpreter.supernodes.GreaterThanIntNodeGen;
+import trufflesom.interpreter.supernodes.IntIncrementNodeGen;
+import trufflesom.interpreter.supernodes.LessThanIntNodeGen;
+import trufflesom.interpreter.supernodes.LocalArgGreaterThanInt;
+import trufflesom.interpreter.supernodes.LocalArgLessThanInt;
+import trufflesom.interpreter.supernodes.LocalFieldStringEqualsNode;
+import trufflesom.interpreter.supernodes.LocalVariableSquareNodeGen;
+import trufflesom.interpreter.supernodes.NonLocalFieldStringEqualsNode;
+import trufflesom.interpreter.supernodes.NonLocalVariableSquareNodeGen;
+import trufflesom.interpreter.supernodes.StringEqualsNodeGen;
 import trufflesom.primitives.Primitives;
 import trufflesom.vm.Globals;
+import trufflesom.vm.NotYetImplementedException;
 import trufflesom.vmobjects.SArray;
 import trufflesom.vmobjects.SClass;
 import trufflesom.vmobjects.SInvokable;
@@ -255,18 +271,102 @@ protected ExpressionNode binaryMessage(final MethodGenerationContext mgenc,
           mgenc.getHolder().getSuperClass(), msg, args, coordWithL);
     }
 
+    String binSelector = msg.getString();
+
+    if (binSelector.equals("*")) {
+      if (receiver instanceof LocalVariableReadNode rcvr
+          && operand instanceof LocalVariableReadNode op) {
+        if (rcvr.isSameLocal(op)) {
+          return LocalVariableSquareNodeGen.create(rcvr.getLocal()).initialize(coordWithL);
+        }
+      } else if (receiver instanceof NonLocalVariableReadNode rcvr
+          && operand instanceof NonLocalVariableReadNode op) {
+        if (rcvr.isSameLocal(op)) {
+          assert rcvr.getContextLevel() == op.getContextLevel();
+          return NonLocalVariableSquareNodeGen.create(
+              rcvr.getContextLevel(), rcvr.getLocal()).initialize(coordWithL);
+        }
+      }
+    } else if (binSelector.equals("=")) {
+      if (operand instanceof GenericLiteralNode) {
+        Object literal = operand.executeGeneric(null);
+        if (literal instanceof String l) {
+          if (receiver instanceof FieldReadNode fieldRead) {
+            ExpressionNode self = fieldRead.getSelf();
+            if (self instanceof LocalArgumentReadNode selfLocal) {
+              return new LocalFieldStringEqualsNode(fieldRead.getFieldIndex(),
+                  selfLocal.getArg(), l).initialize(coordWithL);
+            } else if (self instanceof NonLocalArgumentReadNode arg) {
+              return new NonLocalFieldStringEqualsNode(fieldRead.getFieldIndex(),
+                  arg.getArg(), arg.getContextLevel(), l).initialize(coordWithL);
+            } else {
+              throw new NotYetImplementedException();
+            }
+          }
+
+          return StringEqualsNodeGen.create(l, receiver).initialize(coordWithL);
+        }
+      }
+
+      if (receiver instanceof GenericLiteralNode) {
+        Object literal = receiver.executeGeneric(null);
+        if (literal instanceof String l) {
+          if (operand instanceof FieldReadNode fieldRead) {
+            ExpressionNode self = fieldRead.getSelf();
+            if (self instanceof LocalArgumentReadNode selfArg) {
+              return new LocalFieldStringEqualsNode(fieldRead.getFieldIndex(),
+                  selfArg.getArg(), l).initialize(coordWithL);
+            } else if (self instanceof NonLocalArgumentReadNode) {
+              NonLocalArgumentReadNode arg = (NonLocalArgumentReadNode) self;
+              return new NonLocalFieldStringEqualsNode(fieldRead.getFieldIndex(),
+                  arg.getArg(), arg.getContextLevel(), l).initialize(coordWithL);
+            } else {
+              throw new NotYetImplementedException();
+            }
+          }
+
+          return StringEqualsNodeGen.create(l, operand).initialize(coordWithL);
+        }
+      }
+    } else if (operand instanceof IntegerLiteralNode lit) {
+      if (binSelector.equals("+")) {
+        return IntIncrementNodeGen.create(lit.executeLong(null), false, receiver)
+                                  .initialize(coordWithL);
+      }
+      if (binSelector.equals("-")) {
+        return IntIncrementNodeGen.create(-lit.executeLong(null), true, receiver)
+                                  .initialize(coordWithL);
+      }
+      if (binSelector.equals(">")) {
+        if (receiver instanceof LocalArgumentReadNode rcvr) {
+          return new LocalArgGreaterThanInt(rcvr.getArg(),
+              lit.executeLong(null)).initialize(coordWithL);
+        }
+
+        return GreaterThanIntNodeGen.create(lit.executeLong(null), receiver)
+                                    .initialize(coordWithL);
+      }
+      if (binSelector.equals("<")) {
+        if (receiver instanceof LocalArgumentReadNode rcvr) {
+          return new LocalArgLessThanInt(rcvr.getArg(),
+              lit.executeLong(null)).initialize(coordWithL);
+        }
+
+        return LessThanIntNodeGen.create(lit.executeLong(null), receiver)
+                                 .initialize(coordWithL);
+      }
+    }
+
     ExpressionNode inlined =
         inlinableNodes.inline(msg, args, mgenc, coordWithL);
     if (inlined != null) {
       assert !isSuperSend;
       return inlined;
     }
 
-    if (msg.getString().equals("+") && operand instanceof IntegerLiteralNode) {
-      IntegerLiteralNode lit = (IntegerLiteralNode) operand;
-      if (lit.executeLong(null) == 1) {
-        return IntIncrementNodeGen.create(receiver);
-      }
+    if (msg.getString().equals("+") && operand instanceof IntegerLiteralNode lit) {
+      long value = lit.executeLong(null);
+      return IntIncrementNodeGen.create(value, false, receiver);
     }
     return MessageSendNode.create(msg, args, coordWithL);
   }
@@ -299,6 +399,9 @@ protected ExpressionNode keywordMessage(final MethodGenerationContext mgenc,
     ExpressionNode inlined = inlinableNodes.inline(msg, args, mgenc, coodWithL);
     if (inlined != null) {
       assert !isSuperSend;
+      if (args.length == 2 && inlined instanceof IfInlinedLiteralNode) {
+        return ((IfInlinedLiteralNode) inlined).asIsNilIfTrueIfPossible();
+      }
       return inlined;
     }