clarity-pattern-parser 10.2.3 → 10.2.5

package/dist/patterns/ExpressionPattern.d.ts

@@ -14,6 +14,7 @@ export declare class ExpressionPattern implements Pattern {
     private _binaryPatterns;
     private _recursivePatterns;
     private _recursiveNames;
+    private _endsInRecursion;
     private _binaryAssociation;
     private _precedenceMap;
     private _binaryNames;
@@ -35,6 +36,7 @@ export declare class ExpressionPattern implements Pattern {
     private _isRecursive;
     private _isRecursivePattern;
     private _extractRecursiveTail;
+    private _endsWithRecursion;
     parse(cursor: Cursor): Node | null;
     private _tryToParse;
     test(text: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "10.2.3",
+  "version": "10.2.5",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/patterns/ExpressionPattern.ts

@@ -30,6 +30,7 @@ export class ExpressionPattern implements Pattern {
     private _binaryPatterns: Pattern[];
     private _recursivePatterns: Pattern[];
     private _recursiveNames: string[];
+    private _endsInRecursion: boolean[];
     private _binaryAssociation: Association[];
     private _precedenceMap: Record<string, number>;
     private _binaryNames: string[];
@@ -84,6 +85,7 @@ export class ExpressionPattern implements Pattern {
         this._binaryPatterns = [];
         this._recursivePatterns = [];
         this._recursiveNames = [];
+        this._endsInRecursion = [];
         this._binaryNames = [];
         this._binaryAssociation = [];
         this._precedenceMap = {};
@@ -121,6 +123,7 @@ export class ExpressionPattern implements Pattern {
 
                 this._recursivePatterns.push(tail);
                 this._recursiveNames.push(name);
+                this._endsInRecursion.push(this._endsWithRecursion(pattern));
                 finalPatterns.push(tail);
             } else {
                 const clone = pattern.clone();
@@ -188,6 +191,18 @@ export class ExpressionPattern implements Pattern {
         return new Sequence(`${pattern.name}-tail`, pattern.children.slice(1));
     }
 
+    private _endsWithRecursion(pattern: Pattern) {
+        if (pattern.type === "right-associated") {
+            pattern = pattern.children[0];
+        }
+
+        const lastChild = pattern.children[pattern.children.length - 1];
+        return pattern.type === "sequence" &&
+            pattern.children.length > 1 &&
+            lastChild.type === "reference" &&
+            lastChild.name === this.name;
+    }
+
     parse(cursor: Cursor): Node | null {
         // This is a cache to help with speed
         this._firstIndex = cursor.index;
@@ -214,11 +229,13 @@ export class ExpressionPattern implements Pattern {
             return null;
         }
 
+
         let lastUnaryNode: Node | null = null;
         let lastBinaryNode: Node | null = null;
         let onIndex = cursor.index;
 
         outer: while (true) {
+            cursor.resolveError();
             onIndex = cursor.index;
 
             for (let i = 0; i < this._unaryPatterns.length; i++) {
@@ -259,18 +276,28 @@ export class ExpressionPattern implements Pattern {
                     if (lastBinaryNode != null && lastUnaryNode != null) {
                         lastBinaryNode.appendChild(lastUnaryNode);
                     }
-
-                    const frontExpression = lastBinaryNode == null ? lastUnaryNode as Node : lastBinaryNode.findRoot();
+                    
                     const name = this._recursiveNames[i];
-                    const recursiveNode = createNode(name, [frontExpression, ...node.children]);
 
-                    recursiveNode.normalize(this._firstIndex);
-                    return recursiveNode;
+                    if (this._endsInRecursion[i]) {
+                        const frontExpression = lastBinaryNode == null ? lastUnaryNode as Node : lastBinaryNode.findRoot();
+                        const recursiveNode = createNode(name, [frontExpression, ...node.children]);
+
+                        recursiveNode.normalize(this._firstIndex);
+
+                        return recursiveNode;
+                    } else {
+                        const recursiveNode = createNode(name, [lastUnaryNode, ...node.children]);
+                        recursiveNode.normalize(this._firstIndex);
+                        lastUnaryNode = recursiveNode;
+                        break;
+                    }
                 }
 
                 cursor.moveTo(onIndex);
             }
 
+            cursor.resolveError();
             onIndex = cursor.index;
             for (let i = 0; i < this._binaryPatterns.length; i++) {
                 cursor.moveTo(onIndex);
@@ -295,7 +322,7 @@ export class ExpressionPattern implements Pattern {
                     lastBinaryNode = node;
                 } else if (lastBinaryNode != null && lastUnaryNode != null && delimiterNode != null) {
                     const precedence = this._precedenceMap[name];
-                    const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name];
+                    const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name] || -1;
                     const association = this._binaryAssociation[i];
 
                     if (precedence === lastPrecendece && association === Association.right) {