[GR-26646] Avoid dispatch to #hash method for Hash lookups where compatible

PullRequest: truffleruby/2065

Author: bjfish

spec/ruby/core/hash/element_reference_spec.rb

@@ -117,4 +117,18 @@
     key = HashSpecs::KeyWithPrivateHash.new
     { key => 42 }[key].should == 42
   end
+
+  it "does not dispatch to hash for Boolean, Integer, Float, String, or Symbol" do
+    code = <<-EOC
+      load '#{fixture __FILE__, "name.rb"}'
+      hash = { true => 42, false => 42, 1 => 42, 2.0 => 42, "hello" => 42, :ok => 42 }
+      [true, false, 1, 2.0, "hello", :ok].each do |value|
+        raise "incorrect value" unless hash[value] == 42
+      end
+      puts "Ok."
+    EOC
+    result = ruby_exe(code, args: "2>&1")
+    result.should == "Ok.\n"
+  end
+
 end

spec/ruby/core/hash/fixtures/name.rb

@@ -0,0 +1,30 @@
+class TrueClass
+  def hash
+    raise "TrueClass#hash should not be called"
+  end
+end
+class FalseClass
+  def hash
+    raise "FalseClass#hash should not be called"
+  end
+end
+class Integer
+  def hash
+    raise "Integer#hash should not be called"
+  end
+end
+class Float
+  def hash
+    raise "Float#hash should not be called"
+  end
+end
+class String
+  def hash
+    raise "String#hash should not be called"
+  end
+end
+class Symbol
+  def hash
+    raise "Symbol#hash should not be called"
+  end
+end

spec/ruby/core/hash/shared/store.rb

@@ -95,4 +95,21 @@ def key.reverse() "bar" end
       hash.each { hash.send(@method, 1, :foo) }
       hash.should == {1 => :foo, 3 => 4, 5 => 6}
   end
+
+  it "does not dispatch to hash for Boolean, Integer, Float, String, or Symbol" do
+    code = <<-EOC
+      load '#{fixture __FILE__, "name.rb"}'
+      hash = {}
+      [true, false, 1, 2.0, "hello", :ok].each do |value|
+        hash[value] = 42
+        raise "incorrect value" unless hash[value] == 42
+        hash[value] = 43
+        raise "incorrect value" unless hash[value] == 43
+      end
+      puts "OK"
+      puts hash.size
+    EOC
+    result = ruby_exe(code, args: "2>&1")
+    result.should == "OK\n6\n"
+  end
 end

spec/tags/core/hash/element_reference_tags.txt

@@ -0,0 +1 @@
+slow:Hash#[] does not dispatch to hash for Boolean, Integer, Float, String, or Symbol

spec/tags/core/hash/element_set_tags.txt

@@ -0,0 +1 @@
+slow:Hash#[]= does not dispatch to hash for Boolean, Integer, Float, String, or Symbol

spec/tags/core/hash/store_tags.txt

@@ -0,0 +1 @@
+slow:Hash#store does not dispatch to hash for Boolean, Integer, Float, String, or Symbol

spec/truffle/launcher_spec.rb

@@ -315,7 +315,7 @@ def should_print_full_java_command(options, env: {})
     out = ruby_exe("puts 14.hash", options: "--experimental-options --hashing-deterministic", args: "2>&1")
     check_status_or_print(out)
     out.should include("SEVERE: deterministic hashing is enabled - this may make you vulnerable to denial of service attacks")
-    out.should include("7141275149799654099")
+    out.should include("3412061130696242594")
   end
 
   it "prints help containing runtime options" do

src/main/java/org/truffleruby/RubyContext.java

@@ -62,7 +62,7 @@
 import org.truffleruby.interop.InteropManager;
 import org.truffleruby.language.CallStackManager;
 import org.truffleruby.language.LexicalScope;
-import org.truffleruby.language.RubyNode;
+import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.SafepointManager;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.backtrace.BacktraceFormatter;
@@ -524,7 +524,7 @@ public TruffleLanguage.Env getEnv() {
     }
 
     /** Hashing for a RubyNode, the seed should only be used for a Ruby-level #hash method */
-    public Hashing getHashing(RubyNode node) {
+    public Hashing getHashing(RubyBaseNode node) {
         return hashing;
     }
 

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -38,7 +38,7 @@
 import org.truffleruby.core.encoding.RubyEncoding;
 import org.truffleruby.core.exception.ErrnoErrorNode;
 import org.truffleruby.core.exception.ExceptionOperations;
-import org.truffleruby.core.hash.HashNode;
+import org.truffleruby.core.hash.HashingNodes;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.module.MethodLookupResult;
 import org.truffleruby.core.module.ModuleNodes.ConstSetNode;
@@ -945,16 +945,10 @@ protected Object rbSysErrFail(int errno, RubyString message,
     @CoreMethod(names = "rb_hash", onSingleton = true, required = 1)
     public abstract static class RbHashNode extends CoreMethodArrayArgumentsNode {
 
-        @Child private HashNode hash;
-
         @Specialization
-        protected Object rbHash(Object object) {
-            if (hash == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                hash = insert(new HashNode());
-            }
-
-            return hash.hash(object, false);
+        protected int rbHash(Object object,
+                @Cached HashingNodes.ToHashByHashCode toHashByHashCode) {
+            return toHashByHashCode.execute(object);
         }
     }
 

src/main/java/org/truffleruby/core/hash/HashLiteralNode.java

@@ -64,7 +64,7 @@ public Object execute(VirtualFrame frame) {
 
     public static class SmallHashLiteralNode extends HashLiteralNode {
 
-        @Child private HashNode hashNode;
+        @Child private HashingNodes.ToHashByHashCode hashNode;
         @Child private DispatchNode equalNode;
         @Child private BooleanCastNode booleanCastNode;
         @Child private FreezeHashKeyIfNeededNode freezeHashKeyIfNeededNode = FreezeHashKeyIfNeededNodeGen.create();
@@ -124,9 +124,9 @@ public Object execute(VirtualFrame frame) {
         private int hash(Object key) {
             if (hashNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
-                hashNode = insert(new HashNode());
+                hashNode = insert(HashingNodes.ToHashByHashCode.create());
             }
-            return hashNode.hash(key, false);
+            return hashNode.execute(key);
         }
 
         private boolean callEqual(Object receiver, Object key) {