clarity-pattern-parser 10.3.7 → 11.0.1

package/src/patterns/ExpressionPattern.ts

@@ -4,18 +4,12 @@ import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 import { findPattern } from "./findPattern";
 import { Sequence } from "./Sequence";
+import { Association, PrecedenceTree } from './PrecedenceTree';
+import { testPattern } from "./testPattern";
+import { execPattern } from "./execPattern";
 
 let indexId = 0;
 
-function createNode(name: string, children: Node[]) {
-    return new Node("expression", name, 0, 0, children, "");
-}
-
-enum Association {
-    left = 0,
-    right = 1,
-}
-
 export class ExpressionPattern implements Pattern {
     private _id: string;
     private _type: string;
@@ -25,18 +19,16 @@ export class ExpressionPattern implements Pattern {
     private _originalPatterns: Pattern[];
     private _patterns: Pattern[];
     private _atomPatterns: Pattern[];
-    private _unaryPrefixPatterns: Pattern[];
-    private _unaryPrefixNames: string[];
+    private _prefixPatterns: Pattern[];
+    private _prefixNames: string[];
+    private _postfixPatterns: Pattern[];
+    private _postfixNames: string[];
     private _binaryPatterns: Pattern[];
-    private _recursivePatterns: Pattern[];
-    private _recursiveNames: string[];
-    private _endsInRecursion: boolean[];
-    private _binaryAssociation: Association[];
-    private _precedenceMap: Record<string, number>;
     private _binaryNames: string[];
-    private _shouldCompactPatternsMap: Record<string, boolean>;
-
-    shouldCompactAst = false;
+    private associationMap: Record<string, Association>;
+    private _precedenceMap: Record<string, number>;
+    private _shouldStopParsing: boolean;
+    private _precedenceTree: PrecedenceTree;
 
     get id(): string {
         return this._id;
@@ -62,20 +54,20 @@ export class ExpressionPattern implements Pattern {
         return this._patterns;
     }
 
-    get unaryPrefixPatterns(): readonly Pattern[] {
-        return this._unaryPrefixPatterns;
+    get prefixPatterns(): readonly Pattern[] {
+        return this._prefixPatterns;
     }
 
     get atomPatterns(): readonly Pattern[] {
         return this._atomPatterns;
     }
 
-    get binaryPatterns(): readonly Pattern[] {
-        return this._binaryPatterns;
+    get postfixPatterns(): readonly Pattern[] {
+        return this._postfixPatterns;
     }
 
-    get recursivePatterns(): readonly Pattern[] {
-        return this._recursivePatterns;
+    get binaryPatterns(): readonly Pattern[] {
+        return this._binaryPatterns;
     }
 
     get startedOnIndex() {
@@ -93,67 +85,69 @@ export class ExpressionPattern implements Pattern {
         this._parent = null;
         this._firstIndex = -1;
         this._atomPatterns = [];
-        this._unaryPrefixPatterns = [];
-        this._unaryPrefixNames = [];
+        this._prefixPatterns = [];
+        this._prefixNames = [];
+        this._postfixPatterns = [];
+        this._postfixNames = [];
         this._binaryPatterns = [];
-        this._recursivePatterns = [];
-        this._recursiveNames = [];
-        this._endsInRecursion = [];
         this._binaryNames = [];
-        this._binaryAssociation = [];
+        this.associationMap = {};
         this._precedenceMap = {};
         this._originalPatterns = patterns;
-        this._shouldCompactPatternsMap = {};
         this._patterns = this._organizePatterns(patterns);
+        this._shouldStopParsing = false;
+        this._precedenceTree = new PrecedenceTree(this._precedenceMap, this.associationMap);
 
         if (this._atomPatterns.length === 0) {
-            throw new Error("Need at least one operand pattern with an 'expression' pattern.");
+            throw new Error("Need at least one terminating pattern with an 'expression' pattern.");
         }
     }
 
     private _organizePatterns(patterns: Pattern[]) {
         const finalPatterns: Pattern[] = [];
         patterns.forEach((pattern) => {
-            this._shouldCompactPatternsMap[pattern.name] = pattern.shouldCompactAst;
 
-            if (this._isUnary(pattern)) {
-                const unaryPrefix = this._extractUnaryPrefixPattern(pattern).clone();
-                this._unaryPrefixPatterns.push(unaryPrefix);
-                this._unaryPrefixNames.push(pattern.name);
-                unaryPrefix.parent = this;
+            if (this._isAtom(pattern)) {
+                const atom = pattern.clone();
+                atom.parent = this;
 
-                finalPatterns.push(unaryPrefix);
+                this._atomPatterns.push(atom);
+
+                finalPatterns.push(atom);
+            } else if (this._isPrefix(pattern)) {
+                const name = this._extractName(pattern);
+                const prefix = this._extractPrefix(pattern);
+
+                prefix.parent = this;
+
+                this._prefixPatterns.push(prefix);
+                this._prefixNames.push(name);
+
+                finalPatterns.push(prefix);
+            } else if (this._isPostfix(pattern)) {
+                const name = this._extractName(pattern);
+                const postfix = this._extractPostfix(pattern);
+                postfix.parent = this;
+
+                this._postfixPatterns.push(postfix);
+                this._postfixNames.push(name);
+
+                finalPatterns.push(postfix);
             } else if (this._isBinary(pattern)) {
-                const binaryName = this._extractName(pattern);
-                const clone = this._extractDelimiter(pattern).clone();
+                const name = this._extractName(pattern);
+                const clone = this._extractBinary(pattern);
                 clone.parent = this;
 
-                this._precedenceMap[binaryName] = this._binaryPatterns.length;
+                this._precedenceMap[name] = this._binaryPatterns.length;
                 this._binaryPatterns.push(clone);
-                this._binaryNames.push(binaryName);
+                this._binaryNames.push(name);
 
                 if (pattern.type === "right-associated") {
-                    this._binaryAssociation.push(Association.right);
+                    this.associationMap[name] = Association.right;
                 } else {
-                    this._binaryAssociation.push(Association.left);
+                    this.associationMap[name] = Association.left;
                 }
 
-                finalPatterns.push(clone);
-            } else if (this._isRecursive(pattern)) {
-                const name = this._extractName(pattern);
-                const tail = this._extractRecursiveTail(pattern);
-
-                tail.parent = this;
-
-                this._recursivePatterns.push(tail);
-                this._recursiveNames.push(name);
-                this._endsInRecursion.push(this._endsWithRecursion(pattern));
-                finalPatterns.push(tail);
-            } else {
-                const clone = pattern.clone();
-                clone.parent = this;
-
-                this._atomPatterns.push(clone);
                 finalPatterns.push(clone);
             }
         });
@@ -161,95 +155,93 @@ export class ExpressionPattern implements Pattern {
         return finalPatterns;
     }
 
-    private _isBinary(pattern: Pattern) {
-        if (pattern.type === "right-associated" && this._isBinaryPattern(pattern.children[0])) {
-            return true;
+    private _extractName(pattern: Pattern) {
+        if (pattern.type === "right-associated") {
+            return pattern.children[0].name;
         }
 
-        return this._isBinaryPattern(pattern);
+        return pattern.name;
     }
 
-    private _isBinaryPattern(pattern: Pattern) {
-        return pattern.type === "sequence" &&
-            pattern.children.length === 3 &&
-            pattern.children[0].type === "reference" &&
-            pattern.children[0].name === this.name &&
-            pattern.children[2].type === "reference" &&
-            pattern.children[2].name === this.name;
+    private _isPrefix(pattern: Pattern) {
+        pattern = this._unwrapAssociationIfNecessary(pattern);
+
+        const lastChild = pattern.children[pattern.children.length - 1];
+        const referenceCount = this._referenceCount(pattern);
+        const lastChildIsReference = this._isRecursiveReference(lastChild);
+
+        return lastChildIsReference &&
+            referenceCount === 1;
     }
 
-    private _extractDelimiter(pattern: Pattern) {
-        if (pattern.type === "right-associated") {
-            return pattern.children[0].children[1];
-        }
-        return pattern.children[1];
+    private _extractPrefix(pattern: Pattern) {
+        pattern = this._unwrapAssociationIfNecessary(pattern);
+        return new Sequence(`${pattern.name}-prefix`, pattern.children.slice(0, -1));
     }
 
-    private _extractName(pattern: Pattern) {
-        if (pattern.type === "right-associated") {
-            return pattern.children[0].name;
-        }
+    private _isAtom(pattern: Pattern) {
+        pattern = this._unwrapAssociationIfNecessary(pattern);
 
-        return pattern.name;
+        const firstChild = pattern.children[0];
+        const lastChild = pattern.children[1];
+        const firstChildIsReference = this._isRecursiveReference(firstChild);
+        const lastChildIsReference = this._isRecursiveReference(lastChild);
+
+        return !firstChildIsReference && !lastChildIsReference;
     }
 
-    private _isUnary(pattern: Pattern) {
-        if (pattern.type === "right-associated" && this._isUnaryPattern(pattern.children[0])) {
-            return true;
-        }
+    private _isPostfix(pattern: Pattern) {
+        pattern = this._unwrapAssociationIfNecessary(pattern);
 
-        return this._isUnaryPattern(pattern);
-    }
+        const firstChild = pattern.children[0];
+        const referenceCount = this._referenceCount(pattern);
+        const firstChildIsReference = this._isRecursiveReference(firstChild);
 
-    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;
+        return firstChildIsReference &&
+            referenceCount === 1;
     }
 
-    private _extractUnaryPrefixPattern(pattern: Pattern) {
-        if (pattern.type === "right-associated") {
-            return pattern.children[0].children[0];
-        }
-
-        return pattern.children[0];
+    private _extractPostfix(pattern: Pattern) {
+        pattern = this._unwrapAssociationIfNecessary(pattern);
+        return new Sequence(`${pattern.name}-postfix`, pattern.children.slice(1));
     }
 
-    private _isRecursive(pattern: Pattern) {
-        if (pattern.type === "right-associated" && this._isRecursivePattern(pattern.children[0])) {
-            return true;
-        }
+    private _isBinary(pattern: Pattern) {
+        pattern = this._unwrapAssociationIfNecessary(pattern);
+
+        const firstChild = pattern.children[0];
+        const lastChild = pattern.children[pattern.children.length - 1];
+        const firstChildIsReference = this._isRecursiveReference(firstChild);
+        const lastChildIsReference = this._isRecursiveReference(lastChild);
 
-        return this._isRecursivePattern(pattern);
+        return firstChildIsReference && lastChildIsReference && pattern.children.length > 2;
     }
 
-    private _isRecursivePattern(pattern: Pattern) {
-        return pattern.type === "sequence" &&
-            pattern.children[0].type === "reference" &&
-            pattern.children[0].name === this.name &&
-            pattern.children.length > 2;
+    private _extractBinary(pattern: Pattern) {
+        pattern = this._unwrapAssociationIfNecessary(pattern);
+        const children = pattern.children.slice(1, -1);
+        const binarySequence = new Sequence(`${pattern.name}-delimiter`, children);
+
+        return binarySequence;
     }
 
-    private _extractRecursiveTail(pattern: Pattern) {
+    private _unwrapAssociationIfNecessary(pattern: Pattern) {
         if (pattern.type === "right-associated") {
-            return new Sequence(`${pattern.children[0].name}-tail`, pattern.children[0].children.slice(1));
+            return pattern.children[0];
         }
-        return new Sequence(`${pattern.name}-tail`, pattern.children.slice(1));
+
+        return pattern;
     }
 
-    private _endsWithRecursion(pattern: Pattern) {
-        if (pattern.type === "right-associated") {
-            pattern = pattern.children[0];
-        }
+    private _referenceCount(pattern: Pattern) {
+        return pattern.children.filter(p => this._isRecursiveReference(p)).length;
+    }
 
-        const lastChild = pattern.children[pattern.children.length - 1];
-        return pattern.type === "sequence" &&
-            pattern.children.length > 1 &&
-            lastChild.type === "reference" &&
-            lastChild.name === this.name;
+    private _isRecursiveReference(pattern: Pattern) {
+        if (pattern == null){
+            return false;
+        }
+        return pattern.type === "reference" && pattern.name === this.name;
     }
 
     parse(cursor: Cursor): Node | null {
@@ -261,35 +253,14 @@ export class ExpressionPattern implements Pattern {
 
             cursor.moveTo(node.lastIndex);
             cursor.resolveError();
-            this._compactResult(node);
             return node;
         }
 
+        cursor.moveTo(this._firstIndex);
         cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
         return null;
     }
 
-    private _compactResult(node: Node | null) {
-        if (node == null) {
-            return;
-        }
-
-        if (this.shouldCompactAst) {
-            node.compact();
-            return;
-        }
-
-        // This could be really expensive with large trees. So we optimize with these checks,
-        // as well as use breadth first as to not recompact nodes over and over again. 
-        const isCompactingNeeded = Object.values(this._shouldCompactPatternsMap).some(p => p);
-        if (isCompactingNeeded) {
-            node.walkBreadthFirst(n => {
-                if (this._shouldCompactPatternsMap[n.name]) {
-                    n.compact();
-                }
-            });
-        }
-    }
 
     private _tryToParse(cursor: Cursor): Node | null {
         if (this._isBeyondRecursiveAllowance()) {
@@ -297,228 +268,165 @@ export class ExpressionPattern implements Pattern {
             return null;
         }
 
-        let lastAtomNode: Node | null = null;
-        let lastBinaryNode: Node | null = null;
-        let onIndex = cursor.index;
+        this._shouldStopParsing = false;
 
-        outer: while (true) {
+        while (true) {
             cursor.resolveError();
-            onIndex = cursor.index;
-
-            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;
-                    }
+            this._tryToMatchPrefix(cursor);
 
-                    break;
-                } else {
-                    cursor.resolveError();
-                }
+            if (this._shouldStopParsing) {
+                break;
             }
 
-            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);
+            this._tryToMatchAtom(cursor);
 
-                if (node != null) {
-                    lastAtomNode = node;
-
-                    break;
-                } else {
-                    lastAtomNode = null;
-                    cursor.resolveError();
-                }
+            if (this._shouldStopParsing) {
+                break;
             }
 
-            if (lastAtomNode == null) {
+            this._tryToMatchPostfix(cursor);
+
+            if (this._shouldStopParsing) {
                 break;
             }
 
-            if (cursor.hasNext()) {
-                cursor.next();
-            } else {
-                if (lastBinaryNode != null && lastAtomNode != null) {
-                    if (prefix != null) {
-                        lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
-                    }
-                    lastBinaryNode.appendChild(lastAtomNode);
+            if (this._precedenceTree.hasAtom()) {
+                this._tryToMatchBinary(cursor);
+
+                if (this._shouldStopParsing) {
+                    break;
                 }
+            } else {
                 break;
             }
+        }
 
-            onIndex = cursor.index;
+        return this._precedenceTree.commit();
+    }
 
-            if (prefix != null && this._recursivePatterns.length === 0) {
-                lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
-            }
+    private _tryToMatchPrefix(cursor: Cursor) {
+        let onIndex = cursor.index;
+
+        for (let i = 0; i < this._prefixPatterns.length; i++) {
+            const pattern = this._prefixPatterns[i];
+            const name = this._prefixNames[i];
+            const node = pattern.parse(cursor);
+
+            if (node != null) {
+                this._precedenceTree.addPrefix(name, ...node.children);
 
-            for (let i = 0; i < this._recursivePatterns.length; i++) {
-                const pattern = this._recursivePatterns[i];
-                const node = pattern.parse(cursor);
-
-                if (node != null) {
-                    const name = this._recursiveNames[i];
-
-                    if (this._endsInRecursion[i]) {
-                        if (lastBinaryNode != null && lastAtomNode != null) {
-                            if (prefix != null) {
-                                lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
-                            }
-                            lastBinaryNode.appendChild(lastAtomNode);
-                        }
-
-                        const frontExpression = lastBinaryNode == null ? lastAtomNode as Node : lastBinaryNode.findRoot();
-                        const recursiveNode = createNode(name, [frontExpression, ...node.children]);
-
-
-                        return recursiveNode;
-                    } else {
-                        if (prefix != null) {
-                            lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
-                        }
-
-                        const recursiveNode = createNode(name, [lastAtomNode, ...node.children]);
-                        lastAtomNode = recursiveNode;
-
-                        if (cursor.hasNext()) {
-                            cursor.next();
-                        } else {
-                            if (lastBinaryNode != null && lastAtomNode != null) {
-                                lastBinaryNode.appendChild(lastAtomNode);
-                            }
-                            break outer;
-                        }
-                        onIndex = cursor.index;
-                        i = -1;
-                        continue;
-                    }
+                if (cursor.hasNext()) {
+                    cursor.next();
+                    onIndex = cursor.index;
+                    i = -1;
+
+                    continue;
+                } else {
+                    this._shouldStopParsing = true;
+                    break;
                 }
 
-                cursor.resolveError();
+            } else {
                 cursor.moveTo(onIndex);
+                cursor.resolveError();
             }
+        }
+    }
 
-            onIndex = cursor.index;
-            for (let i = 0; i < this._binaryPatterns.length; i++) {
-                cursor.resolveError();
-                cursor.moveTo(onIndex);
+    private _tryToMatchAtom(cursor: Cursor) {
+        let onIndex = cursor.index;
 
-                const pattern = this._binaryPatterns[i];
-                const name = this._binaryNames[i];
-                const delimiterNode = pattern.parse(cursor);
-
-                if (delimiterNode == null) {
-                    if (i === this._binaryPatterns.length - 1) {
-                        if (lastBinaryNode == null) {
-                            return lastAtomNode;
-                        } else if (lastAtomNode != null) {
-                            lastBinaryNode.appendChild(lastAtomNode);
-                        }
-                    }
-                    continue;
-                }
+        for (let i = 0; i < this._atomPatterns.length; i++) {
+            cursor.moveTo(onIndex);
 
-                if (lastBinaryNode == null && lastAtomNode != null && delimiterNode != null) {
-                    const node = createNode(name, [lastAtomNode, delimiterNode]);
-                    lastBinaryNode = node;
-                } 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, [lastAtomNode, delimiterNode]);
-                        lastBinaryNode.appendChild(node);
-
-                        lastBinaryNode = node;
-                    } else if (precedence === lastPrecendece) {
-                        const node = createNode(name, []);
-
-                        lastBinaryNode.replaceWith(node);
-                        lastBinaryNode.appendChild(lastAtomNode);
-
-                        node.append(lastBinaryNode, delimiterNode);
-                        lastBinaryNode = node;
-                    } else if (precedence > lastPrecendece) {
-                        let ancestor = lastBinaryNode.parent;
-                        let root: Node | null = lastBinaryNode;
-
-                        while (ancestor != null) {
-                            const nodePrecedence = this._precedenceMap[ancestor.name];
-
-                            if (nodePrecedence > precedence) {
-                                break;
-                            }
-                            root = ancestor;
-                            ancestor = ancestor.parent;
-                        }
-
-                        lastBinaryNode.appendChild(lastAtomNode);
-
-                        if (root != null) {
-                            const node = createNode(name, []);
-                            root.replaceWith(node);
-                            node.append(root, delimiterNode);
-
-                            lastBinaryNode = node;
-                        } else {
-                            const node = createNode(name, [lastAtomNode, delimiterNode]);
-                            lastBinaryNode = node;
-                        }
-
-                    } else {
-                        const node = createNode(name, [lastAtomNode, delimiterNode]);
-                        lastBinaryNode.appendChild(node);
-
-                        lastBinaryNode = node;
-                    }
+            const pattern = this._atomPatterns[i];
+            const node = pattern.parse(cursor);
 
-                }
+            if (node != null) {
+                this._precedenceTree.addAtom(node);
 
                 if (cursor.hasNext()) {
                     cursor.next();
                 } else {
-                    break outer;
+                    this._shouldStopParsing = true;
                 }
 
                 break;
+            } else {
+                cursor.resolveError();
+                cursor.moveTo(onIndex);
             }
+        }
+    }
 
-            if (lastBinaryNode == null) {
-                break;
+    private _tryToMatchPostfix(cursor: Cursor) {
+        let onIndex = cursor.index;
+
+        for (let i = 0; i < this._postfixPatterns.length; i++) {
+            const pattern = this._postfixPatterns[i];
+            const name = this._postfixNames[i];
+            const node = pattern.parse(cursor);
+
+            if (node != null) {
+                this._precedenceTree.addPostfix(name, ...node.children);
+
+                if (cursor.hasNext()) {
+                    cursor.next();
+                    onIndex = cursor.index;
+                    i = -1;
+
+                    continue;
+                } else {
+                    this._shouldStopParsing = true;
+                    break;
+                }
+
+            } else {
+                cursor.moveTo(onIndex);
+                cursor.resolveError();
             }
         }
+    }
 
-        if (lastBinaryNode == null) {
-            return lastAtomNode;
-        } else {
-            const root = lastBinaryNode.findAncestor(n => n.parent == null) as Node || lastBinaryNode;
-            if (lastBinaryNode.children.length < 3) {
-                lastBinaryNode.remove();
+    private _tryToMatchBinary(cursor: Cursor) {
+        let onIndex = cursor.index;
+        let foundMatch = false;
+
+        if (this.binaryPatterns.length === 0) {
+            this._shouldStopParsing = true;
+        }
 
-                if (lastBinaryNode === root) {
-                    return lastAtomNode;
+        for (let i = 0; i < this._binaryPatterns.length; i++) {
+            cursor.moveTo(onIndex);
+
+            const pattern = this._binaryPatterns[i];
+            const name = this._binaryNames[i];
+            const node = pattern.parse(cursor);
+
+            if (node != null) {
+                foundMatch = true;
+                this._precedenceTree.addBinary(name, ...node.children);
+
+                if (cursor.hasNext()) {
+                    cursor.next();
+                } else {
+                    this._shouldStopParsing = true;
                 }
+
+                break;
+            } else {
+                cursor.resolveError();
+                cursor.moveTo(onIndex);
             }
+        }
 
-            return root;
+        if (!foundMatch) {
+            this._shouldStopParsing = true;
         }
     }
 
+
     private _isBeyondRecursiveAllowance() {
         let depth = 0;
         let pattern: Pattern | null = this;
@@ -537,52 +445,19 @@ export class ExpressionPattern implements Pattern {
         return false;
     }
 
-    test(text: string) {
-        const cursor = new Cursor(text);
-        const ast = this.parse(cursor);
-
-        return ast?.value === text;
+    test(text: string, record = false): boolean {
+        return testPattern(this, text, record);
     }
 
     exec(text: string, record = false): ParseResult {
-        const cursor = new Cursor(text);
-        record && cursor.startRecording();
-
-        const ast = this.parse(cursor);
-
-        return {
-            ast: ast?.value === text ? ast : null,
-            cursor
-        };
+        return execPattern(this, text, record);
     }
 
     getTokens(): string[] {
         return this.atomPatterns.map(p => p.getTokens()).flat();
     }
 
-    getTokensAfter(childReference: Pattern): string[] {
-        if (this.atomPatterns.indexOf(childReference)) {
-            const recursiveTokens = this._recursivePatterns.map(p => p.getTokens()).flat();
-            const binaryTokens = this._binaryPatterns.map(p => p.getTokens()).flat();
-
-            return [...recursiveTokens, ...binaryTokens];
-        }
-
-        if (this.recursivePatterns.indexOf(childReference)) {
-            return this._binaryPatterns.map(p => p.getTokens()).flat();
-        }
-
-        if (this.binaryPatterns.indexOf(childReference)) {
-            const unaryTokens = this._atomPatterns.map(p => p.getTokens()).flat();
-
-            if (this._parent != null) {
-                const nextTokens = this._parent.getTokensAfter(this);
-                return [...unaryTokens, ...nextTokens];
-            }
-
-            return unaryTokens;
-        }
-
+    getTokensAfter(_childReference: Pattern): string[] {
         return [];
     }
 
@@ -598,29 +473,7 @@ export class ExpressionPattern implements Pattern {
         return this.atomPatterns.map(p => p.getPatterns()).flat();
     }
 
-    getPatternsAfter(childReference: Pattern): Pattern[] {
-        if (this.atomPatterns.indexOf(childReference)) {
-            const recursivePatterns = this._recursivePatterns.map(p => p.getPatterns()).flat();
-            const binaryPatterns = this._binaryPatterns.map(p => p.getPatterns()).flat();
-
-            return [...recursivePatterns, ...binaryPatterns];
-        }
-
-        if (this.recursivePatterns.indexOf(childReference)) {
-            return this._binaryPatterns.map(p => p.getPatterns()).flat();
-        }
-
-        if (this.binaryPatterns.indexOf(childReference)) {
-            const unaryPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
-
-            if (this._parent != null) {
-                const nextPatterns = this._parent.getPatternsAfter(this);
-                return [...unaryPatterns, ...nextPatterns];
-            }
-
-            return unaryPatterns;
-        }
-
+    getPatternsAfter(_childReference: Pattern): Pattern[] {
         return [];
     }
 
@@ -639,7 +492,6 @@ export class ExpressionPattern implements Pattern {
     clone(name = this._name): Pattern {
         const clone = new ExpressionPattern(name, this._originalPatterns);
         clone._id = this._id;
-        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }