Merge pull request #9 from admvx/v1.1.0

admvx · web-flow · commit 191bd4dba21a · 2020-01-19T01:56:32.000-08:00
v1.1.0
diff --git a/README.md b/README.md
@@ -7,19 +7,18 @@ https://github.com/admvx/as2-language-support
 - LSP-based code completion
 - Intrinsic language features + local code parsing
 
-## Known issues
-- Look-up of imported classes requires the open vscode directory to match the class root
-- Method signature intellisense supports single-line cases only
-- Limited awareness of inline method definitions
-
 ## Coming soon
-- File handling improvements
 - Go-to / peek definition support
 - Contextual suggestion filtering
 - Performance improvements via WASM regex implementation
 
 ## Release Notes
 
+### 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
+- Fixes bug where parse queue halts upon encountering a missing file
+
 ### 1.0.1
 Addresses the following issues:
 - No method signature support for the super constructor
diff --git a/package.json b/package.json
@@ -6,7 +6,7 @@
     "type": "git",
     "url": "git@github.com:admvx/as2-language-support.git"
   },
-  "version": "1.0.1",
+  "version": "1.1.0",
   "author": "Adam Vernon",
   "publisher": "admvx",
   "icon": "icon.png",
diff --git a/server/package.json b/server/package.json
@@ -15,6 +15,7 @@
     "fs-extra": "8.1.0",
     "monaco-textmate": "^3.0.1",
     "onigasm": "^2.2.4",
-    "vscode-languageserver": "5.3.0-next.10"
+    "vscode-languageserver": "5.3.0-next.10",
+    "vscode-uri": "^2.1.1"
   }
 }
diff --git a/server/src/action-context.ts b/server/src/action-context.ts
@@ -14,16 +14,13 @@ const stringMatcher = /(?:".*?"|'.*?'|["'].*?$)/g;                  //Matches st
 const braceMatcher = /(?:{(?:(?!{).)*?}|{(?:(?!{).)*?$)/g;          //Matches well paired braces (complete or open to end of string)
 const bracketMatcher = /(?:\[(?:(?!\[).)*?\]|\[(?:(?!\[).)*?$)/g;   //Matches well paired square brackets (complete or open to end of string)
 const matchedParens = /(?:\((?:(?!\().)*?\))/g;                     //Matches well paired parentheses
-const slashMatcher = /\//g;                                         //Matches forward slashes
-const asExtensionMatcher = /\.as$/i;                                //Matches strings ending in .as
 
 interface SymbolChainLink { identifier: string; called: boolean; }
 
 export class ActionContext {
   
-  public static rootPath: string = '';  //TODO: Need a more accurate value for this to avoid i/o errors when the vscode folder is not the class root
-  
   private static _classes: ActionClass[] = [];
+  private static _wildcardImports: { [path: string]: Promise<string[]> } = Object.create(null);
   private static _classLookup: { [fullTypeOrUri: string]: ActionClass } = Object.create(null);
   private static _intrinsicImports: { [shortType: string]: ActionClass } = Object.create(null);
   private static _globalCompletions: CompletionItem[] = [];
@@ -85,7 +82,7 @@ export class ActionContext {
           }
         }
         returnType = nextClass.importMap[returnType] || returnType;
-        nextClass = await this.getClassByFullType(returnType);
+        nextClass = await this.getClassByFullType(returnType, nextClass.baseUri);
         if (symbolCalled && nextClass.constructorMethod) {
           nextVisibility = VisibilityFilter.PUBLIC_INSTANCE;
         }
@@ -124,7 +121,7 @@ export class ActionContext {
     
     let member: ActionParameter;
     if (ambientClass.superClass && chainLength === 1 && symbolChain[0].identifier === 'super') {
-      let superClass = await this.getClassByFullType(ambientClass.superClass);
+      let superClass = await this.getClassByFullType(ambientClass.superClass, ambientClass.baseUri);
       member = superClass && superClass.constructorMethod;
     } else {  
       let memberAndClass = await this.traverseSymbolChainToMember(symbolChain, ambientClass, lineIndex);
@@ -247,7 +244,7 @@ export class ActionContext {
       symbolName = symbolChain[0].identifier;
       returnType = ambientClass.importMap[symbolName];
       if (returnType) {
-        return [null, await this.getClassByFullType(returnType)];
+        return [null, await this.getClassByFullType(returnType, ambientClass.baseUri)];
       } else if (this._intrinsicImports[symbolName]) {
         return [null, this._intrinsicImports[symbolName]];
       }
@@ -287,7 +284,7 @@ export class ActionContext {
           }
         }
         returnType = nextClass.importMap[returnType] || returnType;
-        nextClass = await this.getClassByFullType(returnType);
+        nextClass = await this.getClassByFullType(returnType, nextClass.baseUri);
         if (symbolCalled && nextClass.constructorMethod) {
           nextVisibility = VisibilityFilter.PUBLIC_INSTANCE;
         }
@@ -373,7 +370,7 @@ export class ActionContext {
     }
     
     if (actionClass.superClass) {
-      let superActionClass = await this.getClassByFullType(actionClass.superClass);
+      let superActionClass = await this.getClassByFullType(actionClass.superClass, actionClass.baseUri);
       if (superActionClass) {
         completionItems = completionItems.concat(await this.getInnerSymbols(superActionClass, visibilityFilter, null, false, skipMap, rank));
       }
@@ -451,27 +448,18 @@ export class ActionContext {
     this._classLookup[actionClass.fileUri] = actionClass;
   }
   
-  public static getClassByFullType(fullType: string): Thenable<ActionClass> {
-    if (! fullType) {
-      return Promise.resolve(null);
-    }
-    if (this._classLookup[fullType]) {
-      return Promise.resolve(this._classLookup[fullType]);
-    }
-    return this.requestClassParse(fullType);
-  }
-  
-  public static requestClassParse(fullType: string, forceReparse: boolean = false): Thenable<ActionClass> {
-    ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.INFO, message: `request class parse! ${fullType}` });
+  public static getClassByFullType(fullType: string, basePath: string, forceReparse = false): Thenable<ActionClass> {
+    ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.VERBOSE, message: `Request class parse! ${fullType}` });
     
     if (fullType in this._classLookup && !forceReparse) {
       return Promise.resolve(this._classLookup[fullType]);
     } else {
-      let path = this.typeOrPackageToPath(fullType);
-      ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.INFO, message: `Type to path: ${path}` });
+      let path = this.typeOrPackageToPath(fullType, basePath);
+      ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.VERBOSE, message: `Type to path: ${path}` });
       let promises: [PromiseLike<any>, Promise<string>] = [ActionParser.initialise(), LoadQueue.enqueue(path)];
       return Promise.all(promises)
         .then(res => {
+          if (! res) return null;
           let ac = ActionParser.parseFile(path, res[1]);
           this.registerClass(ac);
           return ac;
@@ -480,18 +468,22 @@ export class ActionContext {
     }
   }
   
-  public static requestPackageParse(packageDescriptor: string, forceReparse: boolean = false): Promise<string[]> {
-    return DirectoryUtility.fileNamesInDirectory(this.typeOrPackageToPath(packageDescriptor), /\.as$/i)
-      .then(fileNames => fileNames.map(fileName => {
-        let fullType = this.pathToFullType(fileName);
-        if (fullType && (forceReparse || !this._classLookup[fullType])) {
-          let path = this.typeOrPackageToPath(fullType);
-          LoadQueue.enqueue(path)
-            .then(contents => this.registerClass(ActionParser.parseFile(path, contents)))
-            .catch(e => ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.ERROR, message: `Load error! ${path} ${e}` }));
-        }
-        return fullType;
-      }));
+  public static requestPackageParse(packageDescriptor: string, basePath: string, forceReparse = false): Promise<string[]> {
+    let lookupKey = basePath + packageDescriptor;
+    if (!forceReparse && lookupKey in this._wildcardImports) {
+      return this._wildcardImports[lookupKey];
+    }
+    this._wildcardImports[lookupKey] = DirectoryUtility.fileNamesInDirectory(this.typeOrPackageToPath(packageDescriptor, basePath), /\.as$/i)
+      .then(fileNames => Promise.all(fileNames.map(fileName => {
+        return LoadQueue.enqueue(fileName)
+          .then(contents => {
+            if (! contents) return null;
+            let parsedClass = ActionParser.parseFile(fileName, contents);
+            this.registerClass(parsedClass);
+            return parsedClass.fullType;
+          });
+      })));
+    return this._wildcardImports[lookupKey];
   }
   
   public static fullTypeToPackage(fullType: string): string {
@@ -506,26 +498,14 @@ export class ActionContext {
     return rawType.indexOf('.') === -1;
   }
   
-  public static typeOrPackageToPath(typeDescriptor: string): string {
+  public static typeOrPackageToPath(typeDescriptor: string, basePath: string): string {
     let isPackage = this.fullTypeToShortType(typeDescriptor) === '*';
-    let path = DirectoryUtility.concatPaths(this.rootPath, DirectoryUtility.typeToPath(typeDescriptor));
+    let path = DirectoryUtility.concatPaths(basePath, DirectoryUtility.typeToPath(typeDescriptor));
     if (isPackage) {
       return path.substring(0, path.length-1);
     } else {
       return path + '.as';
     }
   }
   
-  public static pathToFullType(path: string): string {
-    if (path.indexOf(this.rootPath) !== 0) {
-      ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.WARNING, message: `Can't determine type from path: '${path}' as it does not begin with the current rootPath: '${this.rootPath}'!` });
-      return '';
-    }
-    if (path.substr(-3).toLowerCase() !== '.as') {
-      ActionConfig.LOG_LEVEL !== LogLevel.NONE && logIt({ level: LogLevel.WARNING, message: `Unexpected file extension in path '${path}'!` });
-      return '';
-    }
-    return path.substring(this.rootPath.length).replace(slashMatcher, '.').replace(asExtensionMatcher, '');
-  }
-  
 }
diff --git a/server/src/action-elements.ts b/server/src/action-elements.ts
@@ -1,12 +1,14 @@
 import { ActionContext } from './action-context';
 import { logIt, LogLevel, ActionConfig } from './config';
 import { SignatureInformation } from 'vscode-languageserver';
+import { DirectoryUtility } from './file-system-utilities';
 
 export class ActionClass {
   
   public shortType: string;
   public fullType: string;
   public fileUri: string;
+  public baseUri: string;
   public isIntrinsic: boolean;
   public superClass: string;
   public parentPackage: string;
@@ -60,17 +62,23 @@ export class ActionClass {
     }
   }
   
-  public registerRegularImport(fullType: string, shortType?: string): void {
+  public registerRegularImport(fullType: string, shortType?: string, skipParse?: boolean): void {
     shortType = shortType || ActionContext.fullTypeToShortType(fullType);
     this._imports.push(fullType);
     this._importMap[shortType] = fullType;
-    ActionContext.requestClassParse(fullType);
+    if (! skipParse) {
+      ActionContext.getClassByFullType(fullType, this.baseUri, false);
+    }
   }
   
   public registerWildcardImport(wildcardImport: string): void {
     this._wildcardImports.push(wildcardImport);
-    ActionContext.requestPackageParse(wildcardImport)
-      .then(packageMembers => packageMembers.forEach(fullType => this.registerRegularImport(fullType)));
+    ActionContext.requestPackageParse(wildcardImport, this.baseUri, false)
+      .then(packageMembers => packageMembers.forEach(importType => {
+        if (importType && importType !== this.fullType) {
+          this.registerRegularImport(importType, null, true);
+        }
+      }));
   }
   
   public getMemberByName(memberName: string, filter: VisibilityFilter = VisibilityFilter.PUBLIC_INSTANCE, lineNumber: number = null): PromiseLike<ActionParameter> {
@@ -103,7 +111,7 @@ export class ActionClass {
     if (lookup[memberName]) {
       return Promise.resolve(lookup[memberName]);
     } else if (this.superClass) {
-      return ActionContext.getClassByFullType(this.superClass)
+      return ActionContext.getClassByFullType(this.superClass, this.baseUri, false)
         .then(parsedSuperClass => parsedSuperClass && parsedSuperClass.getMemberByName(memberName, filter));
     }
     return null;
@@ -146,6 +154,7 @@ export class ActionClass {
       });
     }
     this._importMap[this.shortType] = this.fullType;
+    this.baseUri = DirectoryUtility.fileUriAndTypeToBaseUri(this.fileUri, this.fullType);
   }
   
   public get publicMembers(): ActionParameter[] { return this._publicInstanceMembers; }
diff --git a/server/src/action-parser.ts b/server/src/action-parser.ts
@@ -56,6 +56,8 @@ export class ActionParser {
     this.wipClass.fileUri = fileUri;
     this.wipClass.lines = fileContent.split(/\r?\n/);
     
+    let imports: string[] = [];
+    
     let scopeStack: ActionScope[] = [ActionScope.BASE];
     for (let i = 0, l = this.wipClass.lines.length; i < l; i++) {
       line = this.wipClass.lines[i];
@@ -66,13 +68,7 @@ export class ActionParser {
           Patterns.IMPORT.lastIndex = 0;
           result = Patterns.IMPORT.exec(line);
           if (result) {
-            fullType = result[1];
-            shortType = ActionContext.fullTypeToShortType(fullType);
-            if (shortType === '*') {
-              this.wipClass.registerWildcardImport(fullType);
-            } else {
-              this.wipClass.registerRegularImport(fullType, shortType);
-            }
+            imports.push(result[1]);
             break;
           }
           
@@ -145,19 +141,29 @@ export class ActionParser {
             
             if (isConstructor) {
               this.wipClass.constructorMethod = method;
-            }// else {
+            }
             this.wipClass.registerMember(method);
-            // }
             
             i += methodLength;
             break;
           }
           
           break;
-          
       }
     }
+    
     this.wipClass.setupSelfReferences();
+    
+    //Register imports and parse external files
+    imports.forEach(fullType => {
+      shortType = ActionContext.fullTypeToShortType(fullType);
+      if (shortType === '*') {
+        this.wipClass.registerWildcardImport(fullType);
+      } else {
+        this.wipClass.registerRegularImport(fullType, shortType);
+      }
+    });
+    
     return this.wipClass;
   }
   
diff --git a/server/src/config.ts b/server/src/config.ts
@@ -27,8 +27,8 @@ setConsole(console);
 export function logIt(logConfig: { level: LogLevel, message: any } | any, ...rest: any[]) {
   if (ActionConfig.LOG_LEVEL === LogLevel.NONE) return;
   
-  let value: any = logConfig.level ? logConfig.message : Array.prototype.join.call(arguments, ' ');
-  let level: LogLevel = logConfig.level || LogLevel.DEBUG;
+  let value: any = (logConfig && logConfig.level) ? logConfig.message : Array.prototype.join.call(arguments, ' ');
+  let level: LogLevel = (logConfig && logConfig.level) || LogLevel.DEBUG;
   
   if (ActionConfig.LOG_LEVEL > level) return;
   
diff --git a/server/src/file-system-utilities.ts b/server/src/file-system-utilities.ts

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@`
`15`	`15`	`"fs-extra": "8.1.0",`
`16`	`16`	`"monaco-textmate": "^3.0.1",`
`17`	`17`	`"onigasm": "^2.2.4",`
`18`		`- "vscode-languageserver": "5.3.0-next.10"`
	`18`	`+ "vscode-languageserver": "5.3.0-next.10",`
	`19`	`+ "vscode-uri": "^2.1.1"`
`19`	`20`	`}`
`20`	`21`	`}`