[GR-71154] Bytecode DSL: using assumptions causes compilation error.

PullRequest: graal/23555

Author: chumer

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

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.truffle.api.bytecode.test;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+import com.oracle.truffle.api.Assumption;
+import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.bytecode.BytecodeConfig;
+import com.oracle.truffle.api.bytecode.BytecodeParser;
+import com.oracle.truffle.api.bytecode.BytecodeRootNode;
+import com.oracle.truffle.api.bytecode.BytecodeRootNodes;
+import com.oracle.truffle.api.bytecode.GenerateBytecode;
+import com.oracle.truffle.api.bytecode.Operation;
+import com.oracle.truffle.api.dsl.Bind;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.FrameDescriptor;
+
+public class GR71154Test {
+
+    private static final BytecodeDSLTestLanguage LANGUAGE = null;
+
+    private static TestAssumptionsRootNode parse(BytecodeParser<TestAssumptionsRootNodeGen.Builder> builder) {
+        BytecodeRootNodes<TestAssumptionsRootNode> nodes = TestAssumptionsRootNodeGen.create(LANGUAGE, BytecodeConfig.DEFAULT, builder);
+        return nodes.getNode(0);
+    }
+
+    @Test
+    public void testAssumptionInvalidationRemovesSpecialization() {
+        TestAssumptionsRootNode root = parse(b -> {
+            b.beginRoot();
+            b.beginReturn();
+            b.beginLongConsumer();
+            b.emitLoadArgument(0);
+            b.endLongConsumer();
+            b.endReturn();
+            b.endRoot();
+        });
+
+        assertEquals(1L, root.getCallTarget().call(1L));
+        assertEquals(2L, root.getCallTarget().call(2L));
+
+        root.assumption.invalidate();
+
+        assertEquals(2L, root.getCallTarget().call(1L));
+        assertEquals(6L, root.getCallTarget().call(3L));
+    }
+
+    @GenerateBytecode(languageClass = BytecodeDSLTestLanguage.class)
+    abstract static class TestAssumptionsRootNode extends DebugBytecodeRootNode implements BytecodeRootNode {
+
+        final Assumption assumption = Truffle.getRuntime().createAssumption();
+
+        protected TestAssumptionsRootNode(BytecodeDSLTestLanguage language, FrameDescriptor frameDescriptor) {
+            super(language, frameDescriptor);
+        }
+
+        @Operation
+        static final class LongConsumer {
+
+            @Specialization(assumptions = "root.assumption")
+            public static long produceOptimized(long value,
+                            @SuppressWarnings("unused") @Bind TestAssumptionsRootNode root) {
+                return value;
+            }
+
+            @Specialization(replaces = "produceOptimized")
+            public static long produceGeneric(long value) {
+                return value * 2;
+            }
+        }
+    }
+}

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/FlatNodeGenFactory.java

@@ -5930,9 +5930,13 @@ private CodeTree createRemoveThis(CodeTreeBuilder parent, FrameState outerFrameS
             if (useSpecializationClass) {
                 method.addParameter(new CodeVariableElement(specializationType, specializationLocalName));
             }
+            for (VariableElement arg : plugs.additionalArguments()) {
+                method.addParameter(arg);
+            }
             CodeTreeBuilder builder = method.createBuilder();
             if (!useSpecializationClass || !specialization.hasMultipleInstances()) {
                 // single instance remove
+                builder.tree(multiState.createForceLoad(frameState, StateQuery.create(SpecializationActive.class, specialization)));
                 builder.tree((multiState.createSet(frameState, null, StateQuery.create(SpecializationActive.class, specialization), false, true)));
                 plugs.notifySpecialize(this, builder, frameState, specialization);
                 if (useSpecializationClass) {
@@ -6000,6 +6004,9 @@ private CodeTree createRemoveThis(CodeTreeBuilder parent, FrameState outerFrameS
         if (useSpecializationClass) {
             builder.string(specializationLocalName);
         }
+        for (VariableElement arg : plugs.additionalArguments()) {
+            builder.variable(arg);
+        }
         builder.end().end();
         builder.tree(createCallExecuteAndSpecialize(builder, forType, frameState));
         return builder.build();