Adopt InstrumentableNode/GenerateWrapper and hasTag

- all InstrumentableNodes need execute method with virtual frame for correct wrapping
- need no-arg standard constructor
- replace VM.insertInstrumentationWrapper(.) with notifyInserted(.)
- adopt IsValue primitive
- use hasTag method from InstrumentableNode
- eliminate all isTaggedWith, this is not compatible with the other changes, need to use hasTag exclusively
- fix node initialization and set missing source sections

Signed-off-by: Stefan Marr <git@stefan-marr.de>

src/som/VM.java

@@ -12,6 +12,7 @@
 import com.oracle.truffle.api.debug.Debugger;
 import com.oracle.truffle.api.instrumentation.InstrumentableFactory.WrapperNode;
 import com.oracle.truffle.api.instrumentation.InstrumentationHandler;
+import com.oracle.truffle.api.instrumentation.Tag;
 import com.oracle.truffle.api.nodes.GraphPrintVisitor;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.source.Source;
@@ -49,7 +50,6 @@
 import tools.concurrency.KomposTrace;
 import tools.concurrency.TracingActors;
 import tools.concurrency.TracingBackend;
-import tools.debugger.Tags;
 import tools.debugger.WebDebugger;
 import tools.debugger.session.Breakpoints;
 import tools.dym.DynamicMetrics;
@@ -226,7 +226,7 @@ public boolean isPoolIdle() {
         && forkJoinPool.isQuiescent() && threadPool.isQuiescent();
   }
 
-  public void reportSyntaxElement(final Class<? extends Tags> type,
+  public void reportSyntaxElement(final Class<? extends Tag> type,
       final SourceSection source) {
     if (webDebugger != null) {
       webDebugger.reportSyntaxElement(type, source);

src/som/instrumentation/InstrumentableBlockApplyNodeWrapper.java

@@ -0,0 +1,76 @@
+package som.instrumentation;
+
+import com.oracle.truffle.api.CallTarget;
+import com.oracle.truffle.api.instrumentation.InstrumentableNode.WrapperNode;
+import com.oracle.truffle.api.instrumentation.ProbeNode;
+import com.oracle.truffle.api.nodes.NodeCost;
+
+import som.instrumentation.InstrumentableDirectCallNode.InstrumentableBlockApplyNode;
+
+
+public class InstrumentableBlockApplyNodeWrapper extends InstrumentableBlockApplyNode
+    implements WrapperNode {
+  @Child private InstrumentableDirectCallNode delegateNode;
+  @Child private ProbeNode                    probeNode;
+
+  InstrumentableBlockApplyNodeWrapper(final InstrumentableDirectCallNode delegateNode,
+      final ProbeNode probeNode) {
+    this.delegateNode = delegateNode;
+    this.probeNode = probeNode;
+  }
+
+  @Override
+  public InstrumentableDirectCallNode getDelegateNode() {
+    return delegateNode;
+  }
+
+  @Override
+  public ProbeNode getProbeNode() {
+    return probeNode;
+  }
+
+  @Override
+  public NodeCost getCost() {
+    return NodeCost.NONE;
+  }
+
+  @Override
+  public Object call(final Object[] arguments) {
+    return delegateNode.call(arguments);
+  }
+
+  @Override
+  public CallTarget getCallTarget() {
+    return delegateNode.getCallTarget();
+  }
+
+  @Override
+  public boolean isInlinable() {
+    return delegateNode.isInlinable();
+  }
+
+  @Override
+  public boolean isInliningForced() {
+    return delegateNode.isInliningForced();
+  }
+
+  @Override
+  public void forceInlining() {
+    delegateNode.forceInlining();
+  }
+
+  @Override
+  public boolean isCallTargetCloningAllowed() {
+    return delegateNode.isCallTargetCloningAllowed();
+  }
+
+  @Override
+  public boolean cloneCallTarget() {
+    return delegateNode.cloneCallTarget();
+  }
+
+  @Override
+  public CallTarget getClonedCallTarget() {
+    return delegateNode.getClonedCallTarget();
+  }
+}

src/som/instrumentation/InstrumentableDirectCallNode.java

@@ -2,38 +2,55 @@
 
 import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
-import com.oracle.truffle.api.instrumentation.Instrumentable;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.instrumentation.InstrumentableNode;
+import com.oracle.truffle.api.instrumentation.ProbeNode;
+import com.oracle.truffle.api.instrumentation.Tag;
 import com.oracle.truffle.api.nodes.DirectCallNode;
 import com.oracle.truffle.api.source.SourceSection;
 
 import tools.dym.Tags.CachedClosureInvoke;
 import tools.dym.Tags.CachedVirtualInvoke;
 
 
-@Instrumentable(factory = DirectCallNodeWrapper.class)
-public class InstrumentableDirectCallNode extends DirectCallNode {
+public class InstrumentableDirectCallNode extends DirectCallNode
+    implements InstrumentableNode {
 
-  @Child protected DirectCallNode         callNode;
+  @Child private DirectCallNode           callNode;
   @CompilationFinal private SourceSection sourceSection;
 
   public InstrumentableDirectCallNode(final DirectCallNode callNode,
       final SourceSection source) {
     super(null);
+    assert (callNode != null && (getClass() == InstrumentableDirectCallNode.class
+        || getClass() == InstrumentableBlockApplyNode.class))
+        || (callNode == null) : "callNode needs to be set";
     this.callNode = callNode;
     this.sourceSection = source;
   }
 
-  protected InstrumentableDirectCallNode(final InstrumentableDirectCallNode wrapped) {
+  /** For wrapper. */
+  protected InstrumentableDirectCallNode() {
     super(null);
   }
 
+  public Object executeDummy(final VirtualFrame frame) {
+    return null;
+  }
+
   @Override
-  protected boolean isTaggedWith(final Class<?> tag) {
-    if (tag == CachedVirtualInvoke.class) {
-      return true;
-    } else {
-      return super.isTaggedWith(tag);
-    }
+  public boolean isInstrumentable() {
+    return true;
+  }
+
+  @Override
+  public boolean hasTag(final Class<? extends Tag> tag) {
+    return tag == CachedVirtualInvoke.class;
+  }
+
+  @Override
+  public WrapperNode createWrapper(final ProbeNode probe) {
+    return new InstrumentableDirectCallNodeWrapper(this, probe);
   }
 
   @Override
@@ -81,21 +98,30 @@ public CallTarget getClonedCallTarget() {
     return callNode.getClonedCallTarget();
   }
 
-  @Instrumentable(factory = DirectCallNodeWrapper.class)
   public static class InstrumentableBlockApplyNode extends InstrumentableDirectCallNode {
     public InstrumentableBlockApplyNode(final DirectCallNode callNode,
         final SourceSection source) {
       super(callNode, source);
     }
 
+    /** For wrappers. */
+    protected InstrumentableBlockApplyNode() {
+      this(null, null);
+    }
+
+    @Override
+    public WrapperNode createWrapper(final ProbeNode probe) {
+      return new InstrumentableBlockApplyNodeWrapper(this, probe);
+    }
+
     @Override
-    protected boolean isTaggedWith(final Class<?> tag) {
+    public boolean hasTag(final Class<? extends Tag> tag) {
       if (tag == CachedClosureInvoke.class) {
         return true;
       } else if (tag == CachedVirtualInvoke.class) {
         return false; // don't want that type of instrumentation here
       } else {
-        return super.isTaggedWith(tag);
+        return super.hasTag(tag);
       }
     }
   }