Merge pull request #13 from admvx/features

Add enitity definition support

Author: admvx

README.md

@@ -4,16 +4,18 @@ https://github.com/admvx/as2-language-support
 
 ## Features
 - Syntax highlighting for ActionScript 2.0 (`*.as`)
-- LSP-based code completion
+- LSP-based assistance with the following features:
+  - Completion
+  - Hover info
+  - Method signatures
+  - Definition resolution (jump to definition, peek definition)
 - Intrinsic language features + local code parsing
 
-## Coming soon
-- Go-to / peek definition support
-- Contextual suggestion filtering
-- Performance improvements via WASM regex implementation
-
 ## Release Notes
 
+### 1.2.0
+Add definition support (jump to definition, peek definition)
+
 ### 1.1.0
 - Removes the requirement that the active vscode workspace directory must match the root class-path of any open files
 - Improves handling of wildcard imports

package.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "git@github.com:admvx/as2-language-support.git"
   },
-  "version": "1.1.0",
+  "version": "1.2.0",
   "author": "Adam Vernon",
   "publisher": "admvx",
   "icon": "icon.png",

server/src/action-context.ts

@@ -3,7 +3,7 @@ import { classAmbients, methodAmbients, generalAmbients } from './ambient-symbol
 import { ActionParser, recursiveReplace } from './action-parser';
 import { LoadQueue, DirectoryUtility } from './file-system-utilities';
 import { logIt, LogLevel, ActionConfig } from './config';
-import { CompletionItem, CompletionItemKind, CompletionParams, CancellationToken, CompletionTriggerKind, TextDocumentPositionParams, SignatureHelp, Hover } from 'vscode-languageserver';
+import { CompletionItem, CompletionItemKind, CompletionParams, CancellationToken, CompletionTriggerKind, TextDocumentPositionParams, SignatureHelp, Hover, Location } from 'vscode-languageserver';
 
 //TODO: use onigasm for regex instead
 const tokenSplitter = /([\w\$]+)/g;                                 //Captures symbol names
@@ -29,7 +29,7 @@ export class ActionContext {
   //--Completions--//
   //---------------//
   public static async getCompletions(textDocumentPosition: CompletionParams, cancellationToken: CancellationToken): Promise<CompletionItem[]> {
-    ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.VERBOSE, message: `Hooray: ${JSON.stringify(textDocumentPosition)}` });
+    ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.VERBOSE, message: `Completion request: ${JSON.stringify(textDocumentPosition)}` });
 
     let parsedClass = this._classLookup[textDocumentPosition.textDocument.uri];
     if (! parsedClass) return [];
@@ -183,6 +183,47 @@ export class ActionContext {
     };
   }
 
+  public static async getDefinition(textDocumentPosition: TextDocumentPositionParams): Promise<Location> {
+    ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.VERBOSE, message: `Get definition: ${JSON.stringify(textDocumentPosition)}` });
+    
+    let ambientClass = this._classLookup[textDocumentPosition.textDocument.uri];
+    if (! ambientClass) return null;
+    
+    let lineIndex = textDocumentPosition.position.line;
+    let charIndex = textDocumentPosition.position.character;
+    let fullLine = ambientClass.lines[lineIndex];
+    if (!fullLine.charAt(charIndex).match(symbolMatcher)) charIndex --;
+    if (!fullLine.charAt(charIndex).match(symbolMatcher)) return null;
+    
+    let line = fullLine.substr(0, charIndex + 1).trim();
+    if (this.positionInsideStringLiteral(line)) return null;
+    
+    firstSymbolMatcher.lastIndex = 0;
+    let result = firstSymbolMatcher.exec(fullLine.substr(charIndex + 1));
+    if (result) {
+      line += result[1];
+    }
+    
+    let symbolChain = this.getSymbolChainFromLine(line);
+    let memberAndClass = await this.traverseSymbolChainToMember(symbolChain, ambientClass, lineIndex, true);
+    let member = memberAndClass && memberAndClass[0];
+    let actionClass = memberAndClass && memberAndClass[1];
+    if (! member) {
+      if (!actionClass || !actionClass.fileUri || !actionClass.locationRange) return null;
+      return {
+        uri: actionClass.fileUri,
+        range: actionClass.locationRange
+      };
+    }
+    
+    if (!member.owningClass || !member.owningClass.fileUri || !member.locationRange) return null;
+    
+    return {
+      uri: member.owningClass.fileUri,
+      range: member.locationRange
+    };
+  }
+  
   private static getSymbolChainFromLine(line: string, expectGarbageAtEol?: boolean): SymbolChainLink[] {
     let tokens = line.split(tokenSplitter); //Odd-numbered array of tokens and delimiters, where the first and last elements are zero-or-longer delimiter strings
     if (expectGarbageAtEol && tokens[tokens.length - 1] !== '.') {

server/src/action-elements.ts

@@ -1,6 +1,6 @@
 import { ActionContext } from './action-context';
 import { logIt, LogLevel, ActionConfig } from './config';
-import { SignatureInformation } from 'vscode-languageserver';
+import { SignatureInformation, Range } from 'vscode-languageserver';
 import { DirectoryUtility } from './file-system-utilities';
 
 export class ActionClass {
@@ -14,6 +14,7 @@ export class ActionClass {
   public parentPackage: string;
   public lines: string[];
   public constructorMethod: ActionMethod;
+  public locationRange: Range;
 
   private _description: string;
   private _memberLookup: { [propName: string]: ActionParameter } = Object.create(null);
@@ -194,6 +195,8 @@ export class ActionClass {
       parentPackage: this.parentPackage,
       _imports: this._imports,
       _members: this._members.filter(member => member.name !== 'this' && member.name !== 'super')
+    }, (key, value) => {
+      if (key !== 'owningClass') return value;  //Skip this property to avoid circular references
     });
   }
 
@@ -235,14 +238,15 @@ export interface PickledClass {
   _members: (ActionParameter|ActionMethod)[];
 }
 
-//Method + constructor params; function-scoped vars
+//Class properties; method + constructor params; function-scoped vars
 export interface ActionParameter {
   name: string;
   returnType?: string;
-  owner?: string;
+  owningClass?: ActionClass;
   isInline?: boolean;
   isArgument?: boolean;
   documentation?: string;
+  locationRange?: Range;
   description?: string; //Should be present on all but only after instantiation
   isPublic?: boolean;
   isStatic?: boolean;
@@ -251,7 +255,7 @@ export interface ActionParameter {
   isGlobal?: boolean;
 }
 
-//Class level properties
+//Class methods
 export interface ActionMethod extends ActionParameter {
   isMethod: true;
   isConstructor: boolean;

server/src/action-parser.ts

@@ -1,6 +1,7 @@
 import { ActionClass, ActionParameter, ActionMethod } from './action-elements';
 import { logIt, LogLevel, ActionConfig } from './config';
 import { ActionContext } from './action-context';
+import { Range } from 'vscode-languageserver';
 //import { loadWASM } from 'onigasm';
 
 enum ActionScope {
@@ -24,14 +25,14 @@ const stripComments = (str: string) => str.replace(commentMatcher, (match: strin
 //TODO: use onigasm for regex instead
 const Patterns = {
   IMPORT: /\bimport\s+([\w$\.\*]+)/,
-  CLASS: /\bclass\s+([\w$\.]+)/,
+  CLASS: /(\bclass\s+)([\w$\.]+)/,
   CLASS_EXTENDS: /\bextends\s+([\w$\.]+)/,
-  CLASS_VAR: /\bvar\s+([\w$]+)(?:\s*:\s*([\w$\.]+))?/,              //Group 1: var name; capture group 2 (optional): type
+  CLASS_VAR: /(\bvar\s+)([\w$]+)(?:\s*:\s*([\w$\.]+))?/,                //Group 2: var name; group 3 (optional): type
   PRIVATE: /\bprivate\b/,
   STATIC: /\bstatic\b/,
-  METHOD: /\bfunction\s+([\w$]+)\s*\((.*)\)(?:\s*:\s*([\w$\.]+))?/, //Group 1: method name; group 2 (optional): arg list; group 3 (optional): return type
-  IDENTIFIER_AND_TYPE: /\s*([\w$]+)(?:\s*:\s*([\w$\.]+))?/,         //Group 1: var/argument name; capture group 2 (optional): type
-  LOCAL_VARS: /\bvar\b([\s\w$:,=.\[\]()-+*/]+)/,
+  METHOD: /(\bfunction\s+)([\w$]+)(\s*\()(.*)\)(?:\s*:\s*([\w$\.]+))?/, //Group 2: method name; group 4 (optional): arg list; group 5 (optional): return type
+  IDENTIFIER_AND_TYPE: /(\s*)([\w$]+)(\s*)(?:\:\s*([\w$\.]+)\s*)?/,     //Group 2: var/argument name; group 4 (optional): type
+  LOCAL_VARS: /(\bvar\b)([\s\w$:,=.\[\]()-+*/]+)/,                      //Group 2: content
   BRACES: /[{}]/g,
   MATCHED_BRACES: /{(?:(?!{).)*?}/g,
   MATCHED_BRACKETS: /\[(?:(?!\[).)*?\]/g,
@@ -56,6 +57,7 @@ export class ActionParser {
     this.wipClass.fileUri = fileUri;
     this.wipClass.lines = fileContent.split(/\r?\n/);
 
+    let includeLocations: boolean = !! fileUri;
     let imports: string[] = [];
 
     let scopeStack: ActionScope[] = [ActionScope.BASE];
@@ -76,7 +78,11 @@ export class ActionParser {
           Patterns.CLASS.lastIndex = 0;
           result = Patterns.CLASS.exec(line);
           if (result) {
-            fullType = result[1];
+            fullType = result[2];
+            if (includeLocations) {
+              let charStart = result.index + result[1].length;
+              this.wipClass.locationRange = { start: { line: i, character: charStart }, end: { line: i, character: charStart + result[2].length } };
+            }
             shortType = ActionContext.fullTypeToShortType(fullType);
             this.wipClass.fullType = fullType;
             this.wipClass.shortType = shortType;
@@ -102,12 +108,18 @@ export class ActionParser {
             Patterns.PRIVATE.lastIndex = Patterns.STATIC.lastIndex = 0;
             let privateRes = Patterns.PRIVATE.exec(line);
             let staticRes = Patterns.STATIC.exec(line);
-            this.wipClass.registerMember({
-              name: result[1],
-              returnType: result[2] || undefined,
+            let member: ActionParameter = {
+              name: result[2],
+              returnType: result[3] || undefined,
               isPublic: ! (privateRes && privateRes.index < result.index),
-              isStatic: !! (staticRes && staticRes.index < result.index)
-            });
+              isStatic: !! (staticRes && staticRes.index < result.index),
+              owningClass: this.wipClass
+            };
+            if (includeLocations) {
+              let charStart = result.index + result[1].length;
+              member.locationRange = { start: { line: i, character: charStart }, end: { line: i, character: charStart + result[2].length } };
+            }
+            this.wipClass.registerMember(member);
             break;
           }
 
@@ -118,24 +130,35 @@ export class ActionParser {
             Patterns.PRIVATE.lastIndex = Patterns.STATIC.lastIndex = 0;
             let privateRes = Patterns.PRIVATE.exec(line);
             let staticRes = Patterns.STATIC.exec(line);
-            let isConstructor = result[1] && result[1] === this.wipClass.shortType;
+            let isConstructor = result[2] && result[2] === this.wipClass.shortType;
+            
+            let locationRange: Range, argsStart: number;
+            if (includeLocations) {
+              let charStart = result.index + result[1].length;
+              locationRange = { start: { line: i, character: charStart }, end: { line: i, character: charStart + result[2].length } };
+              argsStart = locationRange.end.character + result[3].length;
+            }
 
             let method: ActionMethod = {
               isMethod: true,
               isConstructor: isConstructor,
-              name: result[1],
-              parameters: this.getParameterArrayFromString(result[2], true),
+              name: result[2],
+              parameters: this.getParameterArrayFromString(result[4], true, includeLocations, i, argsStart),
+              locationRange: locationRange,
               locals: [],
-              returnType: result[3] || (isConstructor ? result[1] : null),
+              returnType: result[5] || (isConstructor ? result[2] : null),
               isPublic: !(privateRes && privateRes.index < result.index),
               isStatic: !!(staticRes && staticRes.index < result.index),
-              firstLineNumber: i + 1
+              owningClass: this.wipClass
             };
 
             let methodLines = this.wipClass.lines.slice(i+1);
             methodLines.unshift(line.substr(result.index + result[0].length));
-            let [methodLength, locals] = this.extractMethod(methodLines, deep);
-            method.lastLineNumber = method.firstLineNumber + methodLength - 1;
+            let [methodLength, locals] = this.extractMethod(methodLines, deep, includeLocations, i);
+            if (includeLocations) {
+              method.firstLineNumber = i + 1;
+              method.lastLineNumber = method.firstLineNumber + methodLength - 1;
+            }
             method.locals = locals;
             method.scopedMembers = method.parameters.concat(method.locals);
 
@@ -167,17 +190,24 @@ export class ActionParser {
     return this.wipClass;
   }
 
-  private static getParameterArrayFromString(paramString: string, isArgument = false): ActionParameter[] {
+  private static getParameterArrayFromString(paramString: string, isArgument = false, includeLocations = false, lineNumber?: number, charIndex?: number): ActionParameter[] {
     let parsedParams: ActionParameter[] = [];
     if ((! paramString) || paramString.trim() === '') return parsedParams;
 
-    let rawParams = paramString.split(',');
+    let rawParams = paramString.split(','), charStart: number;
     let result: RegExpExecArray;
     for (let i = 0, l = rawParams.length; i < l; i++) {
-      Patterns.IDENTIFIER_AND_TYPE.lastIndex = 0;
+      Patterns.IDENTIFIER_AND_TYPE.lastIndex = 0; 
       result = Patterns.IDENTIFIER_AND_TYPE.exec(rawParams[i]);
-      if (result && result[1]) {
-        parsedParams.push({ name: result[1], returnType: result[2], isArgument: isArgument, isInline: ! isArgument });
+      if (result && result[2]) {
+        let param: ActionParameter = { name: result[2], returnType: result[4], isArgument: isArgument, isInline: ! isArgument };
+        if (includeLocations) {
+          charStart = charIndex + result.index + result[1].length;
+          param.locationRange = { start: { line: lineNumber, character: charStart }, end: { line: lineNumber, character: charStart + result[2].length } };
+          param.owningClass = this.wipClass;
+          charIndex += rawParams[i].length + 1;
+        }
+        parsedParams.push(param);
       }
     }
     return parsedParams;
@@ -186,7 +216,7 @@ export class ActionParser {
   /**
    * Modifies the passed array to remove the method contents, returns an array with the local vars if desired; otherwise an empty array
    */
-  private static extractMethod(lines: string[], collectLocals = false): [number, ActionParameter[]] {
+  private static extractMethod(lines: string[], collectLocals = false, includeLocations = false, lineNumber?: number): [number, ActionParameter[]] {
     let locals: ActionParameter[] = [];
     let lineCount = -1;
     let searchCount = -1; //Denotes start not yet found
@@ -211,11 +241,11 @@ export class ActionParser {
       if (collectLocals) {
         Patterns.LOCAL_VARS.lastIndex = 0;
         result = Patterns.LOCAL_VARS.exec(line);
-        if (result && result[1]) {
-          let localString = recursiveReplace(result[1], Patterns.MATCHED_BRACES);
-          localString = recursiveReplace(localString, Patterns.MATCHED_BRACKETS);
-          localString = recursiveReplace(localString, Patterns.MATCHED_PARENS);
-          locals = locals.concat(this.getParameterArrayFromString(localString, false));
+        if (result && result[2]) {
+          let localString = recursiveReplaceAndPreserveLength(result[2], Patterns.MATCHED_BRACES);
+          localString = recursiveReplaceAndPreserveLength(localString, Patterns.MATCHED_BRACKETS);
+          localString = recursiveReplaceAndPreserveLength(localString, Patterns.MATCHED_PARENS);
+          locals = locals.concat(this.getParameterArrayFromString(localString, false, includeLocations, lineNumber + lineCount, result.index + result[1].length));
         }
       }
       //Find end / other opening braces
@@ -241,3 +271,16 @@ export function recursiveReplace(input: string, matcher: string | RegExp, replac
   } while (output !== input);
   return output;
 }
+
+export function recursiveReplaceAndPreserveLength(input: string, matcher: RegExp, replacement = ' '): string {
+  let output = input;
+  let result: RegExpExecArray;
+  do {
+    input = output;
+    matcher.lastIndex = 0;
+    result = matcher.exec(input);
+    if (! result || !result[0]) break;
+    output = input.replace(result[0], replacement.repeat(result[0].length));
+  } while (output !== input);
+  return output;
+}

server/src/server.ts

@@ -20,7 +20,8 @@ connection.onInitialize((params) => {
       textDocumentSync: documents.syncKind,
       completionProvider: { resolveProvider: false, triggerCharacters: ['.'] },
       signatureHelpProvider: { triggerCharacters: ['(', ','] },
-      hoverProvider: true
+      hoverProvider: true,
+      definitionProvider: true
     }
   };
 });
@@ -37,5 +38,6 @@ ActionParser.initialise()
     documents.onDidChangeContent(change => ActionContext.registerClass(ActionParser.parseFile(change.document.uri, change.document.getText(), true)));
     connection.onCompletion((docPos, token) => ActionContext.getCompletions(docPos, token));
     connection.onSignatureHelp((docPos, token) => ActionContext.getSignatureHelp(docPos, token));
-    connection.onHover((docPos) => ActionContext.getHoverInfo(docPos));
+    connection.onHover(docPos => ActionContext.getHoverInfo(docPos));
+    connection.onDefinition(docPos => ActionContext.getDefinition(docPos));
   });