Release 1.1.0

njqdev · njqdev · commit 0b521660c222 · 2020-04-19T19:14:07.000+02:00
- Add a new setting for disabling workspace searching.
- Refactoring to improve hinting speed.
- Fix setting workspace search limit to 0 not working.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,17 @@
 # Change Log
 
+## [1.1.0] - 2020-04-19
+
+### Improvements:
+
+* Added a new setting for disabling workspace searching.
+* More default hints are provided for the typing module.
+* Overall speed improvements.
+
+### Fixes:
+
+* Setting the workspace search limit to 0 not working.
+
 ## [1.0.2] - 2020-04-16
 
 * Fixed type hints being provided for non-parameters.
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
 	"name": "vscode-python-typehint",
     "displayName": "Python Type Hint",
-    "version": "1.0.2",
+    "version": "1.1.0",
     "publisher": "njqdev",
     "description": "Type hint completion for Python.",
     "icon": "images/icon.png",
@@ -43,10 +43,15 @@
         "configuration": {
             "title": "Python Type Hint",
             "properties": {
-              "workspace.search.limit": {
+                "workspace.searchEnabled": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Search other files in the workspace when estimating types for a parameter. Disabling this will increase type hinting speed."
+                  },
+              "workspace.searchLimit": {
                 "type": "number",
                 "default": 20,
-                "description": "The maximum number of files searched when estimating types for a parameter. If 0, only the current editor document is searched, which increases speed but can reduce estimation accuracy."
+                "description": "The maximum number of files searched in a workspace search."
               }
             }
         }
diff --git a/src/completionProvider.ts b/src/completionProvider.ts
@@ -11,14 +11,18 @@ import {
     Range
 } from "vscode";
 import { TypeHintProvider } from "./typeHintProvider";
-import { paramHintTrigger, returnHintTrigger, PythonType, simpleIdentifier  } from "./python";
+import { paramHintTrigger, returnHintTrigger, PythonType, simpleIdentifier, getDataTypeContainer  } from "./python";
 import { TypeHintSettings } from "./settings";
+import { WorkspaceSearcher } from "./workspaceSearcher";
 
 
 export abstract class CompletionProvider {
 
     protected bottomOfListSortPrefix: number = 999;
 
+    /**
+     * Push type hints to the bottom of an array of completion items.
+     */
     protected pushHintsToItems(typeHints: string[], completionItems: CompletionItem[]) {
         const sortTextPrefix = this.bottomOfListSortPrefix.toString();
         for (const hint of typeHints) {
@@ -65,11 +69,21 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
 
             if (this.shouldProvideItems(precedingText, pos, doc)) {
                 const param = this.getParam(precedingText);
-                const provider = new TypeHintProvider(doc, this.settings);
-        
+                const documentText = doc.getText();
+                const typeContainer = getDataTypeContainer();
+                const provider = new TypeHintProvider(typeContainer);
+                const wsSearcher = new WorkspaceSearcher(doc.uri, this.settings, typeContainer);
+                
                 if (param) {
+                    const workspaceHintSearch = this.settings.workspaceSearchEnabled
+                        ? this.workspaceHintSearch(param, wsSearcher, documentText)
+                        : null;
                     try {
-                        this.pushEstimationsToItems(await provider.getTypeHints(param), items); 
+                        const estimations = await provider.estimateTypeHints(param, documentText);
+                        if (estimations.length > 0) {
+                            this.pushEstimationsToItems(estimations, items);
+                            wsSearcher.cancel();
+                        }
                     } catch {
                     }
 
@@ -83,14 +97,25 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
                     if (provider.typingImported) {
                         this.pushHintsToItems(provider.remainingTypingHints(), items);
                     }
-                    
+                    const hint = await workspaceHintSearch;
+                    if (hint && provider.hintNotProvided(hint)) {
+                        items.unshift(this.toSelectedCompletionItem(hint));
+                    }
                     return Promise.resolve(new CompletionList(items, false));  
                 }
             }
         }
         return Promise.resolve(null);
     }
 
+    private async workspaceHintSearch(param: string, ws: WorkspaceSearcher, docText: string): Promise<string | null> {
+        try {
+            return ws.findHintOfSimilarParam(param, docText);
+        } catch {
+            return null;
+        }
+    }
+
     /**
      * Returns the parameter which is about to be type hinted.
      * 
@@ -105,19 +130,23 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
     private pushEstimationsToItems(typeHints: string[], items: CompletionItem[]) {
 
         if (typeHints.length > 0) {
-            let item = new CompletionItem(this.labelFor(typeHints[0]), CompletionItemKind.TypeParameter);
-            item.sortText = `0${typeHints[0]}`;
-            item.preselect = true;
-            items.push(item);
+            items.push(this.toSelectedCompletionItem(typeHints[0]));
 
             for (let i = 1; i < typeHints.length; i++) {
-                item = new CompletionItem(this.labelFor(typeHints[i]), CompletionItemKind.TypeParameter);
+                let item = new CompletionItem(this.labelFor(typeHints[i]), CompletionItemKind.TypeParameter);
                 item.sortText = `${i}${typeHints[i]}`;
                 items.push(item);
             }       
         }
     }
 
+    private toSelectedCompletionItem(typeHint: string): CompletionItem {
+        let item = new CompletionItem(this.labelFor(typeHint), CompletionItemKind.TypeParameter);
+        item.sortText = `0${typeHint}`;
+        item.preselect = true;
+        return item;
+    }
+
     private shouldProvideItems(precedingText: string, activePos: Position, doc: TextDocument): boolean {
 
         if (activePos.character > 0 && !/#/.test(precedingText)) {
diff --git a/src/settings.ts b/src/settings.ts
@@ -5,11 +5,8 @@ import { workspace, Event, EventEmitter } from "vscode";
  */
 export class TypeHintSettings {
 
-    private searchLimit = 20;
-
-    public get fileSearchLimit() {
-        return this.searchLimit;
-    }
+    private _workspaceSearchEnabled = true;
+    private _workspaceSearchLimit = 20;
 
     constructor() {
         workspace.onDidChangeConfiguration(() => {
@@ -18,7 +15,13 @@ export class TypeHintSettings {
         });
         this.initialize();
     }
-    
+
+    public get workspaceSearchLimit() {
+        return this._workspaceSearchLimit;
+    }
+    public get workspaceSearchEnabled() {
+        return this._workspaceSearchEnabled;
+    }
     
     public readonly settingsUpdated = new EventEmitter<void>();
 
@@ -27,9 +30,13 @@ export class TypeHintSettings {
     }
 
     private initialize() {
-        const searchLimit: number | undefined = workspace.getConfiguration('workspace.search').get('limit');
-        if (searchLimit) {
-            this.searchLimit = Number.isInteger(searchLimit) ? searchLimit : Math.round(searchLimit);
+        const wsEnable: boolean | undefined = workspace.getConfiguration('workspace').get('searchEnabled');
+        const searchLimit: number | undefined = workspace.getConfiguration('workspace').get('searchLimit');
+        if (wsEnable !== undefined) {
+            this._workspaceSearchEnabled = wsEnable;
+        }
+        if (searchLimit || searchLimit === 0) {
+            this._workspaceSearchLimit = Number.isInteger(searchLimit) ? searchLimit : Math.round(searchLimit);
         }
     }
 
diff --git a/src/typeHintProvider.ts b/src/typeHintProvider.ts
@@ -2,17 +2,15 @@ import { TextDocument } from "vscode";
 import { PythonType as PythonType, DataTypeContainer, getDataTypeContainer } from "./python";
 import { TypeSearch, VariableSearchResult } from "./typeSearch";
 import { TypingHintProvider } from "./typingHintProvider";
-import { WorkspaceSearcher } from "./workspaceSearcher";
 import { TypeHintSettings } from "./settings";
 
 /**
  * Provides type hints.
  */
 export class TypeHintProvider {
     
-    private doc: TextDocument;
-    private settings: TypeHintSettings;
-    private typingHintProvider: TypingHintProvider;
+    private _typingHintProvider: TypingHintProvider;
+
     private likelyTypes: PythonType[] = [
         PythonType.String,
         PythonType.List, 
@@ -22,20 +20,13 @@ export class TypeHintProvider {
         PythonType.Tuple, 
         PythonType.Float
     ];
-    private providedTypeHints: string[] = [];
-    private typeContainer: DataTypeContainer = getDataTypeContainer();
+    private _providedTypeHints: string[] = [];
+    private _typeContainer: DataTypeContainer;
     private _typingImported = false;
 
-    /**
-     * Constructs a new TypeHintProvider.
-     * 
-     * @param doc The active document.
-     * @param settings User settings.
-     */
-    constructor(doc: TextDocument, settings: TypeHintSettings) {
-        this.doc = doc;
-        this.settings = settings;
-        this.typingHintProvider = new TypingHintProvider(this.typeContainer);
+    constructor(typeContainer: DataTypeContainer) {
+        this._typeContainer = typeContainer;
+        this._typingHintProvider = new TypingHintProvider(typeContainer);
     }
 
     public get typingImported() {
@@ -47,47 +38,44 @@ export class TypeHintProvider {
      * The returned hints are ordered with the most likely type being first. 
      * 
      * @param param The parameter name.
+     * @param documentText The text to search in order to estimate types.
      */
-    public async getTypeHints(param: string): Promise<string[]> {
+    public async estimateTypeHints(param: string, documentText: string): Promise<string[]> {
         const typeHints: string[] = [];
-        const documentText = this.doc.getText();
-
-        const typingSearch = this.typingHintProvider.detectTypingImport(documentText);
 
+        const typingSearch = this._typingHintProvider.detectTypingImport(documentText);
         const variableSearch = TypeSearch.variableWithSameName(param, documentText);
 
-        const wsSearcher = new WorkspaceSearcher(this.doc.uri, this.settings);
-        const workspaceSearch = wsSearcher.findHintOfSimilarParam(param, documentText);
-
-        this.tryAdd(TypeSearch.classWithSameName(param, documentText), typeHints);
-        this.tryAdd(TypeSearch.hintOfSimilarParam(param, documentText), typeHints);
-
         let typeName = this.getTypeParamEndsWith(param, "_");
+        this._typingImported = await typingSearch;
         if (typeName) {
             this.add(typeName, typeHints);
-            this.tryAddTypingHint(await typingSearch, typeName, typeHints);
-            wsSearcher.cancel();
-            await workspaceSearch;
+            this.tryAddTypingHint(typeName, typeHints);
+        }
+
+        if (
+            typeHints.length > 0 
+            || this.tryAdd(TypeSearch.hintOfSimilarParam(param, documentText), typeHints)
+            || this.tryAdd(TypeSearch.classWithSameName(param, documentText), typeHints)
+        ) {
             return typeHints;
         }
 
         const searchResult = await variableSearch;
 
         if (searchResult !== null && !TypeSearch.invalidTernaryOperator(searchResult)) {
             this.add(searchResult.typeName, typeHints);
-            this.tryAddTypingHints(await typingSearch, searchResult, typeHints);
+            this.tryAddTypingHints(searchResult, typeHints);
             this.tryAdd(this.typeGuessFor(param, typeHints), typeHints);
         } else {
             typeName = this.getTypeParamEndsWith(param, "");
             if (typeName) {
                 this.add(typeName, typeHints);
-                this.tryAddTypingHint(await typingSearch, typeName, typeHints);
+                this.tryAddTypingHint(typeName, typeHints);
             } else {
                 this.tryAdd(this.typeGuessFor(param, typeHints), typeHints);
             }
-        } 
-
-        this.tryAdd(await workspaceSearch, typeHints);
+        }
         return typeHints;
     }
     
@@ -97,7 +85,7 @@ export class TypeHintProvider {
     public remainingTypeHints(): PythonType[] {
         const result: PythonType[] = [];
 
-        for (const type of Object.values(this.typeContainer)) {
+        for (const type of Object.values(this._typeContainer)) {
             if (this.hintNotProvided(type.name)) {
                 result.push(type.name);
             }
@@ -110,7 +98,11 @@ export class TypeHintProvider {
      * Returns hints for the typing module that have not been provided yet.
      */
     public remainingTypingHints(): string[] {
-        return this.typingHintProvider.getRemainingHints();
+        return this._typingHintProvider.getRemainingHints();
+    }
+
+    public hintNotProvided(typeHint: string): boolean {
+        return !this._providedTypeHints.includes(typeHint);
     }
 
     /**
@@ -153,27 +145,21 @@ export class TypeHintProvider {
         type = type.trim();
         if (this.hintNotProvided(type)) {
             typeHints.push(type);
-            this.providedTypeHints.push(type);
+            this._providedTypeHints.push(type);
         }
     }
-            
-    private hintNotProvided(type: string): boolean {
-        return !this.providedTypeHints.includes(type);
-    }
 
-    private tryAdd(type: string | null, typeHints: string[]) {
+    private tryAdd(type: string | null, typeHints: string[]): boolean {
         if (type) {
             this.add(type, typeHints);
+            return true;
         }
+        return false;
     }
     
-    private tryAddTypingHints(
-        typingFound: boolean,
-        searchResult: VariableSearchResult | null,
-        typeHints: string[]
-    ) {
-        if (typingFound) {
-            const hints: string[] | null = this.typingHintProvider.getHints(searchResult);
+    private tryAddTypingHints(searchResult: VariableSearchResult | null, typeHints: string[]) {
+        if (this._typingImported) {
+            const hints: string[] | null = this._typingHintProvider.getHints(searchResult);
             if (hints) {
                 for (const hint of hints) {
                     this.add(hint, typeHints);
@@ -182,10 +168,9 @@ export class TypeHintProvider {
         }
     }
 
-    private tryAddTypingHint(typingImported: boolean, typeName: string, typeHints: string[]) {
-        this._typingImported = typingImported;
-        if (typingImported) {
-            const typingHint = this.typingHintProvider.getHint(typeName);
+    private tryAddTypingHint(typeName: string, typeHints: string[]) {
+        if (this._typingImported) {
+            const typingHint = this._typingHintProvider.getHint(typeName);
             if (typingHint) {
                 this.add(typingHint, typeHints);
             }
diff --git a/src/typeSearch.ts b/src/typeSearch.ts
@@ -152,7 +152,10 @@ export class TypeSearch {
      * @returns The type hint of the found parameter or null.
      */
     public static hintOfSimilarParam(param: string, src: string): string | null {
-        const m = new RegExp(`^[ \t]*def ${simpleIdentifier}\\([^)]*\\b${param}\\b: *([^),\\s]+)`, "m").exec(src);
+        const m = new RegExp(
+            `^[ \t]*def ${simpleIdentifier}\\([^)]*\\b${param}\\b: *([a-zA-Z_][^),\\s]+)`,
+            "m"
+        ).exec(src);
         if (m) {
             let hint = m[1].trim();
             return hint ? hint : null;
diff --git a/src/workspaceSearcher.ts b/src/workspaceSearcher.ts
