DCL Auto-Completion Provider (#203)

DCL Auto-Completion Provider (#203)

Author: JD-Howard

.gitignore

@@ -1,5 +1,5 @@
-node_modules
-out
+/node_modules
+/out
 vendor
 tmp
 autolispext*.zip

extension/smartBracket/language-configuration-dcl.json

@@ -17,5 +17,9 @@
 		"start": "^\\s*\/\/\\s*#?region\\b",
 		"end": "^\\s*\/\/\\s*#?endregion\\b"
 	  }
-	}
+	},
+  "indentationRules": {
+		"increaseIndentPattern": "{",
+		"decreaseIndentPattern": "}"
+	  }
 }

extension/src/astObjects/dclAtom.ts

@@ -34,8 +34,33 @@ export class DclAtom implements IDclFragment {
         return /^".*"$/.test(this.symbol);
     }
 
+    get isNumber(): boolean {
+        return /^\d+\.*\d*$/.test(this.symbol);
+    }
+
     get range(): Range {
-        return new Range(this.line, this.column, this.line, this.column + this.symbol.length);
+        if (!this.symbol.includes('\n')) {
+            return new Range(this.line, this.column, this.line, this.column + this.symbol.length);    
+        }
+
+        let cLine = this.line;
+        let cColm = this.column;
+        const begin: Position = new Position(cLine, cColm);
+        for (let i = 0; i < this.symbol.length; i++) {
+            const ch = this.symbol[i];
+            if (ch === '\n') {
+                cLine += 1;
+                cColm = 0;
+            } else {
+                cColm += 1;
+            }
+        }
+        const close: Position = new Position(cLine, cColm);
+        return new Range(begin.line, begin.character, close.line, close.character);
+    }
+
+    get rank(): number {
+        return this.line * 1000 + this.column;
     }
 
     equal(atom: IDclFragment): boolean {

extension/src/astObjects/dclAttribute.ts

@@ -32,10 +32,18 @@ export class DclAttribute implements IDclContainer {
         return false; 
     }
 
+    get isNumber(): boolean {
+        return false; 
+    }
+
     get range(): Range {
         const lastAtom = this.atoms[this.length - 1];
         return new Range(this.firstAtom.range.start, lastAtom.range.end);
     }
+
+    get rank(): number {
+        return this.line * 1000 + this.column;
+    }
 
     equal(dclObject: IDclFragment): boolean {
         return JSON.stringify(this) === JSON.stringify(dclObject);
@@ -83,6 +91,10 @@ export class DclAttribute implements IDclContainer {
         return null;
     }
 
+    getImpliedParent(position: Position): IDclContainer {
+        return this.contains(position) ? this : null;
+    }
+
     flatten(into?: Array<DclAtom>): Array<DclAtom> {
         if (!into) {
             into = [];
@@ -112,15 +124,12 @@ export class DclAttribute implements IDclContainer {
         return this.length < 3 ? null : this.atoms[2];
     }
 
-    // Context: DCL Attributes are valid in 2 arrangements: "Key = Value;" OR "key;"
-    //          Any other arrangement should be considered a malformed syntax error.
+
     get isWellFormed(): boolean {
-        const invalid = this.length < 2              // probably has key, but missing semi-colon
-                     || this.length === 3            // probably missing equal or semi-colon
-                     || this.length > 4              // exceeds possible key-value-pair structure
-                     || this.lastAtom.symbol !== ';' // invalid attribute termination
-                     || this.firstAtom.isString      // strings are invalid keys
-                     || (this.length === 4 && this.atoms[1].symbol !== '=');
+        const invalid = this.length !== 4              // exceeds possible key-value-pair structure
+                     || this.lastAtom.symbol !== ';'   // invalid attribute termination
+                     || this.firstAtom.isString        // strings are invalid keys
+                     || this.atoms[1].symbol !== '=';  // Unexpected delineator
         return !invalid;
     }
 

extension/src/astObjects/dclInterfaces.ts

@@ -7,14 +7,16 @@ export interface IDclFragment {
     readonly line: number;
     readonly column: number;
     readonly symbol?: string | undefined;
-    readonly flatIndex?: number | undefined;
+    readonly flatIndex?: number | undefined; // This is ideal for comparing an ASTObjects position to another ASTObject
     readonly asTile?: DclTile | undefined;
 	readonly asAttribute?: DclAttribute | undefined;
     readonly asContainer?: IDclContainer | undefined;
     readonly isComment: boolean;
     readonly isBlockComment: boolean;
     readonly isString: boolean;
+    readonly isNumber: boolean;
     readonly range: Range;
+    readonly rank: number; // This is ideal for comparing cursor position to an ASTObject
 
     equal(atom: IDclFragment): boolean;
     contains(position: Position): boolean;
@@ -27,6 +29,8 @@ export interface IDclContainer extends IDclFragment {
     readonly firstAtom: IDclFragment;
     readonly lastAtom: IDclFragment;
     readonly firstNonComment: IDclFragment;
+    readonly isWellFormed: boolean;
     getParentFrom(position: Position|IDclFragment, tilesOnly: boolean): IDclContainer;
+    getImpliedParent(position: Position): IDclContainer;
     flatten(into?: Array<DclAtom>): Array<DclAtom>;
 }

extension/src/astObjects/dclTile.ts

@@ -34,12 +34,20 @@ export class DclTile implements IDclContainer {
         return false; 
     }
 
+    get isNumber(): boolean {
+        return false; 
+    }
+
     get range(): Range {
         const begin = this.firstAtom.range.start;
         const close = this.lastAtom.range.end;
         return new Range(begin, close);
     }
 
+    get rank(): number {
+        return this.line * 1000 + this.column;
+    }
+
     equal(atom: IDclFragment): boolean {
         return JSON.stringify(this) === JSON.stringify(atom);
     }
@@ -88,12 +96,27 @@ export class DclTile implements IDclContainer {
         return null;
     }
 
+    get isWellFormed(): boolean {
+        if (this.length === 2) {
+            return /^[a-z\_]+$/i.test(this.firstAtom.symbol) && this.lastAtom.symbol === ';';
+        }
+
+        const name = this.tileTypeAtom?.symbol.toLowerCase() ?? '';
+
+        return this.firstAtom?.symbol === ':'
+            && this.closeBracketAtom?.symbol === '}'
+            && /^[a-z\_]+$/i.test(name)
+            && this.openBracketAtom?.symbol === '{'; // doing this one last because it loops over all atoms
+    }
+
     getParentFrom(position: Position|IDclFragment, tilesOnly = false): IDclContainer {
         const pos = position instanceof Position ? position : position.range.start;
         if (this.contains(pos)) {
+            let failed = 0;
             for (let i = 0; i < this.length; i++) {
                 const dclObj = this.atoms[i];
                 if (!dclObj.contains(pos)) {
+                    failed++;
                     continue;
                 }
                 if (dclObj instanceof DclAttribute) {
@@ -104,7 +127,40 @@ export class DclTile implements IDclContainer {
                     return dclObj.asTile.getParentFrom(pos, tilesOnly) ?? this;
                 }
             }
+            if (failed === this.length) {
+                return this; // position is not at the location of an atom, but we only care about the parent anyway
+            }
+        }
+        return null;
+    }
+
+    getImpliedParent(position: Position): IDclContainer {
+        // Note: attributes handle themselves, your challange is determining if an attribute is malformed and needs a force return.
+        let prev = 0;
+        const positionRank = position.line * 1000 + position.character;
+        for (let i = 0; i < this.atoms.length; i++) {
+            const atom = this.atoms[i];
+            if (prev > 0 && positionRank > prev && positionRank < atom.rank)  {
+                return this.atoms[i-1].asContainer ?? this;
+            }
+
+            const contains = atom.range.contains(position);
+            if (atom instanceof DclAtom) {
+                if (contains) {
+                    return this;
+                }
+                prev = atom.rank;
+                continue;
+            }
+
+            if (contains) {
+                // if the container is an attribute it will return itself, if its a tile it will keep digging for the best scenario
+                return atom.asContainer.getImpliedParent(position) ?? this;
+            }
+
+            prev = atom.rank;
         }
+
         return null;
     }
 

extension/src/commands.ts

@@ -1,4 +1,10 @@
 import * as vscode from "vscode";
+import {
+	TextDocument, ProviderResult, CancellationToken,
+	Position, Range,
+	CompletionContext, CompletionItem, CompletionList
+} from "vscode";
+
 import * as nls from 'vscode-nls';
 import { AutoLispExt } from './context';
 import { generateDocumentationSnippet, getDefunArguments, getDefunAtPosition } from './help/userDocumentation';
@@ -9,6 +15,7 @@ import { AutoLispExtPrepareRename, AutoLispExtProvideRenameEdits } from './provi
 import { SymbolManager } from './symbols';
 import {AutoLispExtProvideHover} from "./providers/hoverProvider";
 import { DocumentServices } from './services/documentServices';
+import { invokeCompletionProviderDcl } from './completion/completionProviderDcl';
 
 const localize = nls.loadMessageBundle();
 
@@ -178,4 +185,13 @@ export function registerCommands(context: vscode.ExtensionContext){
 		}
 	}));
 
+	AutoLispExt.Subscriptions.push(vscode.languages.registerCompletionItemProvider([DocumentServices.Selectors.DCL], {
+
+		provideCompletionItems(document: TextDocument, position: Position, token: CancellationToken, context: CompletionContext) : ProviderResult<CompletionItem[]|CompletionList> {
+			const roDoc = AutoLispExt.Documents.getDocument(document);
+			return invokeCompletionProviderDcl(roDoc, position, context);
+		}
+	}, ...[' ', ':', '=', ';', '/']));
+
+
 }