ensure capture groups are returned in the correct order

Author: ColinEberhardt

assembly/__spec_tests__/generated.spec.ts

@@ -692,7 +692,7 @@ it("line: 149 - matches (ab|a)b*c against 'abc'", () => {
   expect(match.matches[0]).toBe("abc");
   expect(match.matches[1]).toBe("ab");
 });
-xit("line: 150 - matches ((a)(b)c)(d) against 'abcd'", () => {
+it("line: 150 - matches ((a)(b)c)(d) against 'abcd'", () => {
   const match = exec("((a)(b)c)(d)", "abcd", "");
   expect(match.matches[0]).toBe("abcd");
   expect(match.matches[1]).toBe("abc");
@@ -974,14 +974,14 @@ it("line: 186 - matches ^.+!([^!]+!)([^!]+)$ against 'foo!bar!bas'", () => {
   expect(match.matches[1]).toBe("bar!");
   expect(match.matches[2]).toBe("bas");
 });
-xit("line: 187 - matches ((foo)|(bar))!bas against 'bar!bas'", () => {
+it("line: 187 - matches ((foo)|(bar))!bas against 'bar!bas'", () => {
   const match = exec("((foo)|(bar))!bas", "bar!bas", "");
   expect(match.matches[0]).toBe("bar!bas");
   expect(match.matches[1]).toBe("bar");
   expect(match.matches[2]).toBe("");
   expect(match.matches[3]).toBe("bar");
 });
-xit("line: 188 - matches ((foo)|(bar))!bas against 'foo!bar!bas'", () => {
+it("line: 188 - matches ((foo)|(bar))!bas against 'foo!bar!bas'", () => {
   const match = exec("((foo)|(bar))!bas", "foo!bar!bas", "");
   expect(match.matches[0]).toBe("bar!bas");
   expect(match.matches[1]).toBe("bar");
@@ -994,12 +994,12 @@ it("line: 189 - matches ((foo)|(bar))!bas against 'foo!bas'", () => {
   expect(match.matches[1]).toBe("foo");
   expect(match.matches[2]).toBe("foo");
 });
-xit("line: 190 - matches ((foo)|bar)!bas against 'bar!bas'", () => {
+it("line: 190 - matches ((foo)|bar)!bas against 'bar!bas'", () => {
   const match = exec("((foo)|bar)!bas", "bar!bas", "");
   expect(match.matches[0]).toBe("bar!bas");
   expect(match.matches[1]).toBe("bar");
 });
-xit("line: 191 - matches ((foo)|bar)!bas against 'foo!bar!bas'", () => {
+it("line: 191 - matches ((foo)|bar)!bas against 'foo!bar!bas'", () => {
   const match = exec("((foo)|bar)!bas", "foo!bar!bas", "");
   expect(match.matches[0]).toBe("bar!bas");
   expect(match.matches[1]).toBe("bar");

assembly/nfa/nfa.ts

@@ -34,6 +34,10 @@ export class State {
 
 export class GroupStartMarkerState extends State {
   location: i32 = -1;
+  // a bit yucky - storing transient state in the state machine!
+  capture: string = "";
+  // captures from the path through the NFA that reaches the end are flagged
+  flagged: bool = false;
 
   constructor(next: State) {
     super();
@@ -47,18 +51,16 @@ export class GroupStartMarkerState extends State {
 }
 
 export class GroupEndMarkerState extends State {
-  // a bit yucky - storing transient state in the state machine!
-  capture: string = "";
-  // captures from the path through the NFA that reaches the end are flagged
-  flagged: bool = false;
-
   constructor(next: State, public startMarker: GroupStartMarkerState) {
     super();
     this.transitions.push(next);
   }
 
   matches(input: string, position: u32): MatchResult {
-    this.capture = input.substring(this.startMarker.location, position);
+    this.startMarker.capture = input.substring(
+      this.startMarker.location,
+      position
+    );
     return MatchResult.Ignore;
   }
 }

assembly/regexp.ts

@@ -1,4 +1,4 @@
-import { State, Automata, GroupEndMarkerState, MatchResult } from "./nfa/nfa";
+import { State, Automata, GroupStartMarkerState, MatchResult } from "./nfa/nfa";
 import { walker as nfaWalker } from "./nfa/walker";
 import { ConcatenationNode, AssertionNode, NodeType } from "./parser/node";
 import { Char } from "./char";
@@ -46,8 +46,8 @@ function recursiveBacktrackingSearch(
     );
     if (match != null) {
       // when unwinding the stack after a successful match, flag the captured values
-      if (state instanceof GroupEndMarkerState) {
-        (state as GroupEndMarkerState).flagged = true;
+      if (state instanceof GroupStartMarkerState) {
+        (state as GroupStartMarkerState).flagged = true;
       }
       return match;
     }
@@ -67,7 +67,7 @@ export class Match {
   }
 }
 
-let gm = new Array<GroupEndMarkerState>();
+let gm = new Array<GroupStartMarkerState>();
 
 export class RegExp {
   lastIndex: i32 = 0;
@@ -77,7 +77,7 @@ export class RegExp {
   private nfa: Automata;
   private endOfInput: bool = false;
   private startOfInput: bool = false;
-  private groupMarkers: GroupEndMarkerState[];
+  private groupMarkers: GroupStartMarkerState[];
 
   constructor(private regex: string, public flags: string | null = null) {
     const ast = Parser.toAST(regex);
@@ -100,10 +100,10 @@ export class RegExp {
     this.nfa = Automata.toNFA(ast, this.ignoreCase);
 
     // find all the group marker states
-    gm = new Array<GroupEndMarkerState>();
+    gm = new Array<GroupStartMarkerState>();
     nfaWalker(this.nfa.start, (state) => {
-      if (state instanceof GroupEndMarkerState) {
-        gm.push(state as GroupEndMarkerState);
+      if (state instanceof GroupStartMarkerState) {
+        gm.push(state as GroupStartMarkerState);
       }
     });
     this.groupMarkers = gm;

spec/test-generator.js

@@ -9,18 +9,9 @@ const knownIssues = {
   "issue with parsing the test itself": [28, 58, 59, 78, 212, 213],
   "issue with generating the test": [61, 62, 64, 76, 209, 210],
   "unsupported POSIX regex syntax": [54, 55, 56],
-  "issue that require triage": [199, 202, 204, 205, 206, 207],
+  "issue that require triage": [133, 199, 202, 204, 205, 206, 207],
   // I can't find a good reference that describes this behaviour!
   "BUG: doesn't support anchors within capture groups": [20],
-  // https://github.com/ColinEberhardt/assemblyscript-regex/issues/2
-  "BUG: Should not return captured values for non-matching alternations": [
-    133,
-    150,
-    187,
-    188,
-    190,
-    191,
-  ],
 };
 
 const hasKnownIssue = (index) => {