Create ambiguity nodes when joining stack heads

spec/runtime/parse_stack_spec.cc

@@ -3,9 +3,19 @@
 #include "runtime/tree.h"
 #include "runtime/length.h"
 
-enum { stateA, stateB, stateC, stateD, stateE, stateF, stateG, };
-enum { symbol0, symbol1, symbol2, symbol3, symbol4, symbol5, symbol6, };
-const char *symbol_names[] = { "zero", "one", "two", "three", "four", "five", "six", };
+enum {
+  stateA, stateB, stateC, stateD, stateE, stateF, stateG, stageH
+};
+
+enum {
+  symbol0 = ts_builtin_sym_start,
+  symbol1, symbol2, symbol3, symbol4, symbol5, symbol6, symbol7
+};
+
+const char *symbol_names[] = {
+  "ERROR", "END", "DOCUMENT", "AMBIGUITY",
+  "zero", "one", "two", "three", "four", "five", "six", "seven",
+};
 
 START_TEST
 
@@ -18,7 +28,7 @@ describe("ParseStack", [&]() {
     stack = ts_parse_stack_new();
     TSLength len = ts_length_make(2, 2);
     for (size_t i = 0; i < tree_count; i++)
-      trees[i] = ts_tree_make_leaf(i, len, len, false);
+      trees[i] = ts_tree_make_leaf(ts_builtin_sym_start + i, len, len, false);
   });
 
   after_each([&]() {
@@ -103,6 +113,7 @@ describe("ParseStack", [&]() {
   });
 
   describe("split(head_index)", [&]() {
+    int new_index;
     bool merged;
 
     before_each([&]() {
@@ -111,18 +122,18 @@ describe("ParseStack", [&]() {
       ts_parse_stack_shift(stack, 0, stateB, trees[1]);
       ts_parse_stack_shift(stack, 0, stateC, trees[2]);
 
-      int new_index = ts_parse_stack_split(stack, 0);
+      new_index = ts_parse_stack_split(stack, 0);
       AssertThat(new_index, Equals(1));
       AssertThat(ts_parse_stack_head_count(stack), Equals(2));
-    });
 
-    it("creates a new head pointing to the same node as the given head", [&]() {
       //  A0__B1__C2__D3
-      //   \__E4__F3
+      //   \______E4__F3
       ts_parse_stack_shift(stack, 0, stateD, trees[3]);
       ts_parse_stack_reduce(stack, 1, stateE, symbol4, 2);
       merged = ts_parse_stack_shift(stack, 1, stateF, trees[3]);
+    });
 
+    it("creates a new head pointing to the same node as the given head", [&]() {
       AssertThat(merged, IsFalse());
       AssertThat(ts_parse_stack_head_count(stack), Equals(2));
 
@@ -137,65 +148,69 @@ describe("ParseStack", [&]() {
       AssertThat(head2->successor_count, Equals(1));
     });
 
-    it("re-joins the heads when the same state and tree are shifted onto both heads", [&]() {
-      //  A0__B1__C2__D3
-      //   \____E4____/
-      ts_parse_stack_shift(stack, 0, stateD, trees[3]);
-      ts_parse_stack_reduce(stack, 1, stateE, symbol4, 2);
-      TSTree *tree4 = ts_parse_stack_head(stack, 1)->tree;
-      merged = ts_parse_stack_shift(stack, 1, stateD, trees[3]);
+    describe("when the same state and tree are shifted onto both heads", [&]() {
+      before_each([&]() {
+        //  A0__B1__C2__D3__G5
+        //   \______E4__F3__/
+        merged = ts_parse_stack_shift(stack, 0, stateG, trees[5]);
+        AssertThat(merged, IsFalse());
+        merged = ts_parse_stack_shift(stack, 1, stateG, trees[5]);
+        AssertThat(merged, IsTrue());
+      });
 
-      AssertThat(merged, IsTrue());
-      AssertThat(ts_parse_stack_head_count(stack), Equals(1));
+      it("re-joins the heads", [&]() {
+        AssertThat(ts_parse_stack_head_count(stack), Equals(1));
 
-      ParseStackNode *head = ts_parse_stack_head(stack, 0);
-      AssertThat(head->state, Equals(stateD));
-      AssertThat(head->tree, Equals(trees[3]));
-      AssertThat(head->successor_count, Equals(2));
+        ParseStackNode *head = ts_parse_stack_head(stack, 0);
+        AssertThat(head->state, Equals(stateG));
+        AssertThat(head->tree, Equals(trees[5]));
+        AssertThat(head->successor_count, Equals(2));
 
-      ParseStackNode *successor1 = head->successors[0];
-      AssertThat(successor1->state, Equals(stateC));
-      AssertThat(successor1->tree, Equals(trees[2]))
-      AssertThat(successor1->successor_count, Equals(1));
+        ParseStackNode *successor1 = head->successors[0];
+        AssertThat(successor1->state, Equals(stateD));
+        AssertThat(successor1->tree, Equals(trees[3]))
+        AssertThat(successor1->successor_count, Equals(1));
 
-      ParseStackNode *successor2 = head->successors[1];
-      AssertThat(successor2->state, Equals(stateE));
-      AssertThat(successor2->tree, Equals(tree4))
-      AssertThat(successor2->successor_count, Equals(1));
+        ParseStackNode *successor2 = head->successors[1];
+        AssertThat(successor2->state, Equals(stateF));
+        AssertThat(successor2->tree, Equals(trees[3]))
+        AssertThat(successor2->successor_count, Equals(1));
+      });
     });
 
-    it("re-joins the heads when the same state and tree are reduced onto both heads", [&]() {
-      //  A0__B1__C2__F4
-      //       \__D3__E4
-      ts_parse_stack_reduce(stack, 0, stateD, symbol3, 1);
-      ts_parse_stack_shift(stack, 0, stateE, trees[4]);
-      ts_parse_stack_shift(stack, 1, stateF, trees[4]);
+    describe("when both heads are reduced into the same state with the same symbol and yield", [&]() {
+      before_each([&]() {
+        //  A0__G5
+        merged = ts_parse_stack_reduce(stack, 0, stateG, symbol5, 3);
+        AssertThat(merged, IsFalse());
+        merged = ts_parse_stack_reduce(stack, 1, stateG, symbol5, 2);
+        AssertThat(merged, IsTrue());
+      });
 
-      AssertThat(ts_parse_stack_head_count(stack), Equals(2));
-      ParseStackNode *head1 = ts_parse_stack_head(stack, 0);
-      AssertThat(head1->state, Equals(stateE));
-      AssertThat(head1->tree, Equals(trees[4]));
-      AssertThat(head1->successor_count, Equals(1));
+      it("re-joins the heads, creating an 'ambiguity' node", [&]() {
+        AssertThat(ts_parse_stack_head_count(stack), Equals(1));
 
-      ParseStackNode *head2 = ts_parse_stack_head(stack, 1);
-      AssertThat(head2->state, Equals(stateF));
-      AssertThat(head2->tree, Equals(trees[4]));
-      AssertThat(head2->successor_count, Equals(1));
+        ParseStackNode *head = ts_parse_stack_head(stack, 0);
+        AssertThat(head->state, Equals(stateG));
 
-      //  A0__B1__C2__G5
-      //       \__D3__/
-      merged = ts_parse_stack_reduce(stack, 0, stateG, symbol5, 1);
-      AssertThat(merged, IsFalse());
-      merged = ts_parse_stack_reduce(stack, 1, stateG, symbol5, 1);
-      AssertThat(merged, IsTrue());
-
-      AssertThat(ts_parse_stack_head_count(stack), Equals(1));
-      ParseStackNode *head = ts_parse_stack_head(stack, 0);
-      AssertThat(head->state, Equals(stateG));
-      AssertThat(head->tree, Fulfills(EqualsTree(
-        ts_tree_make_node(symbol5, 1, tree_array({ trees[4] }), false),
-        symbol_names)));
-      AssertThat(head->successor_count, Equals(2));
+        AssertThat(head->tree, Fulfills(EqualsTree(
+          ts_tree_make_ambiguity(2, tree_array({
+            ts_tree_make_node(symbol5, 3, tree_array({
+              trees[1],
+              trees[2],
+              trees[3],
+            }), false),
+            ts_tree_make_node(symbol5, 2, tree_array({
+              ts_tree_make_node(symbol4, 2, tree_array({
+                trees[1],
+                trees[2],
+              }), false),
+              trees[3]
+            }), false)
+          })),
+          symbol_names)));
+        AssertThat(head->successor_count, Equals(1));
+      });
     });
   });
 });