Don't use ReadCallerFrameNode in ModuleNodes.InstanceMethodNode class

Author: andrykonchin

spec/ruby/core/module/instance_method_spec.rb

@@ -51,14 +51,36 @@
     @mod_um.inspect.should =~ /\bModuleSpecs::InstanceMethChild\b/
   end
 
-  it "raises a TypeError if not passed a symbol" do
-    -> { Object.instance_method([]) }.should raise_error(TypeError)
-    -> { Object.instance_method(0)  }.should raise_error(TypeError)
+  it "raises a TypeError if the given name is not a String/Symbol" do
+    -> { Object.instance_method([]) }.should raise_error(TypeError, /is not a symbol nor a string/)
+    -> { Object.instance_method(0) }.should raise_error(TypeError, /is not a symbol nor a string/)
+    -> { Object.instance_method(nil) }.should raise_error(TypeError, /is not a symbol nor a string/)
+    -> { Object.instance_method(mock('x')) }.should raise_error(TypeError, /is not a symbol nor a string/)
   end
 
-  it "raises a TypeError if the given name is not a string/symbol" do
-    -> { Object.instance_method(nil)       }.should raise_error(TypeError)
-    -> { Object.instance_method(mock('x')) }.should raise_error(TypeError)
+  it "accepts String name argument" do
+    method = ModuleSpecs::InstanceMeth.instance_method(:foo)
+    method.should be_kind_of(UnboundMethod)
+  end
+
+  it "accepts Symbol name argument"  do
+    method = ModuleSpecs::InstanceMeth.instance_method("foo")
+    method.should be_kind_of(UnboundMethod)
+  end
+
+  it "converts non-String name by calling #to_str method" do
+    obj = Object.new
+    def obj.to_str() "foo" end
+
+    method = ModuleSpecs::InstanceMeth.instance_method(obj)
+    method.should be_kind_of(UnboundMethod)
+  end
+
+  it "raises TypeError when passed non-String name and #to_str returns non-String value" do
+    obj = Object.new
+    def obj.to_str() [] end
+
+    -> { ModuleSpecs::InstanceMeth.instance_method(obj) }.should raise_error(TypeError, /can't convert Object to String/)
   end
 
   it "raises a NameError if the method has been undefined" do

src/main/java/org/truffleruby/core/module/ModuleNodes.java

@@ -89,7 +89,6 @@
 import org.truffleruby.language.WarningNode.UncachedWarningNode;
 import org.truffleruby.language.arguments.ArgumentsDescriptor;
 import org.truffleruby.language.arguments.EmptyArgumentsDescriptor;
-import org.truffleruby.language.arguments.ReadCallerFrameNode;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.backtrace.BacktraceFormatter;
 import org.truffleruby.language.constants.ConstantEntry;
@@ -1948,22 +1947,18 @@ protected RubyArray instanceMethods(RubyModule module, boolean includeAncestors)
         }
     }
 
-    @CoreMethod(names = "instance_method", required = 1)
-    @NodeChild(value = "module", type = RubyNode.class)
-    @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class)
-    public abstract static class InstanceMethodNode extends CoreMethodNode {
-        @Child private ReadCallerFrameNode readCallerFrame = ReadCallerFrameNode.create();
-
-        @CreateCast("name")
-        protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) {
-            return NameToJavaStringNode.create(name);
-        }
+    @GenerateUncached
+    @CoreMethod(names = "instance_method", required = 1, alwaysInlined = true)
+    public abstract static class InstanceMethodNode extends AlwaysInlinedMethodNode {
 
         @Specialization
-        protected RubyUnboundMethod instanceMethod(VirtualFrame frame, RubyModule module, String name,
+        protected RubyUnboundMethod instanceMethod(
+                Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+                @Cached NameToJavaStringNode nameToJavaStringNode,
                 @Cached BranchProfile errorProfile) {
-            final Frame callerFrame = readCallerFrame.execute(frame);
+            needCallerFrame(callerFrame, target);
             final DeclarationContext declarationContext = RubyArguments.getDeclarationContext(callerFrame);
+            final String name = nameToJavaStringNode.execute(RubyArguments.getArgument(rubyArgs, 0));
 
             // TODO(CS, 11-Jan-15) cache this lookup
             final InternalMethod method = ModuleOperations.lookupMethodUncached(module, name, declarationContext);