Removed a support for self replacement.

Author: tzezula

truffle/src/com.oracle.truffle.api.library.test/src/com/oracle/truffle/api/library/test/GenerateLibraryTest.java

@@ -49,7 +49,6 @@
 
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.library.ExportLibrary;
 import com.oracle.truffle.api.library.ExportMessage;
 import com.oracle.truffle.api.library.GenerateLibrary;
@@ -622,6 +621,7 @@ public boolean isType(Object receiver) {
             return false;
         }
 
+        @ExpectError("The 'replacementMethod' attribute is only valid when 'replacementOf' is also specified.")
         @Abstract(replacementMethod = "isType")
         public Object replacedErr(Object receiver) {
             return receiver;
@@ -640,130 +640,6 @@ public boolean replace2(Object receiver) {
         }
     }
 
-    @GenerateLibrary
-    public abstract static class SelfReplacementsLibraryA extends Library {
-
-        public void noop(Object receiver) {
-        }
-
-        public boolean canComputeFactorial(Object receiver) {
-            return false;
-        }
-
-        @Abstract(ifExported = "canComputeFactorial")
-        public double multiply(Object receiver, double a, double b) {
-            throw new UnsupportedOperationException();
-        }
-
-        @Abstract(ifExportedAsWarning = "canComputeFactorial", replacementMethod = "factorialFixed")
-        public double factorial(Object receiver, int n) {
-            return n;
-        }
-
-        // Replaces factorial() only when factorial() is not exported
-        // and canComputeFactorial() is exported.
-        protected final double factorialFixed(Object receiver, int n) {
-            double f = n;
-            for (int i = 2; i < n; i++) {
-                f = multiply(receiver, f, i);
-            }
-            return f;
-        }
-    }
-
-    @GenerateLibrary
-    public abstract static class SelfReplacementsLibraryB extends Library {
-
-        public boolean canComputeFactorial(Object receiver) {
-            return false;
-        }
-
-        @Abstract(ifExported = "canComputeFactorial")
-        public double multiply(Object receiver, double a, double b) {
-            throw new UnsupportedOperationException();
-        }
-
-        @Abstract(ifExportedAsWarning = "canComputeFactorial", replacementMethod = "factorialFixed")
-        public double factorial(Object receiver, int n) {
-            return n;
-        }
-
-        // Replaces factorial() only when factorial() is not exported
-        // and canComputeFactorial() is exported.
-        @SuppressWarnings("static-method")
-        protected final double factorialFixed(Object receiver, int n, @CachedLibrary(limit = "2") SelfReplacementsLibraryB helperLibrary) {
-            if (helperLibrary.canComputeFactorial(n)) {
-                double f = helperLibrary.factorial(n, n);
-                return f;
-            } else {
-                return -n;
-            }
-        }
-    }
-
-    @ExportLibrary(SelfReplacementsLibraryA.class)
-    public static final class SelfReplacementsLibraryImplA1 extends Object {
-
-        // Only to prevent from warning: Exported library has no effect.
-        @ExportMessage
-        void noop() {
-        }
-
-        // canComputeFactorial() is not implemented,
-        // we have only the default impl of factorial() that returns `n`.
-    }
-
-    @ExportLibrary(SelfReplacementsLibraryA.class)
-    @SuppressWarnings("static-method")
-    public static final class SelfReplacementsLibraryImplA3 extends Object {
-
-        @ExportMessage
-        boolean canComputeFactorial() {
-            return true;
-        }
-
-        @ExportMessage
-        double multiply(double a, double b) {
-            return a * b;
-        }
-
-        @ExportMessage
-        double factorial(int n) {
-            return 2 * n;
-        }
-    }
-
-    @ExportLibrary(SelfReplacementsLibraryB.class)
-    @SuppressWarnings({"static-method", "truffle-abstract-export"})
-    public static final class SelfReplacementsLibraryImplB3 extends Object {
-
-        @ExportMessage
-        boolean canComputeFactorial() {
-            return true;
-        }
-
-        @ExportMessage
-        double multiply(double a, double b) {
-            return a * b;
-        }
-    }
-
-    @ExpectError({"The following message(s) of library SelfReplacementsLibraryB are abstract and should be exported using:%"})
-    @ExportLibrary(SelfReplacementsLibraryB.class)
-    @SuppressWarnings("static-method")
-    public static final class SelfReplacementsLibraryImplBErr extends Object {
-
-        @ExportMessage
-        boolean canComputeFactorial() {
-            return true;
-        }
-
-        @ExportMessage
-        double multiply(double a, double b) {
-            return a * b;
-        }
-    }
-
     interface ExportsType {
     }
 

truffle/src/com.oracle.truffle.api.library/src/com/oracle/truffle/api/library/GenerateLibrary.java

@@ -378,26 +378,20 @@
         String replacementOf() default "";
 
         /**
-         * Specifies a method that provides a replacement implementation for a message.
+         * Specifies a custom replacement method to handle delegation for a message declared with
+         * {@link #replacementOf()}.
          * <p>
-         * This annotation serves two related purposes, depending on how it is used:
-         * <ol>
-         * <li><b>Custom replacement for a {@link #replacementOf()} message:</b> Used when a
-         * deprecated message cannot be automatically delegated to its replacement due to
-         * differences in argument semantics, type conversions, or behavioral requirements. In this
-         * mode, the specified method implements the conversion or adaptation logic between the
-         * deprecated and replacement messages. The method must have a compatible signature and be
-         * accessible from the annotated message.</li>
-         * <li><b>Self-replacement method:</b> Used to provide a fallback implementation for the
-         * annotated message itself. The self-replacement method is invoked only when the annotated
-         * message is not exported, but one or more messages listed in {@link #ifExported()} or
-         * {@link #ifExportedAsWarning()} are exported. This allows non-exported messages to
-         * participate in message relationships without requiring explicit implementation by the
-         * user.</li>
-         * </ol>
+         * This attribute provides a way to manually implement delegation logic when automatic
+         * delegation from the deprecated message to its replacement cannot be generated correctly.
+         * Typical reasons include differences in argument semantics, necessary type conversions, or
+         * behavioral changes that cannot be inferred automatically.
+         * <p>
+         * This element is only valid when {@link #replacementOf()} is also set. Using it without
+         * {@code replacementOf} will result in a compilation error. The specified method must have
+         * a compatible signature and be accessible from the annotated message.
          *
          * <p>
-         * <b>Example - Custom replacement for {@link #replacementOf()}:</b>
+         * <b>Example:</b>
          *
          * <pre>
          * &#64;Abstract(ifExported = "isArray", replacementOf = "read(Object, int)", replacementMethod = "readLegacy")
@@ -411,44 +405,9 @@
          * }
          * </pre>
          *
-         * In this example, automatic conversion between {@code int} and {@code long} indices would
-         * yield incorrect results because the index is treated as unsigned. The custom
-         * {@code readLegacy} method therefore provides the correct delegation logic.
-         *
-         * <p>
-         * <b>Example - Self-replacement method:</b>
-         *
-         * <pre>
-         * &#64;GenerateLibrary
-         * public abstract static class SelfReplacementLibrary extends Library {
-         *
-         *     public boolean canComputeFactorial(Object receiver) {
-         *         return false;
-         *     }
-         *
-         *     &#64;Abstract(ifExported = "canComputeFactorial")
-         *     public double multiply(Object receiver, double a, double b) {
-         *         throw new UnsupportedOperationException();
-         *     }
-         *
-         *     &#64;Abstract(ifExportedAsWarning = "canComputeFactorial", replacementMethod = "factorialFixed")
-         *     public double factorial(Object receiver, int n) {
-         *         throw new UnsupportedOperationException();
-         *     }
-         *
-         *     // Used only when factorial() is not exported but canComputeFactorial() is.
-         *     protected final double factorialFixed(Object receiver, int n) {
-         *         double f = n;
-         *         for (int i = 2; i &lt; n; i++) {
-         *             f = multiply(receiver, f, i);
-         *         }
-         *         return f;
-         *     }
-         * }
-         * </pre>
-         *
-         * In this example, {@code factorialFixed} serves as a fallback implementation for
-         * {@code factorial()} when it is not exported but another related message is.
+         * In this example, the deprecated {@code read(Object, int)} message cannot be automatically
+         * delegated to {@code read(Object, long)} because the index must be treated as unsigned.
+         * The custom {@code readLegacy} method therefore provides the correct conversion logic.
          *
          * @see #replacementOf()
          * @since 25.1

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/library/ExportMessageData.java

@@ -62,10 +62,6 @@ public class ExportMessageData extends MessageContainer {
 
     private final Element element;
     private final AnnotationMirror annotation;
-    /**
-     * The type that serves as the target of a self replacement.
-     */
-    private TypeMirror selfReplacementTarget;
     private NodeData specializedNode;
 
     private boolean overriden;
@@ -126,25 +122,7 @@ public boolean isMethod() {
         return !isClass();
     }
 
-    public boolean isSelfReplacement() {
-        return selfReplacementTarget != null;
-    }
-
-    /**
-     * Marks this {@link ExportMessageData} as a self replacement.
-     * <p>
-     * The corresponding self replacement method is invoked as if it were static: the receiver is
-     * passed as the first argument, even though the method itself is not static. The target method
-     * owner is the <em>exported library instance</em>, not to the object that exports the library.
-     */
-    void setSelfReplacement() {
-        this.selfReplacementTarget = exports.getReceiverType();
-    }
-
     public TypeMirror getReceiverType() {
-        if (selfReplacementTarget != null) {
-            return selfReplacementTarget;
-        }
         if (element == null || exports.isExplicitReceiver()) {
             return exports.getReceiverType();
         }

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/library/ExportsParser.java

@@ -269,42 +269,6 @@ protected ExportsData parse(Element element, List<AnnotationMirror> elementMirro
                     replacedExport.addError(error);
                 }
             }
-            for (LibraryMessage message : library.getLibrary().getAllMethods()) {
-                ExecutableElement replacementMethod = message.getReplacementMethod();
-                if (replacementMethod != null && message.getReplacementOf() == null) {
-                    // Replacing this message, if not exported
-                    if (!exportedMessages.containsKey(message.getName())) {
-                        // Exported messages do not contain this message
-                        // We'll generate the replacement when some message from isExported is
-                        // exported
-                        boolean shouldReplace = false;
-                        for (LibraryMessage expMessage : message.getAbstractIfExportedAsWarning()) {
-                            ExportMessageData messageData = exportedMessages.get(expMessage.getName());
-                            if (messageData != null) {
-                                shouldReplace = true;
-                                break;
-                            }
-                        }
-                        if (shouldReplace) {
-                            // We need to add an @ExportMessage annotation for the generated message
-                            AnnotationMirror exportAnnotation = new CodeAnnotationMirror(ProcessorContext.getInstance().getTypes().ExportMessage);
-                            CodeExecutableElement replaceWithClone = CodeExecutableElement.clone(replacementMethod);
-                            if (library.isExplicitReceiver()) {
-                                replaceWithClone.getModifiers().add(STATIC);
-                            }
-                            Element enclosing = ElementUtils.castTypeElement(library.getReceiverType());
-                            replaceWithClone.setEnclosingElement(enclosing);
-                            replacementMethod = replaceWithClone;
-                            ExportMessageData exportData = new ExportMessageData(library, message, replacementMethod, exportAnnotation);
-                            exportData.setSelfReplacement();
-                            exportedElements.add(exportData);
-                            exportedMessages.put(message.getName(), exportData);
-                            Set<LibraryMessage> generatedNames = generatedLibraryMessages.computeIfAbsent(library, (lib) -> new HashSet<>());
-                            generatedNames.add(message);
-                        }
-                    }
-                }
-            }
         }
 
         /*
@@ -1376,13 +1340,9 @@ private void initializeExportedMethod(Map<String, NodeData> parsedNodeCache, Exp
             }
 
             boolean isStaticMethod = element.getModifiers().contains(Modifier.STATIC);
-            boolean isForcedStatic = exportedElement.isSelfReplacement();
-            boolean isStatic = isStaticMethod || isForcedStatic;
-            if (!isStatic) {
+            if (!isStaticMethod) {
                 element.getParameters().add(0, new CodeVariableElement(exportedElement.getReceiverType(), "this"));
                 element.getModifiers().add(Modifier.STATIC);
-            } else if (exportedElement.isSelfReplacement()) {
-                element.getParameters().set(0, new CodeVariableElement(exportedElement.getReceiverType(), "receiver"));
             }
 
             if (message.getName().equals("accepts")) {
@@ -1487,8 +1447,7 @@ private NodeData parseNode(Map<String, NodeData> parsedNodeCache, TypeElement no
         NodeData parsedNodeData = NodeParser.createExportParser(
                         exportedMessage.getExportsLibrary().getLibrary().getTemplateType().asType(),
                         exportedMessage.getExportsLibrary().getTemplateType(),
-                        exportedMessage.getExportsLibrary().hasExportDelegation(),
-                        !exportedMessage.isSelfReplacement()).parse(clonedType, false);
+                        exportedMessage.getExportsLibrary().hasExportDelegation()).parse(clonedType, false);
 
         parsedNodeCache.put(nodeTypeId, parsedNodeData);
 
@@ -1536,7 +1495,7 @@ private static boolean verifyMethodSignature(TypeElement type, LibraryMessage me
             return false;
         }
 
-        boolean explicitReceiver = exportedMethod.getModifiers().contains(Modifier.STATIC) || exportedMessage.isSelfReplacement();
+        boolean explicitReceiver = exportedMethod.getModifiers().contains(Modifier.STATIC);
         int paramOffset = !explicitReceiver ? 1 : 0;
         List<? extends VariableElement> expectedParameters = libraryMethod.getParameters().subList(paramOffset, libraryMethod.getParameters().size());
         List<? extends VariableElement> exportedParameters = exportedMethod.getParameters().subList(0, realParameterCount);
@@ -1567,7 +1526,7 @@ private static boolean verifyMethodSignature(TypeElement type, LibraryMessage me
             VariableElement exportedArg = exportedParameters.get(i);
             VariableElement libraryArg = expectedParameters.get(i);
             TypeMirror exportedArgType = exportedArg.asType();
-            TypeMirror libraryArgType = (explicitReceiver && !exportedMessage.isSelfReplacement() && i == 0) ? receiverType : libraryArg.asType();
+            TypeMirror libraryArgType = (explicitReceiver && i == 0) ? receiverType : libraryArg.asType();
             if (!typeEquals(exportedArgType, libraryArgType)) {
                 if (emitErrors) {
                     exportedMessage.addError(exportedArg, "Invalid parameter type. Expected '%s' but was '%s'. Expected signature:%n    %s",

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/library/LibraryParser.java

@@ -291,9 +291,7 @@ protected LibraryData parse(Element element, List<AnnotationMirror> mirrors) {
                 ExecutableElement replacementMethod = parseAbstractReplacementWith(message, replaced, abstractMirror, "replacementMethod", allMethods);
 
                 if (replacementMethod != null && replaced == null) {
-                    Set<LibraryMessage> ifExported = new HashSet<>(message.getAbstractIfExported());
-                    ifExported.addAll(message.getAbstractIfExportedAsWarning());
-                    message.setReplacementOf(null, replacementMethod);
+                    message.addError("The 'replacementMethod' attribute is only valid when 'replacementOf' is also specified.");
                 }
                 if (replaced != null) {
                     if (!replacedMessages.add(replaced)) {