clarity-pattern-parser 10.3.2 → 10.3.4

package/dist/patterns/ExpressionPattern.d.ts

@@ -10,7 +10,9 @@ export declare class ExpressionPattern implements Pattern {
     private _firstIndex;
     private _originalPatterns;
     private _patterns;
-    private _unaryPatterns;
+    private _atomPatterns;
+    private _unaryPrefixPatterns;
+    private _unaryPrefixNames;
     private _binaryPatterns;
     private _recursivePatterns;
     private _recursiveNames;
@@ -36,6 +38,9 @@ export declare class ExpressionPattern implements Pattern {
     private _isBinaryPattern;
     private _extractDelimiter;
     private _extractName;
+    private _isUnary;
+    private _isUnaryPattern;
+    private _extractUnaryPrefixPattern;
     private _isRecursive;
     private _isRecursivePattern;
     private _extractRecursiveTail;

package/package.json

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

package/src/patterns/ExpressionPattern.ts

@@ -24,7 +24,9 @@ export class ExpressionPattern implements Pattern {
     private _firstIndex: number;
     private _originalPatterns: Pattern[];
     private _patterns: Pattern[];
-    private _unaryPatterns: Pattern[];
+    private _atomPatterns: Pattern[];
+    private _unaryPrefixPatterns: Pattern[];
+    private _unaryPrefixNames: string[];
     private _binaryPatterns: Pattern[];
     private _recursivePatterns: Pattern[];
     private _recursiveNames: string[];
@@ -61,7 +63,7 @@ export class ExpressionPattern implements Pattern {
     }
 
     get unaryPatterns(): readonly Pattern[] {
-        return this._unaryPatterns;
+        return this._atomPatterns;
     }
 
     get binaryPatterns(): readonly Pattern[] {
@@ -86,7 +88,9 @@ export class ExpressionPattern implements Pattern {
         this._name = name;
         this._parent = null;
         this._firstIndex = -1;
-        this._unaryPatterns = [];
+        this._atomPatterns = [];
+        this._unaryPrefixPatterns = [];
+        this._unaryPrefixNames = [];
         this._binaryPatterns = [];
         this._recursivePatterns = [];
         this._recursiveNames = [];
@@ -98,7 +102,7 @@ export class ExpressionPattern implements Pattern {
         this._shouldCompactPatternsMap = {};
         this._patterns = this._organizePatterns(patterns);
 
-        if (this._unaryPatterns.length === 0) {
+        if (this._atomPatterns.length === 0) {
             throw new Error("Need at least one operand pattern with an 'expression' pattern.");
         }
     }
@@ -108,7 +112,14 @@ export class ExpressionPattern implements Pattern {
         patterns.forEach((pattern) => {
             this._shouldCompactPatternsMap[pattern.name] = pattern.shouldCompactAst;
 
-            if (this._isBinary(pattern)) {
+            if (this._isUnary(pattern)) {
+                const unaryPrefix = this._extractUnaryPrefixPattern(pattern).clone();
+                this._unaryPrefixPatterns.push(pattern);
+                this._unaryPrefixNames.push(pattern.name);
+                unaryPrefix.parent = this;
+
+                finalPatterns.push(unaryPrefix);
+            } else if (this._isBinary(pattern)) {
                 const binaryName = this._extractName(pattern);
                 const clone = this._extractDelimiter(pattern).clone();
                 clone.parent = this;
@@ -138,7 +149,7 @@ export class ExpressionPattern implements Pattern {
                 const clone = pattern.clone();
                 clone.parent = this;
 
-                this._unaryPatterns.push(clone);
+                this._atomPatterns.push(clone);
                 finalPatterns.push(clone);
             }
         });
@@ -178,6 +189,31 @@ export class ExpressionPattern implements Pattern {
         return pattern.name;
     }
 
+    private _isUnary(pattern: Pattern) {
+        if (pattern.type === "right-associated" && this._isUnaryPattern(pattern.children[0])) {
+            return true;
+        }
+
+        return this._isUnaryPattern(pattern);
+    }
+
+    private _isUnaryPattern(pattern: Pattern) {
+        return pattern.type === "sequence" &&
+            pattern.children[0].type !== "reference" &&
+            pattern.children[0].name !== this.name &&
+            pattern.children[1].type === "reference" &&
+            pattern.children[1].name === this.name &&
+            pattern.children.length === 2;
+    }
+
+    private _extractUnaryPrefixPattern(pattern: Pattern) {
+        if (pattern.type === "right-associated") {
+            return pattern.children[0].children[0];
+        }
+
+        return pattern.children[0];
+    }
+
     private _isRecursive(pattern: Pattern) {
         if (pattern.type === "right-associated" && this._isRecursivePattern(pattern.children[0])) {
             return true;
@@ -190,7 +226,7 @@ export class ExpressionPattern implements Pattern {
         return pattern.type === "sequence" &&
             pattern.children[0].type === "reference" &&
             pattern.children[0].name === this.name &&
-            pattern.children.length > 1;
+            pattern.children.length > 2;
     }
 
     private _extractRecursiveTail(pattern: Pattern) {
@@ -255,7 +291,7 @@ export class ExpressionPattern implements Pattern {
             return null;
         }
 
-        let lastUnaryNode: Node | null = null;
+        let lastAtomNode: Node | null = null;
         let lastBinaryNode: Node | null = null;
         let onIndex = cursor.index;
 
@@ -263,31 +299,57 @@ export class ExpressionPattern implements Pattern {
             cursor.resolveError();
             onIndex = cursor.index;
 
-            for (let i = 0; i < this._unaryPatterns.length; i++) {
+            let prefix: Node | null = null;
+            let prefixName = "";
+            for (let i = 0; i < this._unaryPrefixPatterns.length; i++) {
                 cursor.moveTo(onIndex);
+                const pattern = this._unaryPrefixPatterns[i];
+                const node = pattern.parse(cursor);
+
+                if (node != null) {
+                    prefix = node;
+                    prefixName = this._unaryPrefixNames[i];
+
+                    if (cursor.hasNext()) {
+                        cursor.next();
+                    } else {
+                        break outer;
+                    }
+
+                    break;
+                } else {
+                    cursor.resolveError();
+                }
+            }
 
-                const pattern = this._unaryPatterns[i];
+            onIndex = cursor.index;
+            for (let i = 0; i < this._atomPatterns.length; i++) {
+                cursor.moveTo(onIndex);
+                const pattern = this._atomPatterns[i];
                 const node = pattern.parse(cursor);
 
                 if (node != null) {
-                    lastUnaryNode = node;
+                    lastAtomNode = node;
 
                     break;
                 } else {
-                    lastUnaryNode = null;
+                    lastAtomNode = null;
                     cursor.resolveError();
                 }
             }
 
-            if (lastUnaryNode == null) {
+            if (lastAtomNode == null) {
                 break;
             }
 
             if (cursor.hasNext()) {
                 cursor.next();
             } else {
-                if (lastBinaryNode != null && lastUnaryNode != null) {
-                    lastBinaryNode.appendChild(lastUnaryNode);
+                if (lastBinaryNode != null && lastAtomNode != null) {
+                    if (prefix != null) {
+                        lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                    }
+                    lastBinaryNode.appendChild(lastAtomNode);
                 }
                 break;
             }
@@ -302,26 +364,33 @@ export class ExpressionPattern implements Pattern {
                     const name = this._recursiveNames[i];
 
                     if (this._endsInRecursion[i]) {
-                        if (lastBinaryNode != null && lastUnaryNode != null) {
-                            lastBinaryNode.appendChild(lastUnaryNode);
+                        if (lastBinaryNode != null && lastAtomNode != null) {
+                            if (prefix != null) {
+                                lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                            }
+                            lastBinaryNode.appendChild(lastAtomNode);
                         }
 
-                        const frontExpression = lastBinaryNode == null ? lastUnaryNode as Node : lastBinaryNode.findRoot();
+                        const frontExpression = lastBinaryNode == null ? lastAtomNode 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(lastUnaryNode.startIndex);
-                        lastUnaryNode = recursiveNode;
+                        if (prefix != null) {
+                            lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                        }
+
+                        const recursiveNode = createNode(name, [lastAtomNode, ...node.children]);
+                        recursiveNode.normalize(lastAtomNode.startIndex);
+                        lastAtomNode = recursiveNode;
 
                         if (cursor.hasNext()) {
                             cursor.next();
                         } else {
-                            if (lastBinaryNode != null) {
-                                lastBinaryNode.appendChild(lastUnaryNode);
+                            if (lastBinaryNode != null && lastAtomNode != null) {
+                                lastBinaryNode.appendChild(lastAtomNode);
                             }
                             break outer;
                         }
@@ -347,24 +416,24 @@ export class ExpressionPattern implements Pattern {
                 if (delimiterNode == null) {
                     if (i === this._binaryPatterns.length - 1) {
                         if (lastBinaryNode == null) {
-                            return lastUnaryNode;
-                        } else if (lastUnaryNode != null) {
-                            lastBinaryNode.appendChild(lastUnaryNode);
+                            return lastAtomNode;
+                        } else if (lastAtomNode != null) {
+                            lastBinaryNode.appendChild(lastAtomNode);
                         }
                     }
                     continue;
                 }
 
-                if (lastBinaryNode == null && lastUnaryNode != null && delimiterNode != null) {
-                    const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                if (lastBinaryNode == null && lastAtomNode != null && delimiterNode != null) {
+                    const node = createNode(name, [lastAtomNode, delimiterNode]);
                     lastBinaryNode = node;
-                } else if (lastBinaryNode != null && lastUnaryNode != null && delimiterNode != null) {
+                } else if (lastBinaryNode != null && lastAtomNode != null && delimiterNode != null) {
                     const precedence = this._precedenceMap[name];
                     const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name] == null ? -1 : this._precedenceMap[lastBinaryNode.name];
                     const association = this._binaryAssociation[i];
 
                     if (precedence === lastPrecendece && association === Association.right) {
-                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                        const node = createNode(name, [lastAtomNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
 
                         lastBinaryNode = node;
@@ -372,7 +441,7 @@ export class ExpressionPattern implements Pattern {
                         const node = createNode(name, []);
 
                         lastBinaryNode.replaceWith(node);
-                        lastBinaryNode.appendChild(lastUnaryNode);
+                        lastBinaryNode.appendChild(lastAtomNode);
 
                         node.append(lastBinaryNode, delimiterNode);
                         lastBinaryNode = node;
@@ -390,7 +459,7 @@ export class ExpressionPattern implements Pattern {
                             ancestor = ancestor.parent;
                         }
 
-                        lastBinaryNode.appendChild(lastUnaryNode);
+                        lastBinaryNode.appendChild(lastAtomNode);
 
                         if (root != null) {
                             const node = createNode(name, []);
@@ -399,12 +468,12 @@ export class ExpressionPattern implements Pattern {
 
                             lastBinaryNode = node;
                         } else {
-                            const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                            const node = createNode(name, [lastAtomNode, delimiterNode]);
                             lastBinaryNode = node;
                         }
 
                     } else {
-                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                        const node = createNode(name, [lastAtomNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
 
                         lastBinaryNode = node;
@@ -427,14 +496,14 @@ export class ExpressionPattern implements Pattern {
         }
 
         if (lastBinaryNode == null) {
-            return lastUnaryNode;
+            return lastAtomNode;
         } else {
             const root = lastBinaryNode.findAncestor(n => n.parent == null) as Node || lastBinaryNode;
             if (lastBinaryNode.children.length < 3) {
                 lastBinaryNode.remove();
 
                 if (lastBinaryNode === root) {
-                    return lastUnaryNode;
+                    return lastAtomNode;
                 }
             }
 
@@ -497,7 +566,7 @@ export class ExpressionPattern implements Pattern {
         }
 
         if (this.binaryPatterns.indexOf(childReference)) {
-            const unaryTokens = this._unaryPatterns.map(p => p.getTokens()).flat();
+            const unaryTokens = this._atomPatterns.map(p => p.getTokens()).flat();
 
             if (this._parent != null) {
                 const nextTokens = this._parent.getTokensAfter(this);
@@ -535,7 +604,7 @@ export class ExpressionPattern implements Pattern {
         }
 
         if (this.binaryPatterns.indexOf(childReference)) {
-            const unaryPatterns = this._unaryPatterns.map(p => p.getPatterns()).flat();
+            const unaryPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
 
             if (this._parent != null) {
                 const nextPatterns = this._parent.getPatternsAfter(this);