round trip

Author: Protryon

src/main/java/com/shapesecurity/shift/es2017/parser/PatternAcceptor.java

@@ -408,12 +408,12 @@ private boolean acceptGrouping(State superState) {
     }
 
     private boolean acceptAtomEscape(State state) {
-        return acceptDecimalEscapeBackreference(state) ||
+        return acceptDecimalEscape(state) ||
                 acceptCharacterClassEscape(state) ||
                 acceptCharacterEscape(state).map(i -> true).orJust(false);
     }
 
-    private boolean acceptDecimalEscapeBackreference(State superState) {
+    private boolean acceptDecimalEscape(State superState) {
         return superState.backtrackOnFailure(state -> {
             StringBuilder digits = new StringBuilder();
             Maybe<String> firstDecimal = state.eatAny(decimalDigits);
@@ -433,37 +433,6 @@ private boolean acceptDecimalEscapeBackreference(State superState) {
         });
     }
 
-    @Nonnull
-    private Maybe<Integer> acceptDecimalEscape(State superState) {
-        return superState.backtrackOnFailureMaybe(state -> {
-            Maybe<String> firstDigit = state.eatAny(decimalDigits);
-            if (firstDigit.isNothing()) {
-                return Maybe.empty();
-            }
-            if (firstDigit.isJust() && firstDigit.fromJust().equals("0")) {
-                return Maybe.of(0);
-            }
-            if (this.unicode) {
-                return Maybe.empty();
-            }
-            StringBuilder digits = new StringBuilder();
-            digits.append(firstDigit.fromJust());
-            Maybe<String> digit = state.eatAny(decimalDigits);
-            if (digit.isJust()) {
-                String justDigit = digit.fromJust();
-                digits.append(justDigit);
-                if (firstDigit.fromJust().equals("1")) {
-                    if (justDigit.equals("0") || justDigit.equals("1")) {
-                        state.eatAny(decimalDigits).foreach(digits::append);
-                    } else if (justDigit.equals("2")) {
-                        state.eatAny(octalDigits).foreach(digits::append);
-                    }
-                }
-            }
-            return Maybe.of(Integer.parseInt(digits.toString()));
-        });
-    }
-
     private boolean acceptCharacterClassEscape(State state) {
         return state.eatAny("d", "D", "s", "S", "w", "W").isJust();
     }
@@ -573,7 +542,7 @@ private Maybe<Integer> acceptCharacterEscape(State superState) {
                         if (octal3.isNothing()) {
                             return Maybe.of(octal1.fromJust() << 3 | octal2.fromJust());
                         }
-                        return Maybe.of(octal1.fromJust() << 6 | octal2.fromJust() << 3 | octal1.fromJust());
+                        return Maybe.of(octal1.fromJust() << 6 | octal2.fromJust() << 3 | octal3.fromJust());
                     } else {
                         return Maybe.of(octal1.fromJust() << 3 | octal2.fromJust());
                     }
@@ -613,7 +582,6 @@ private Maybe<Maybe<Integer>> acceptClassEscape(State superState) {
                     }
                     return Maybe.of(0x0008); // backspace
                 }).map(Maybe::of),
-            state -> acceptDecimalEscape(state).map(Maybe::of),
             state -> {
                     if (this.unicode && state.eat("-")) {
                         return Maybe.of(Maybe.of((int)"-".charAt(0)));

src/test/java/com/shapesecurity/shift/es2017/parser/expressions/literals/LiteralRegExpExpressionTest.java

@@ -156,6 +156,8 @@ public class LiteralRegExpExpressionTest extends ParserTestCase {
         "/|.||.|/",
         "/|/",
         "/}*/",
+        "/[\\99-\\98]/",
+        "/[\\99-\\100]/",
     };
 
     private static final String[] expectedToFail = new String[] {
@@ -224,6 +226,7 @@ public class LiteralRegExpExpressionTest extends ParserTestCase {
         "/{5.}/u",
         "/{dfwfdf}/u",
         "/}*/u",
+        "/[\\100-\\99]/",
     };
 
     @Test