Merge pull request #186 from DataFlowAnalysis/update-assignments

Author: Kr0nox

src/features/constraintMenu/AutoCompletion.ts

@@ -13,10 +13,11 @@ export interface ValidationError {
     endColumn: number;
 }
 
-interface Token {
+export interface Token {
     text: string;
     line: number;
     column: number;
+    whiteSpaceAfter?: string;
 }
 
 export type WordCompletion = RequiredCompletionParts & Partial<monaco.languages.CompletionItem>;
@@ -96,24 +97,29 @@ export class NegatableWord implements AbstractWord {
 }
 
 export class AutoCompleteTree {
-    constructor(private roots: AutoCompleteNode[]) {}
+    constructor(protected roots: AutoCompleteNode<AbstractWord>[]) {}
 
-    private tokenize(text: string[]): Token[] {
+    protected tokenize(text: string[]): Token[] {
         if (!text || text.length == 0) {
             return [];
         }
 
         const tokens: Token[] = [];
         for (const [lineNumber, line] of text.entries()) {
-            const lineTokens = line.split(/\s+/).filter((t) => t.length > 0);
+            const lineTokens = line.split(/(\s+)/);
             let column = 0;
-            for (const token of lineTokens) {
-                column = line.indexOf(token, column);
-                tokens.push({
-                    text: token,
-                    line: lineNumber + 1,
-                    column: column + 1,
-                });
+            for (let i = 0; i < lineTokens.length; i += 2) {
+                const token = lineTokens[i];
+                if (token.length > 0) {
+                    tokens.push({
+                        text: token,
+                        line: lineNumber + 1,
+                        column: column + 1,
+                        whiteSpaceAfter: lineTokens[i + 1],
+                    });
+                }
+                column += token.length;
+                column += lineTokens[i + 1] ? lineTokens[i + 1].length : 0; // Add whitespace length
             }
         }
 
@@ -199,6 +205,7 @@ export class AutoCompleteTree {
                 column: lines[lines.length - 1].length + 1,
             });
         }
+
         let result: WordCompletion[] = [];
         if (tokens.length == 0) {
             for (const r of this.roots) {
@@ -214,14 +221,16 @@ export class AutoCompleteTree {
         nodes: AutoCompleteNode[],
         tokens: Token[],
         index: number,
+        cameFromFinal = false,
         skipStartCheck = false,
     ): WordCompletion[] {
         // check for new start
-
         if (!skipStartCheck && tokens[index].column == 1) {
             const matchesAnyRoot = this.roots.some((n) => n.word.verifyWord(tokens[index].text).length === 0);
             if (matchesAnyRoot) {
-                return this.completeNode(this.roots, tokens, index, true);
+                return this.completeNode(this.roots, tokens, index, cameFromFinal, true);
+            } else if (cameFromFinal || nodes.length == 0) {
+                return this.completeNode([...this.roots, ...nodes], tokens, index, cameFromFinal, true);
             }
         }
 
@@ -233,10 +242,10 @@ export class AutoCompleteTree {
             return result;
         }
         for (const n of nodes) {
-            if (!n.word.verifyWord(tokens[index].text)) {
+            if (n.word.verifyWord(tokens[index].text).length > 0) {
                 continue;
             }
-            result = result.concat(this.completeNode(n.children, tokens, index + 1));
+            result = result.concat(this.completeNode(n.children, tokens, index + 1, n.canBeFinal || false));
         }
         return result;
     }
@@ -283,9 +292,9 @@ function deduplicateErrors(errors: ValidationError[]): ValidationError[] {
     });
 }
 
-export interface AutoCompleteNode {
-    word: AbstractWord;
-    children: AutoCompleteNode[];
+export interface AutoCompleteNode<W extends AbstractWord = AbstractWord> {
+    word: W;
+    children: AutoCompleteNode<W>[];
     canBeFinal?: boolean;
     viewAsLeaf?: boolean;
 }