Fix: stop overriding countsTowardsStackTraceLimit.

The default `countsTowardsStackTraceLimit` impl invokes `isInternal`, which used to force materialization of sources in the Bytecode DSL.
To prevent this eager materialization, we overrode `countsTowardsStackTraceLimit` to `true` when the user did not implement it.
This is incorrect: the user could override `isInternal`, but the `countsTowardsStackTraceLimit` override would ignore it.
Since eager materialization no longer occurs, we can stop generating an override for this method.

Author: DSouzaM

truffle/src/com.oracle.truffle.api.bytecode.test/src/com/oracle/truffle/api/bytecode/test/StackTraceTest.java

@@ -47,8 +47,10 @@
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 import org.graalvm.polyglot.Context;
@@ -337,6 +339,40 @@ public void testValidateResumedFrameInstances() {
         }
     }
 
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testCaptureWithLimit() {
+        int depth = run.depth;
+        assumeTrue("Cannot test stack trace limits with less than two frames in the trace.", depth >= 2);
+        int stackTraceLimit = depth / 2;
+        StackTraceTestRootNode[] nodes = chainCalls(depth, b -> {
+            b.beginRoot();
+            b.emitDummy();
+            b.beginReturn();
+            b.emitCaptureStackWithLimit(stackTraceLimit);
+            b.endReturn();
+            b.endRoot();
+        }, true, false);
+        StackTraceTestRootNode outer = nodes[nodes.length - 1];
+
+        // First, invoke as usual. The stack trace should consist of the top stackTraceLimit frames.
+        StackTraceTestRootNode[] topFrames = Arrays.copyOfRange(nodes, 0, stackTraceLimit);
+        for (int repeat = 0; repeat < REPEATS; repeat++) {
+            List<TruffleStackTraceElement> elements = (List<TruffleStackTraceElement>) outer.getCallTarget().call();
+            assertStackElements(topFrames, elements, "c.CaptureStackWithLimit", "c.Call", false);
+        }
+
+        // Next, mark the top (depth - stackTraceLimit) roots as internal so they do not "count".
+        for (int i = 0; i < depth - stackTraceLimit; i++) {
+            nodes[i].internal = true;
+        }
+        // Since they do not "count", we should capture every frame.
+        for (int repeat = 0; repeat < REPEATS; repeat++) {
+            List<TruffleStackTraceElement> elements = (List<TruffleStackTraceElement>) outer.getCallTarget().call();
+            assertStackElements(nodes, elements, "c.CaptureStackWithLimit", "c.Call", false);
+        }
+    }
+
     private void assertStackElements(StackTraceTestRootNode[] nodes, List<TruffleStackTraceElement> elements, String firstElementInstruction, String chainedElementInstruction, boolean checkSources) {
         assertEquals(nodes.length, elements.size());
         assertStackElement(elements.get(0), nodes[0], firstElementInstruction, checkSources);
@@ -515,6 +551,7 @@ protected StackTraceTestRootNode(BytecodeDSLTestLanguage language, FrameDescript
 
         public String name;
         public int depth;
+        public boolean internal = false;
 
         public void setName(String name) {
             this.name = name;
@@ -525,6 +562,11 @@ public String getName() {
             return name;
         }
 
+        @Override
+        public boolean isInternal() {
+            return internal;
+        }
+
         @Override
         public String toString() {
             return "StackTest[name=" + name + ", depth=" + depth + "]";
@@ -606,6 +648,17 @@ static Object doDefault(@Bind Node node) {
             }
         }
 
+        @Operation(storeBytecodeIndex = true)
+        @ConstantOperand(type = int.class, name = "stackTraceLimit")
+        static final class CaptureStackWithLimit {
+
+            @Specialization
+            static Object doDefault(int stackTraceLimit, @Bind Node node) {
+                TestException ex = new TestException(node, stackTraceLimit);
+                return TruffleStackTrace.getStackTrace(ex);
+            }
+        }
+
         @SuppressWarnings("truffle-interpreted-performance")
         @Operation(storeBytecodeIndex = true)
         // The parser should populate this array after parsing. This is a hack to expose the roots.
@@ -689,6 +742,10 @@ static class TestException extends AbstractTruffleException {
             super(resolveLocation(location));
         }
 
+        TestException(Node location, int stackTraceElementLimit) {
+            super(null, null, stackTraceElementLimit, resolveLocation(location));
+        }
+
         private static Node resolveLocation(Node location) {
             if (location == null) {
                 return null;

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/bytecode/generator/BytecodeRootNodeElement.java

@@ -500,7 +500,6 @@ final class BytecodeRootNodeElement extends CodeTypeElement {
         this.add(createInvalidate());
 
         this.add(createGetRootNodes());
-        this.addOptional(createCountTowardsStackTraceLimit());
         this.add(createGetSourceSection());
         CodeExecutableElement translateStackTraceElement = this.addOptional(createTranslateStackTraceElement());
         if (translateStackTraceElement != null) {
@@ -1137,28 +1136,6 @@ private CodeExecutableElement createCreateStackTraceElement() {
         return ex;
     }
 
-    private CodeExecutableElement createCountTowardsStackTraceLimit() {
-        ExecutableElement executable = ElementUtils.findOverride(ElementUtils.findMethod(types.RootNode, "countsTowardsStackTraceLimit"), model.templateType);
-        if (executable != null) {
-            return null;
-        }
-        CodeExecutableElement ex = overrideImplementRootNodeMethod(model, "countsTowardsStackTraceLimit");
-        if (ex.getModifiers().contains(Modifier.FINAL)) {
-            // already overridden by the root node.
-            return null;
-        }
-
-        ex.getModifiers().remove(Modifier.ABSTRACT);
-        ex.getModifiers().add(Modifier.FINAL);
-        CodeTreeBuilder b = ex.createBuilder();
-        /*
-         * We do override with false by default to avoid materialization of sources during stack
-         * walking.
-         */
-        b.returnTrue();
-        return ex;
-    }
-
     private CodeExecutableElement createGetSourceSection() {
         CodeExecutableElement ex = GeneratorUtils.override(types.Node, "getSourceSection");
         CodeTreeBuilder b = ex.createBuilder();