WorkspaceSearcher + refactoring

Author: njqdev

.vscode/launch.json

@@ -11,6 +11,7 @@
 			"request": "launch",
 			"runtimeExecutable": "${execPath}",
 			"args": [
+                "--disable-extensions=1",
 				"--extensionDevelopmentPath=${workspaceFolder}"
 			],
 			"outFiles": [

src/codeSearch.ts

@@ -10,12 +10,12 @@ import {
     TextDocument
 } from "vscode";
 import { TypeHintProvider, TypeHint } from "./typeHintProvider";
-import { paramHintTrigger, returnHintTrigger, TypeName } from "./python";
+import { paramHintTrigger, returnHintTrigger, PythonType } from "./python";
 
 
 abstract class CompletionProvider {
 
-    protected pushTypeNamesToItems(typeNames: TypeName[], completionItems: CompletionItem[]) {
+    protected pushTypesToItems(typeNames: PythonType[], completionItems: CompletionItem[]) {
         for (const typeName of typeNames) {
             const item = new CompletionItem(typeName, CompletionItemKind.TypeParameter);
 
@@ -38,19 +38,25 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
         token: CancellationToken,
         context: CompletionContext
     ): Promise<CompletionList | null> {
-        if (context.triggerCharacter !== paramHintTrigger) {
-            return Promise.resolve(null);
-        }
-        const items: CompletionItem[] = [];
-        const line = doc.lineAt(pos);
-        const param = this.findParam(line, pos);
-        const provider = new TypeHintProvider(doc);
-
-        if (param && param.length > 0) {     
-            this.pushEstimationsToItems(await provider.getTypeHints(param), items); 
+        if (context.triggerCharacter === paramHintTrigger) {
+            const items: CompletionItem[] = [];
+            const line = doc.lineAt(pos);
+    
+            if (this.shouldProvideItems(line, pos)) {
+                const param = this.findParam(line, pos);
+                const provider = new TypeHintProvider(doc);
+        
+                if (param && param.length > 0) {
+                    try {
+                        this.pushEstimationsToItems(await provider.getTypeHints(param), items); 
+                    } catch (error) {
+                    }     
+                }
+                this.pushTypesToItems(provider.getRemainingTypes(), items);
+                return Promise.resolve(new CompletionList(items, false));
+            }
         }
-        this.pushTypeNamesToItems(provider.getRemainingTypes(), items);
-        return Promise.resolve(new CompletionList(items, false));
+        return Promise.resolve(null);
     }
 
     /**
@@ -69,9 +75,9 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
         return param;
     }
 
-    protected pushEstimationsToItems(typeHints: TypeHint[], items: CompletionItem[]) {
+    private pushEstimationsToItems(typeHints: TypeHint[], items: CompletionItem[]) {
 
-        if (typeHints) {
+        if (typeHints.length > 0) {
             let typeHint = typeHints[0].type;
             let item = new CompletionItem(typeHint, CompletionItemKind.TypeParameter);
             item.sortText = `0${typeHint}`;
@@ -89,6 +95,14 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
 
         }
     }
+
+    private shouldProvideItems(line: TextLine, pos: Position): boolean {
+
+        if (pos.character > 0) {
+            return new RegExp("^[ \t]*def", "m").test(line.text);
+        }
+        return false;
+    }
 }
 
 /**
@@ -108,17 +122,17 @@ export class ReturnHintCompletionProvider extends CompletionProvider implements
         const items: CompletionItem[] = [];
         const line = doc.lineAt(pos);
 
-        if (this.shouldProvideReturnHint(line, pos)) {         
-            this.pushTypeNamesToItems(Object.values(TypeName), items);
+        if (this.shouldProvideItems(line, pos)) {         
+            this.pushTypesToItems(Object.values(PythonType), items);
         }
         return Promise.resolve(new CompletionList(items, false));
     }
 
-    private shouldProvideReturnHint(line: TextLine, pos: Position): boolean {
+    private shouldProvideItems(line: TextLine, pos: Position): boolean {
 
         if (pos.character > 0 && line.text.substr(pos.character - 2, 2) === "->") {
 
-            return new RegExp("^[*\t]*def.*\\) *->[: ]*$", "m").test(line.text);
+            return new RegExp("^[ \t]*def.*\\) *->[: ]*$", "m").test(line.text);
         }
         return false;
     }

src/completionProvider.ts

@@ -1,35 +1,35 @@
 
-export const anyTypeName: string = "[a-zA-Z_][a-zA-Z0-9_.]*";
+export const anyClassOrFunctionName: string = "[a-zA-Z_][a-zA-Z0-9_.]*";
 
 export const paramHintTrigger: string = ":";
 export const returnHintTrigger: string = ">";
 
 export class DataType {
-    name: TypeName;
+    name: PythonType;
     category: TypeCategory;
 
-    constructor(name: TypeName, category: TypeCategory) {
+    constructor(name: PythonType, category: TypeCategory) {
         this.name = name;
         this.category = category;
     }
 }
 
-export interface DataTypes {
+export interface DataTypeContainer {
      [key: string]: DataType 
 };
 
-export const getDataTypes = (): DataTypes => {
+export const getDataTypeContainer = (): DataTypeContainer => {
     return {
-        bool: new DataType(TypeName.Bool, typeCategories.bool),
-        complex: new DataType(TypeName.Complex, typeCategories.complex),
-        dict: new DataType(TypeName.Dict, typeCategories.dict),
-        float: new DataType(TypeName.Float, typeCategories.float),
-        int: new DataType(TypeName.Int, typeCategories.int),
-        list: new DataType(TypeName.List, typeCategories.list),
-        object: new DataType(TypeName.Object, typeCategories.object),
-        set: new DataType(TypeName.Set, typeCategories.set),
-        str: new DataType(TypeName.String, typeCategories.string),
-        tuple: new DataType(TypeName.Tuple, typeCategories.tuple)
+        bool: new DataType(PythonType.Bool, typeCategories.bool),
+        complex: new DataType(PythonType.Complex, typeCategories.complex),
+        dict: new DataType(PythonType.Dict, typeCategories.dict),
+        float: new DataType(PythonType.Float, typeCategories.float),
+        int: new DataType(PythonType.Int, typeCategories.int),
+        list: new DataType(PythonType.List, typeCategories.list),
+        object: new DataType(PythonType.Object, typeCategories.object),
+        set: new DataType(PythonType.Set, typeCategories.set),
+        str: new DataType(PythonType.String, typeCategories.string),
+        tuple: new DataType(PythonType.Tuple, typeCategories.tuple)
     };
 };
 
@@ -42,9 +42,9 @@ export enum Initialization {
 }
 
 /**
- * Names of built-in Python types which can be hinted. 
+ * Built-in Python types.
  */
-export enum TypeName {
+export enum PythonType {
     Bool = "bool",
     Complex = "complex",
     Dict = "dict",
@@ -67,7 +67,7 @@ export enum TypeCategory {
 }
 
 /**
- * Type name keys with Type values. 
+ * Built-in Python type keys with Type category values. 
  */
 const typeCategories: { [key: string]: TypeCategory } = {
     bool: TypeCategory.Basic,