[GR-18163] Fix the --regexp-instrument-creation option

PullRequest: truffleruby/2841

Author: eregon

spec/tags/truffle/options/regex_instrument_creation_tags.txt

@@ -0,0 +1 @@
+slow:The --regexp-instrument-creation option works

spec/truffle/options/regex_instrument_creation_spec.rb

@@ -0,0 +1,17 @@
+# Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. This
+# code is released under a tri EPL/GPL/LGPL license. You can use it,
+# redistribute it and/or modify it under the terms of the:
+#
+# Eclipse Public License version 2.0, or
+# GNU General Public License version 2, or
+# GNU Lesser General Public License version 2.1.
+
+require_relative '../../ruby/spec_helper'
+
+describe "The --regexp-instrument-creation option" do
+  it "works" do
+    out = ruby_exe("/abc/i", options: "--experimental-options --regexp-instrument-creation")
+    out.should.include? "Regular expression statistics"
+    out.should.include? "1    /abc/i"
+  end
+end

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

@@ -127,11 +127,10 @@ private static Regex getRegexpFromCache(RubyContext context, RopeBuilder bytes,
         }
 
         final Rope rope = RopeOperations.ropeFromRopeBuilder(bytes);
-        final int joniOptions = options.toJoniOptions();
         final RegexpCacheKey cacheKey = new RegexpCacheKey(
                 rope,
                 encoding,
-                joniOptions,
+                options,
                 context.getHashing(context.getRegexpCache()));
 
         final Regex regex = context.getRegexpCache().get(cacheKey);

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

@@ -13,20 +13,20 @@
 import org.truffleruby.core.encoding.RubyEncoding;
 import org.truffleruby.core.rope.NativeRope;
 import org.truffleruby.core.rope.Rope;
-import org.truffleruby.parser.ReOptions;
+import org.truffleruby.core.rope.RopeOperations;
 
 public final class RegexpCacheKey {
 
     private final Rope rope;
     private final RubyEncoding encoding;
-    private final int options;
+    private final int joniOptions;
     private final Hashing hashing;
 
-    public RegexpCacheKey(Rope rope, RubyEncoding encoding, int options, Hashing hashing) {
+    public RegexpCacheKey(Rope rope, RubyEncoding encoding, RegexpOptions options, Hashing hashing) {
         assert !(rope instanceof NativeRope);
         this.rope = rope;
         this.encoding = encoding;
-        this.options = options;
+        this.joniOptions = options.toJoniOptions();
         this.hashing = hashing;
     }
 
@@ -39,25 +39,15 @@ 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 && options == other.options;
+            return rope.equals(other.rope) && encoding == other.encoding && joniOptions == other.joniOptions;
         } else {
             return false;
         }
     }
 
     @Override
     public String toString() {
-        StringBuilder builder = new StringBuilder();
-        builder.append('/').append(rope.toString()).append('/');
-        if ((options & ReOptions.RE_OPTION_MULTILINE) != 0) {
-            builder.append('m');
-        }
-        if ((options & ReOptions.RE_OPTION_IGNORECASE) != 0) {
-            builder.append('i');
-        }
-        if ((options & ReOptions.RE_OPTION_EXTENDED) != 0) {
-            builder.append('x');
-        }
-        return builder.toString();
+        return '/' + RopeOperations.decodeOrEscapeBinaryRope(rope) + '/' +
+                RegexpOptions.fromJoniOptions(joniOptions).toOptionsString();
     }
 }

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

@@ -654,7 +654,7 @@ protected void instrument(RubyRegexp regexp, Object string, boolean fromStart) {
             RubyEncoding enc = RubyStringLibrary.getUncached().getEncoding(string);
             RegexpOptions options = regexp.options;
             MatchInfo matchInfo = new MatchInfo(
-                    new RegexpCacheKey(source, enc, options.toJoniOptions(), Hashing.NO_SEED),
+                    new RegexpCacheKey(source, enc, options, Hashing.NO_SEED),
                     fromStart);
             ConcurrentOperations.getOrCompute(MATCHED_REGEXPS, matchInfo, x -> new AtomicInteger()).incrementAndGet();
         }
@@ -730,7 +730,7 @@ public static Regex compile(RubyLanguage language, RubyDeferredWarnings rubyDefe
             final RegexpCacheKey key = new RegexpCacheKey(
                     bytes.getRope(),
                     enc,
-                    options.toJoniOptions(),
+                    options,
                     Hashing.NO_SEED);
             ConcurrentOperations.getOrCompute(COMPILED_REGEXPS, key, x -> new AtomicInteger()).incrementAndGet();
         }

src/main/java/org/truffleruby/core/rope/RopeOperations.java

@@ -205,24 +205,24 @@ public static String decodeOrEscapeBinaryRope(Rope rope, byte[] bytes) {
         if (rope.isAsciiOnly() || rope.getEncoding() != ASCIIEncoding.INSTANCE) {
             return decodeRopeSegment(rope, bytes, 0, bytes.length);
         } else {
-            // A Rope with BINARY encoding cannot be converted faithfully to a Java String.
-            // (ISO_8859_1 would just show random characters for bytes above 128)
-            // Therefore we convert non-US-ASCII characters to "\xNN".
-            // MRI Symbol#inspect for binary symbols is similar: "\xff".b.to_sym => :"\xFF"
-
-            final StringBuilder builder = new StringBuilder(rope.byteLength());
+            return escapeBinaryRope(bytes);
+        }
+    }
 
-            for (int i = 0; i < bytes.length; i++) {
-                final byte c = bytes[i];
-                if (c >= 0) { // US-ASCII character
-                    builder.append((char) (c & 0xFF));
-                } else {
-                    builder.append("\\x").append(String.format("%02X", c & 0xFF));
-                }
+    private static String escapeBinaryRope(byte[] bytes) {
+        // A Rope with BINARY encoding cannot be converted faithfully to a Java String.
+        // (ISO_8859_1 would just show random characters for bytes above 128)
+        // Therefore we convert non-US-ASCII characters to "\xNN".
+        // MRI Symbol#inspect for binary symbols is similar: "\xff".b.to_sym => :"\xFF"
+        final StringBuilder builder = new StringBuilder(bytes.length);
+        for (final byte c : bytes) {
+            if (c >= 0) { // US-ASCII character
+                builder.append((char) (c & 0xFF));
+            } else {
+                builder.append("\\x").append(String.format("%02X", c & 0xFF));
             }
-
-            return builder.toString();
         }
+        return builder.toString();
     }
 
     public static String decodeRope(Rope value) {
@@ -242,9 +242,15 @@ private static String decodeRopeSegment(Rope value, byte[] bytes, int byteOffset
         }
     }
 
+    /** This method has no side effects, because it does not even have access to the Rope - for debugging only. */
     @TruffleBoundary
     public static String decode(Encoding encoding, byte[] bytes) {
-        return decode(EncodingManager.charsetForEncoding(encoding), bytes, 0, bytes.length);
+        if (encoding == ASCIIEncoding.INSTANCE) {
+            return escapeBinaryRope(bytes);
+        } else {
+            final Charset charset = EncodingManager.charsetForEncoding(encoding);
+            return decode(charset, bytes, 0, bytes.length);
+        }
     }
 
     private static String decode(Charset charset, byte[] bytes, int byteOffset, int byteLength) {