Merge pull request #3656 from HenryRLee:regexUnicode

PiperOrigin-RevId: 326105468

Author: copybara-github

src/com/google/javascript/jscomp/regex/RegExpTree.java

@@ -399,7 +399,7 @@ private RegExpTree parseCharset() {
         CharRanges ieExplicits = CharRanges.EMPTY;
         while (pos < limit && pattern.charAt(pos) != ']') {
           char ch = pattern.charAt(pos);
-          char start;
+          int start;
           if (ch == '\\') {
             ++pos;
             char possibleGroupName = pattern.charAt(pos);
@@ -414,7 +414,7 @@ private RegExpTree parseCharset() {
             start = ch;
             ++pos;
           }
-          char end = start;
+          int end = start;
           if (pos + 1 < limit && pattern.charAt(pos) == '-'
               && pattern.charAt(pos + 1) != ']') {
             ++pos;
@@ -459,20 +459,22 @@ private RegExpTree parseCharset() {
       }
 
       /**
-       * Parses an escape to a code point.
-       * Some of the characters parsed here have special meanings in various
-       * contexts, so contexts must filter those instead.
-       * E.g. '\b' means a different thing inside a charset than without.
+       * Parses an escape to a code point. Some of the characters parsed here have special meanings
+       * in various contexts, so contexts must filter those instead. E.g. '\b' means a different
+       * thing inside a charset than without.
        */
-      private char parseEscapeChar() {
+      private int parseEscapeChar() {
         char ch = pattern.charAt(pos++);
         switch (ch) {
           case 'b': return '\b';
           case 'f': return '\f';
           case 'n': return '\n';
           case 'r': return '\r';
           case 't': return '\t';
-          case 'u': return parseHex(4);
+          case 'u':
+            return (flags.contains("u") && pos < limit && pattern.charAt(pos) == '{')
+                ? parseBracedUnicodeEscape()
+                : parseHex(4);
           case 'v': return '\u000b';
           case 'x': return parseHex(2);
           default:
@@ -599,18 +601,23 @@ private RegExpTree parseEscape() {
             ++pos;
             return new Charset(charGroup, CharRanges.EMPTY);
           }
-          return new Text("" + parseEscapeChar());
+          return new Text(new String(Character.toChars(parseEscapeChar())));
         }
       }
 
-      /**
-       * Parses n hex digits to a code-unit.
-       */
-      private char parseHex(int n) {
+      /** Parses n hex digits to a code-unit. */
+      private int parseHex(int n) {
         if (pos + n > limit) {
           throw new IllegalArgumentException(
               "Abbreviated hex escape " + pattern.substring(pos));
         }
+        if (n > 7) {
+          // We need to guard the MSB to prevent overflow.
+          throw new IllegalArgumentException(
+              "Cannot parse hexadecimal encoding wider than 28 bits: "
+                  + pattern.substring(pos, pos + n));
+        }
+
         int result = 0;
         while (--n >= 0) {
           char ch = pattern.charAt(pos);
@@ -627,7 +634,31 @@ private char parseHex(int n) {
           ++pos;
           result = (result << 4) | digit;
         }
-        return (char) result;
+        return result;
+      }
+
+      private int parseBracedUnicodeEscape() {
+        int openBrace = pos;
+        checkState(pattern.charAt(pos++) == '{');
+
+        int closeBrace = pos;
+        while (closeBrace < limit && pattern.charAt(closeBrace) != '}') {
+          closeBrace++;
+        }
+        if (closeBrace == limit) {
+          throw new IllegalArgumentException(
+              "Malformed unicode escape: expected '}' after " + pattern.substring(openBrace));
+        } else if (closeBrace == pos) {
+          throw new IllegalArgumentException("Empty unicode escape");
+        }
+
+        int result = parseHex(closeBrace - pos);
+        if (result > 0x10FFFF) {
+          throw new IllegalArgumentException(
+              "Unicode must be at most 0x10FFFF: " + pattern.substring(openBrace + 1, pos));
+        }
+        pos++; // Consume the close brace.
+        return result;
       }
 
       private boolean isRepetitionStart(char ch) {

test/com/google/javascript/jscomp/parsing/ParserTest.java

@@ -4894,6 +4894,14 @@ public void testRegExpError() {
     parseError("/\b.\\/", "Expected '/' in regular expression literal");
   }
 
+  @Test
+  public void testRegExpUnicode() {
+    assertNodeEquality(parse("/\\u10fA/"), script(expr(regex("\\u10fA"))));
+    assertNodeEquality(parse("/\\u{10fA}/u"), script(expr(regex("\\u{10fA}", "u"))));
+    assertNodeEquality(parse("/\\u{1fA}/u"), script(expr(regex("\\u{1fA}", "u"))));
+    assertNodeEquality(parse("/\\u{10FFFF}/u"), script(expr(regex("\\u{10FFFF}", "u"))));
+  }
+
   @Test
   public void testRegExpFlags() {
     // Various valid combinations.
@@ -6556,6 +6564,10 @@ private static Node regex(String regex) {
     return new Node(Token.REGEXP, Node.newString(regex));
   }
 
+  private static Node regex(String regex, String flag) {
+    return new Node(Token.REGEXP, Node.newString(regex), Node.newString(flag));
+  }
+
   /**
    * Verify that the given code has the given parse errors.
    * @return If in IDE mode, returns a partial tree.

test/com/google/javascript/jscomp/regex/RegExpTreeTest.java

@@ -193,4 +193,33 @@ public void testBackreferencingTreatedAsStringIfNoGroup() {
     // (?: ) in expected output serves same purpose as above test
     assertRegexCompilesTo("[(?<foo>)]\\k<foo>", "", "(?:[()<>?fo]k)<foo>");
   }
+
+  @Test
+  public void testValidUnicodeEscape() {
+    assertRegexCompilesTo("\\u0061", "", "a");
+    assertRegexCompilesTo("\\u10b1", "u", "\\u10b1");
+    assertRegexCompilesTo("\\u{61}", "u", "a");
+    assertRegexCompilesTo("\\u{10b1}", "u", "\\u10b1");
+    assertRegexCompilesTo("\\u{1bc}", "u", "\\u01bc");
+    assertRegexCompilesTo("\\u{100A3}", "u", "\\ud800\\udca3");
+  }
+
+  @Test
+  public void testInvalidUnicodeEscape() {
+    assertRegexThrowsExceptionThat("\\u{a012", "u")
+        .hasMessageThat()
+        .isEqualTo("Malformed unicode escape: expected '}' after {a012");
+    assertRegexThrowsExceptionThat("\\u{}", "u") //
+        .hasMessageThat()
+        .isEqualTo("Empty unicode escape");
+    assertRegexThrowsExceptionThat("\\u{10za}", "u") //
+        .hasMessageThat()
+        .isEqualTo("za}");
+    assertRegexThrowsExceptionThat("\\u{FFFFFF}", "u")
+        .hasMessageThat()
+        .isEqualTo("Unicode must be at most 0x10FFFF: FFFFFF");
+    assertRegexThrowsExceptionThat("\\u{FF00FFFF}", "u")
+        .hasMessageThat()
+        .isEqualTo("Cannot parse hexadecimal encoding wider than 28 bits: FF00FFFF");
+  }
 }