[GR-19220] Add more comprehensive regexp instrumentation (#2430)

PullRequest: truffleruby/2890

Author: bjfish

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

@@ -9,13 +9,19 @@
  */
 package org.truffleruby.core.hash;
 
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.hash.library.EmptyHashStore;
+import org.truffleruby.core.hash.library.HashStoreLibrary;
 import org.truffleruby.core.numeric.BigIntegerOps;
 import org.truffleruby.core.numeric.RubyBignum;
 import org.truffleruby.language.RubyBaseNode;
 
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
 public abstract class HashOperations {
 
     public static RubyHash newEmptyHash(RubyContext context, RubyLanguage language) {
@@ -27,6 +33,22 @@ public static RubyHash newEmptyHash(RubyContext context, RubyLanguage language)
                 0);
     }
 
+    @TruffleBoundary
+    public static <K, V> RubyHash toRubyHash(RubyContext context, RubyLanguage language,
+            HashStoreLibrary hashStoreLibrary, Map<K, V> map, Optional<Function<K, Object>> keyMapper,
+            Optional<Function<V, Object>> valueMapper, boolean byIdentity) {
+        final RubyHash ret = newEmptyHash(context, language);
+
+        for (Map.Entry<K, V> entry : map.entrySet()) {
+            final Object key = keyMapper.isPresent() ? keyMapper.get().apply(entry.getKey()) : entry.getKey();
+            final Object value = valueMapper.isPresent() ? valueMapper.get().apply(entry.getValue()) : entry.getValue();
+
+            hashStoreLibrary.set(ret.store, ret, key, value, byIdentity);
+        }
+
+        return ret;
+    }
+
     // random number, stops hashes for similar values but different classes being the same, static because we want deterministic hashes
     public static final int BOOLEAN_CLASS_SALT = 55927484;
     public static final int INTEGER_CLASS_SALT = 1028093337;

src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java

@@ -110,6 +110,7 @@ protected RubyRegexp createRegexp(RopeWithEncoding[] strings) {
                         null,
                         preprocessed,
                         options,
+                        false,
                         this);
             } catch (DeferredRaiseException dre) {
                 throw dre.getException(getContext());

src/main/java/org/truffleruby/core/regexp/RegexpCacheKey.java

@@ -30,6 +30,18 @@ public RegexpCacheKey(Rope rope, RubyEncoding encoding, RegexpOptions options, H
         this.hashing = hashing;
     }
 
+    public Rope getRope() {
+        return rope;
+    }
+
+    public RubyEncoding getEncoding() {
+        return encoding;
+    }
+
+    public int getJoniOptions() {
+        return joniOptions;
+    }
+
     @Override
     public int hashCode() {
         return hashing.hash(rope.hashCode());
@@ -39,7 +51,7 @@ public int hashCode() {
     public boolean equals(Object o) {
         if (o instanceof RegexpCacheKey) {
             final RegexpCacheKey other = (RegexpCacheKey) o;
-            return rope.equals(other.rope) && encoding == other.encoding && joniOptions == other.joniOptions;
+            return encoding == other.encoding && joniOptions == other.joniOptions && rope.equals(other.getRope());
         } else {
             return false;
         }
@@ -48,6 +60,7 @@ public boolean equals(Object o) {
     @Override
     public String toString() {
         return '/' + RopeOperations.decodeOrEscapeBinaryRope(rope) + '/' +
-                RegexpOptions.fromJoniOptions(joniOptions).toOptionsString();
+                RegexpOptions.fromJoniOptions(joniOptions).toOptionsString() +
+                " -- " + RopeOperations.decodeOrEscapeBinaryRope(encoding.name.rope);
     }
 }

src/main/java/org/truffleruby/core/regexp/RegexpNodes.java

@@ -64,6 +64,7 @@ public static RubyRegexp create(RubyLanguage language,
                 null,
                 new RopeWithEncoding(setSource, setSourceEncoding),
                 regexpOptions,
+                false,
                 currentNode);
         return new RubyRegexp(regex, regexpOptions);
     }