[GR-32001] Replace ReadCallerFrameNode by AlwaysInlinedMethodNode

PullRequest: truffleruby/3458

Author: eregon

CHANGELOG.md

@@ -38,6 +38,9 @@ Compatibility:
 * Implement `rb_ivar_foreach` to iterate over instance and class variables like in CRuby (#2701, @aardvark179).
 * Fix the absolute path of the main script after chdir (#2709, @eregon).
 * Fix exception for `Fiddle::Handle.new` with a missing library (#2714, @eregon).
+* Fix arguments implicit type conversion for `BasicObject#instance_eval`, `Module#class_eval`, `Module#module_eval`, `Module#define_method` (@andrykonchin).
+* Raise `ArgumentError` unconditionally when `Proc.new` is called without a block argument (@andrykonchin).
+
 
 Performance:
 

spec/ruby/core/basicobject/instance_eval_spec.rb

@@ -20,12 +20,18 @@
     a.instance_eval('self').equal?(a).should be_true
   end
 
-  it "expects a block with no arguments" do
-    -> { "hola".instance_eval }.should raise_error(ArgumentError)
+  it "raises an ArgumentError when no arguments and no block are given" do
+    -> { "hola".instance_eval }.should raise_error(ArgumentError, "wrong number of arguments (given 0, expected 1..3)")
   end
 
-  it "takes no arguments with a block" do
-    -> { "hola".instance_eval(4, 5) {|a,b| a + b } }.should raise_error(ArgumentError)
+  it "raises an ArgumentError when a block and normal arguments are given" do
+    -> { "hola".instance_eval(4, 5) {|a,b| a + b } }.should raise_error(ArgumentError, "wrong number of arguments (given 2, expected 0)")
+  end
+
+  it "raises an ArgumentError when more than 3 arguments are given" do
+    -> {
+      "hola".instance_eval("1 + 1", "some file", 0, "bogus")
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)")
   end
 
   it "yields the object to the block" do
@@ -185,4 +191,58 @@ def meth(arg); arg; end
 
     x.should == :value
   end
+
+  it "converts string argument with #to_str method" do
+    source_code = Object.new
+    def source_code.to_str() "1" end
+
+    a = BasicObject.new
+    a.instance_eval(source_code).should == 1
+  end
+
+  it "raises ArgumentError if returned value is not String" do
+    source_code = Object.new
+    def source_code.to_str() :symbol end
+
+    a = BasicObject.new
+    -> { a.instance_eval(source_code) }.should raise_error(TypeError, /can't convert Object to String/)
+  end
+
+  it "converts filename argument with #to_str method" do
+    filename = Object.new
+    def filename.to_str() "file.rb" end
+
+    err = begin
+            Object.new.instance_eval("raise", filename)
+          rescue => e
+            e
+          end
+    err.backtrace.first.split(":")[0].should == "file.rb"
+  end
+
+  it "raises ArgumentError if returned value is not String" do
+    filename = Object.new
+    def filename.to_str() :symbol end
+
+    -> { Object.new.instance_eval("raise", filename) }.should raise_error(TypeError, /can't convert Object to String/)
+  end
+
+  it "converts lineno argument with #to_int method" do
+    lineno = Object.new
+    def lineno.to_int() 15 end
+
+    err = begin
+            Object.new.instance_eval("raise", "file.rb", lineno)
+          rescue => e
+            e
+          end
+    err.backtrace.first.split(":")[1].should == "15"
+  end
+
+  it "raises ArgumentError if returned value is not Integer" do
+    lineno = Object.new
+    def lineno.to_int() :symbol end
+
+    -> { Object.new.instance_eval("raise", "file.rb", lineno) }.should raise_error(TypeError, /can't convert Object to Integer/)
+  end
 end

spec/ruby/core/module/define_method_spec.rb

@@ -219,18 +219,55 @@ class DefineMethodSpecClass
     o.block_test2.should == o
   end
 
+  it "raises TypeError if name cannot converted to String" do
+    -> {
+      Class.new { define_method(1001, -> {}) }
+    }.should raise_error(TypeError, /is not a symbol nor a string/)
+
+    -> {
+      Class.new { define_method([], -> {}) }
+    }.should raise_error(TypeError, /is not a symbol nor a string/)
+  end
+
+  it "converts non-String name to String with #to_str" do
+    obj = Object.new
+    def obj.to_str() "foo" end
+
+    new_class = Class.new { define_method(obj, -> { :called }) }
+    new_class.new.foo.should == :called
+  end
+
+  it "raises TypeError when #to_str called on non-String name returns non-String value" do
+    obj = Object.new
+    def obj.to_str() [] end
+
+    -> {
+      Class.new { define_method(obj, -> {}) }
+    }.should raise_error(TypeError, /can't convert Object to String/)
+  end
+
   it "raises a TypeError when the given method is no Method/Proc" do
     -> {
       Class.new { define_method(:test, "self") }
-    }.should raise_error(TypeError)
+    }.should raise_error(TypeError, "wrong argument type String (expected Proc/Method/UnboundMethod)")
 
     -> {
       Class.new { define_method(:test, 1234) }
-    }.should raise_error(TypeError)
+    }.should raise_error(TypeError, "wrong argument type Integer (expected Proc/Method/UnboundMethod)")
 
     -> {
       Class.new { define_method(:test, nil) }
-    }.should raise_error(TypeError)
+    }.should raise_error(TypeError, "wrong argument type NilClass (expected Proc/Method/UnboundMethod)")
+  end
+
+  it "uses provided Method/Proc even if block is specified" do
+    new_class = Class.new do
+      define_method(:test, -> { :method_is_called }) do
+        :block_is_called
+      end
+    end
+
+    new_class.new.test.should == :method_is_called
   end
 
   it "raises an ArgumentError when no block is given" do

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

spec/ruby/core/module/shared/class_eval.rb

@@ -55,40 +55,49 @@ def foo
   it "converts a non-string filename to a string using to_str" do
     (file = mock(__FILE__)).should_receive(:to_str).and_return(__FILE__)
     ModuleSpecs.send(@method, "1+1", file)
+
+    (file = mock(__FILE__)).should_receive(:to_str).and_return(__FILE__)
+    ModuleSpecs.send(@method, "1+1", file, 15)
   end
 
   it "raises a TypeError when the given filename can't be converted to string using to_str" do
     (file = mock('123')).should_receive(:to_str).and_return(123)
-    -> { ModuleSpecs.send(@method, "1+1", file) }.should raise_error(TypeError)
+    -> { ModuleSpecs.send(@method, "1+1", file) }.should raise_error(TypeError, /can't convert MockObject to String/)
   end
 
   it "converts non string eval-string to string using to_str" do
     (o = mock('1 + 1')).should_receive(:to_str).and_return("1 + 1")
     ModuleSpecs.send(@method, o).should == 2
+
+    (o = mock('1 + 1')).should_receive(:to_str).and_return("1 + 1")
+    ModuleSpecs.send(@method, o, "file.rb").should == 2
+
+    (o = mock('1 + 1')).should_receive(:to_str).and_return("1 + 1")
+    ModuleSpecs.send(@method, o, "file.rb", 15).should == 2
   end
 
   it "raises a TypeError when the given eval-string can't be converted to string using to_str" do
     o = mock('x')
-    -> { ModuleSpecs.send(@method, o) }.should raise_error(TypeError)
+    -> { ModuleSpecs.send(@method, o) }.should raise_error(TypeError, "no implicit conversion of MockObject into String")
 
     (o = mock('123')).should_receive(:to_str).and_return(123)
-    -> { ModuleSpecs.send(@method, o) }.should raise_error(TypeError)
+    -> { ModuleSpecs.send(@method, o) }.should raise_error(TypeError, /can't convert MockObject to String/)
   end
 
   it "raises an ArgumentError when no arguments and no block are given" do
-    -> { ModuleSpecs.send(@method) }.should raise_error(ArgumentError)
+    -> { ModuleSpecs.send(@method) }.should raise_error(ArgumentError, "wrong number of arguments (given 0, expected 1..3)")
   end
 
   it "raises an ArgumentError when more than 3 arguments are given" do
     -> {
       ModuleSpecs.send(@method, "1 + 1", "some file", 0, "bogus")
-    }.should raise_error(ArgumentError)
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)")
   end
 
   it "raises an ArgumentError when a block and normal arguments are given" do
     -> {
       ModuleSpecs.send(@method, "1 + 1") { 1 + 1 }
-    }.should raise_error(ArgumentError)
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 1, expected 0)")
   end
 
   # This case was found because Rubinius was caching the compiled

spec/tags/core/basicobject/instance_eval_tags.txt

@@ -1 +1,2 @@
 fails:BasicObject#instance_eval gets constants in the receiver if a string given
+fails:BasicObject#instance_eval raises an ArgumentError when more than 3 arguments are given

spec/tags/core/module/class_eval_tags.txt

@@ -1,2 +1,3 @@
 fails:Module#class_eval activates refinements from the eval scope
 fails:Module#class_eval activates refinements from the eval scope with block
+fails:Module#class_eval raises an ArgumentError when more than 3 arguments are given

spec/tags/core/module/module_eval_tags.txt

@@ -1,2 +1,3 @@
 fails:Module#module_eval activates refinements from the eval scope
 fails:Module#module_eval activates refinements from the eval scope with block
+fails:Module#module_eval raises an ArgumentError when more than 3 arguments are given

spec/tags/core/proc/new_tags.txt

@@ -1,5 +1 @@
 fails:Proc.new with an associated block raises a LocalJumpError when context of the block no longer exists
-fails:Proc.new without a block can be created if invoked from within a method with a block
-fails:Proc.new without a block can be created if invoked on a subclass from within a method with a block
-fails:Proc.new without a block can be create when called with no block
-fails:Proc.new without a block raises an ArgumentError when passed no block

spec/truffle/always_inlined_spec.rb

@@ -87,6 +87,42 @@
       }.should raise_error(ArgumentError) { |e| e.backtrace_locations[0].label.should == 'initialize_copy' }
     end
 
+    it "for Symbol#to_proc" do
+      -> {
+        :a.to_proc(:wrong)
+      }.should raise_error(ArgumentError) { |e| e.backtrace_locations[0].label.should == 'to_proc' }
+    end
+
+    it "for BasicObject#instance_eval" do
+      -> {
+        BasicObject.new.instance_eval
+      }.should raise_error(ArgumentError) { |e| e.backtrace_locations[0].label.should == 'instance_eval' }
+    end
+
+    it "for Module#class_eval" do
+      -> {
+        Module.new.class_eval
+      }.should raise_error(ArgumentError) { |e| e.backtrace_locations[0].label.should == 'class_eval' }
+    end
+
+    it "for Module#module_eval" do
+      -> {
+        Module.new.module_eval
+      }.should raise_error(ArgumentError) { |e| e.backtrace_locations[0].label.should == 'module_eval' }
+    end
+
+    it "for Module#define_method" do
+      -> {
+        Module.new.define_method(:wrong)
+      }.should raise_error(ArgumentError) { |e| e.backtrace_locations[0].label.should == 'define_method' }
+    end
+
+    it "for Module#instance_method" do
+      -> {
+        Module.new.instance_method([])
+      }.should raise_error(TypeError) { |e| e.backtrace_locations[0].label.should == 'instance_method' }
+    end
+
     guard -> { RUBY_ENGINE != "ruby" } do
       it "for #send" do
         -> {