[GR-19220] Implement UnboundMethod#original_name (#2874)

PullRequest: truffleruby/3658

Author: eregon

CHANGELOG.md

@@ -77,6 +77,7 @@ Compatibility:
 * Fix `Enumerable` methods `each_cons` and `each_slice` to return receiver (#2733, @horakivo)
 * `Module` methods `#private`, `#public`, `#protected`, `#module_function` now returns their arguments like in CRuby 3.1 (#2733, @horakivo)
 * `Kernel#exit!`, killing Fibers and internal errors do not run code in `ensure` clauses anymore, the same as CRuby (@eregon).
+* Implement `UnboundMethod#original_name` (@paracycle, @nirvdrum).
 
 Performance:
 

spec/tags/core/unboundmethod/original_name_tags.txt

@@ -73,7 +73,7 @@ protected Object mainUsing(Frame callerFrame, Object self, Object[] rubyArgs, Ro
 
         @TruffleBoundary
         private boolean isCalledFromTopLevel(InternalMethod callerMethod) {
-            final String name = callerMethod.getSharedMethodInfo().getBacktraceName();
+            final String name = callerMethod.getOriginalName();
             return name.equals("<main>") || name.startsWith("<top ");
         }
     }

src/main/java/org/truffleruby/core/MainNodes.java

@@ -19,6 +19,7 @@
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
 import org.truffleruby.core.Hashing;
 import org.truffleruby.core.array.RubyArray;
+import org.truffleruby.core.cast.ToSymbolNode;
 import org.truffleruby.core.encoding.Encodings;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.module.MethodLookupResult;
@@ -136,9 +137,8 @@ protected RubySymbol name(RubyUnboundMethod unboundMethod) {
 
     }
 
-    // TODO: We should have an additional method for this but we need to access it for #inspect.
-    @CoreMethod(names = "origin", visibility = Visibility.PRIVATE)
-    public abstract static class OriginNode extends CoreMethodArrayArgumentsNode {
+    @Primitive(name = "unbound_method_origin")
+    public abstract static class OriginNode extends PrimitiveArrayArgumentsNode {
 
         @Specialization
         protected RubyModule origin(RubyUnboundMethod unboundMethod) {
@@ -147,6 +147,17 @@ protected RubyModule origin(RubyUnboundMethod unboundMethod) {
 
     }
 
+    @CoreMethod(names = "original_name")
+    public abstract static class OriginalNameNode extends CoreMethodArrayArgumentsNode {
+
+        @Specialization
+        protected RubySymbol originalName(RubyUnboundMethod unboundMethod,
+                @Cached ToSymbolNode toSymbolNode) {
+            String originalName = unboundMethod.method.getOriginalName();
+            return toSymbolNode.execute(originalName);
+        }
+    }
+
     @CoreMethod(names = "owner")
     public abstract static class OwnerNode extends CoreMethodArrayArgumentsNode {
 

src/main/java/org/truffleruby/core/method/UnboundMethodNodes.java

@@ -286,7 +286,7 @@ public abstract static class ProcSymbolToProcSymbolNode extends PrimitiveArrayAr
         @Specialization
         protected Object symbolToProcSymbol(RubyProc proc) {
             if (proc.arity == SymbolNodes.ToProcNode.ARITY) {
-                return getSymbol(proc.getSharedMethodInfo().getBacktraceName());
+                return getSymbol(proc.getSharedMethodInfo().getOriginalName());
             } else {
                 return nil;
             }

src/main/java/org/truffleruby/core/proc/ProcNodes.java

@@ -151,7 +151,7 @@ public static String labelFor(TruffleStackTraceElement e) {
         RootNode root = e.getTarget().getRootNode();
         String label = root instanceof RubyRootNode
                 // Ruby backtraces do not include the class name for MRI compatibility.
-                ? ((RubyRootNode) root).getSharedMethodInfo().getBacktraceName()
+                ? ((RubyRootNode) root).getSharedMethodInfo().getOriginalName()
                 : root.getName();
         return label == null ? "<unknown>" : label;
     }

src/main/java/org/truffleruby/language/backtrace/Backtrace.java

@@ -195,6 +195,10 @@ public String getName() {
         return name;
     }
 
+    public String getOriginalName() {
+        return sharedMethodInfo.getOriginalName();
+    }
+
     public Visibility getVisibility() {
         return visibility;
     }

src/main/java/org/truffleruby/language/methods/InternalMethod.java

@@ -24,8 +24,10 @@
 import org.truffleruby.parser.OpenModule;
 import org.truffleruby.parser.ParserContext;
 
-/** {@link InternalMethod} objects are copied as properties such as visibility are changed. {@link SharedMethodInfo}
- * stores the state that does not change, such as where the method was defined. */
+/** SharedMethodInfo represents static information from the parser for either a method definition or a block like its
+ * name, SourceSection, etc. Such information is always "original" since it comes from the source as opposed to
+ * "aliased" (e.g. the aliased name of a method). In contrast, {@link InternalMethod} are runtime objects containing
+ * properties that change for a method. */
 public final class SharedMethodInfo {
 
     private final SourceSection sourceSection;
@@ -34,7 +36,7 @@ public final class SharedMethodInfo {
     private final Arity arity;
     /** The original name of the method. Does not change when aliased. Looks like "block in foo" or "block (2 levels) in
      * foo" for blocks. This is the name shown in backtraces: "from FILE:LINE:in `NAME'". */
-    private final String backtraceName;
+    private final String originalName;
     /** The "static" name of this method at parse time, such as "M::C#foo", "M::C.foo", "<module:Inner>", "block (2
      * levels) in M::C.foo" or "block (2 levels) in <module:Inner>". This name is used for tools. */
     private final String parseName;
@@ -48,16 +50,16 @@ public SharedMethodInfo(
             SourceSection sourceSection,
             LexicalScope staticLexicalScope,
             Arity arity,
-            String backtraceName,
+            String originalName,
             int blockDepth,
             String parseName,
             String notes,
             ArgumentDescriptor[] argumentDescriptors) {
-        assert blockDepth == 0 || backtraceName.startsWith("block ") : backtraceName;
+        assert blockDepth == 0 || originalName.startsWith("block ") : originalName;
         this.sourceSection = sourceSection;
         this.staticLexicalScope = staticLexicalScope;
         this.arity = arity;
-        this.backtraceName = backtraceName;
+        this.originalName = originalName;
         this.blockDepth = blockDepth;
         this.parseName = parseName;
         this.notes = notes;
@@ -93,7 +95,7 @@ public SharedMethodInfo withArity(Arity newArity) {
                 sourceSection,
                 staticLexicalScope,
                 newArity,
-                backtraceName,
+                originalName,
                 blockDepth,
                 parseName,
                 notes,
@@ -131,7 +133,7 @@ public boolean isBlock() {
 
     @TruffleBoundary
     public boolean isModuleBody() {
-        boolean isModuleBody = isModuleBody(getBacktraceName());
+        boolean isModuleBody = isModuleBody(getOriginalName());
         assert !(isModuleBody && isBlock()) : this;
         return isModuleBody;
     }
@@ -150,19 +152,20 @@ public static boolean isModuleBody(String name) {
         }
     }
 
-    public String getBacktraceName() {
-        return backtraceName;
+    /** See {@link #originalName} */
+    public String getOriginalName() {
+        return originalName;
     }
 
     /** Returns the method name on its own. Can start with "<" like "<module:Inner>" for module bodies. */
     public String getMethodName() {
-        return blockDepth == 0 ? backtraceName : notes;
+        return blockDepth == 0 ? originalName : notes;
     }
 
     /** More efficient than {@link #getMethodName()} when we know blockDepth == 0 */
     public String getMethodNameForNotBlock() {
         assert blockDepth == 0;
-        return backtraceName;
+        return originalName;
     }
 
     public String getParseName() {

src/main/java/org/truffleruby/language/methods/SharedMethodInfo.java

@@ -1079,7 +1079,7 @@ private ModuleBodyDefinition compileClassNode(SourceIndexLength sourceSection, P
                 environment.getReturnID());
 
         return new ModuleBodyDefinition(
-                environment.getSharedMethodInfo().getBacktraceName(),
+                environment.getSharedMethodInfo().getOriginalName(),
                 environment.getSharedMethodInfo(),
                 rootNode.getCallTarget(),
                 environment.getStaticLexicalScopeOrNull());
@@ -2006,14 +2006,14 @@ private RubyNode translateBlockLikeNode(IterParseNode node, boolean isStabbyLamb
         final int blockDepth = environment.getBlockDepth() + 1;
 
         // "block in foo"
-        String backtraceName = SharedMethodInfo.getBlockName(blockDepth, methodName);
+        String originalName = SharedMethodInfo.getBlockName(blockDepth, methodName);
         // "block (2 levels) in M::C.foo"
         String parseName = SharedMethodInfo.getBlockName(blockDepth, methodParent.getSharedMethodInfo().getParseName());
         final SharedMethodInfo sharedMethodInfo = new SharedMethodInfo(
                 sourceSection.toSourceSection(source),
                 environment.getStaticLexicalScopeOrNull(),
                 argsNode.getArity(),
-                backtraceName,
+                originalName,
                 blockDepth,
                 parseName,
                 methodName,

src/main/java/org/truffleruby/parser/BodyTranslator.java

@@ -10,7 +10,7 @@
 
 class UnboundMethod
   def inspect
-    Truffle::MethodOperations.inspect_method(self, origin, owner)
+    Truffle::MethodOperations.inspect_method(self, Primitive.unbound_method_origin(self), owner)
   end
   alias_method :to_s, :inspect