Fix first item not being pre-selected

Author: njqdev

src/completionProvider.ts

@@ -19,20 +19,37 @@ import { TypingHintProvider } from "./typingHintProvider";
 
 export abstract class CompletionProvider {
 
-    protected bottomOfListSortPrefix: number = 999;
+    protected itemSortPrefix: number = 90;
 
     /**
      * Push type hints to the end of an array of completion items.
      */
-    protected pushHintsToItems(typeHints: string[], completionItems: CompletionItem[]) {
-        const sortTextPrefix = this.bottomOfListSortPrefix.toString();
-        for (const hint of typeHints) {
-            const item = new CompletionItem(this.labelFor(hint), CompletionItemKind.TypeParameter);
-            item.sortText = sortTextPrefix + hint;
-            completionItems.push(item);
+    protected pushHintsToItems(typeHints: string[], completionItems: CompletionItem[], firstItemSelected: boolean) {
+        const sortTextPrefix = this.itemSortPrefix.toString();
+        completionItems.push(
+            firstItemSelected 
+                ? this.selectedCompletionItem(typeHints[0])
+                : this.newCompletionitem(typeHints[0], sortTextPrefix)
+        );
+
+        for (let i = 1; i < typeHints.length; i++) {
+            completionItems.push(this.newCompletionitem(typeHints[i], sortTextPrefix));
         }
     }
 
+    private newCompletionitem = (hint: string, sortTextPrefix: string): CompletionItem => {
+        const item = new CompletionItem(this.labelFor(hint), CompletionItemKind.TypeParameter);
+        item.sortText = sortTextPrefix + hint;
+        return item;
+    };
+
+    protected selectedCompletionItem(typeHint: string, sortTextPrefix: string = "0b"): CompletionItem {
+        let item = new CompletionItem(this.labelFor(typeHint), CompletionItemKind.TypeParameter);
+        item.sortText = `${sortTextPrefix}${typeHint}`;
+        item.preselect = true;
+        return item;
+    }
+
     protected labelFor(typeHint: string): string {
         return " " + typeHint;
     }
@@ -74,33 +91,28 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
                 const typeContainer = getDataTypeContainer();
                 const provider = new TypeHintProvider(typeContainer);
                 const wsSearcher = new WorkspaceSearcher(doc.uri, this.settings, typeContainer);
-                
+                let estimations: string[] = [];
+
                 if (param) {
                     const workspaceHintSearch = this.settings.workspaceSearchEnabled
                         ? this.workspaceHintSearch(param, wsSearcher, documentText)
                         : null;
                     try {
-                        const estimations = await provider.estimateTypeHints(param, documentText);
+                        estimations = await provider.estimateTypeHints(param, documentText);
                         if (estimations.length > 0) {
                             this.pushEstimationsToItems(estimations, items);
                             wsSearcher.cancel();
                         }
                     } catch {
                     }
 
-                    const sortTextPrefix = (this.bottomOfListSortPrefix - 1).toString();
-                    for (const hint of provider.remainingTypeHints()) {
-                        let item = new CompletionItem(this.labelFor(hint), CompletionItemKind.TypeParameter);
-                        item.sortText = sortTextPrefix + hint;
-                        items.push(item);
-                    }
-                    
-                    if (provider.typingImported) {
-                        this.pushHintsToItems(provider.remainingTypingHints(), items);
-                    }
+                    this.pushHintsToItems(provider.remainingTypeHints(), items, estimations.length === 0);
+                    this.itemSortPrefix++;
+                    this.pushHintsToItems(provider.remainingTypingHints(), items, false);
+
                     const hint = await workspaceHintSearch;
                     if (hint && provider.hintNotProvided(hint)) {
-                        items.unshift(this.toSelectedCompletionItem(hint));
+                        items.unshift(this.selectedCompletionItem(hint, "0a"));
                     }
                     return Promise.resolve(new CompletionList(items, false));  
                 }
@@ -131,7 +143,7 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
     private pushEstimationsToItems(typeHints: string[], items: CompletionItem[]) {
 
         if (typeHints.length > 0) {
-            items.push(this.toSelectedCompletionItem(typeHints[0]));
+            items.push(this.selectedCompletionItem(typeHints[0]));
 
             for (let i = 1; i < typeHints.length; i++) {
                 let item = new CompletionItem(this.labelFor(typeHints[i]), CompletionItemKind.TypeParameter);
@@ -141,13 +153,6 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
         }
     }
 
-    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)) {
@@ -185,11 +190,13 @@ export class ReturnHintCompletionProvider extends CompletionProvider implements
 
         if (this.shouldProvideItems(line, pos)) {
             const provider = new TypingHintProvider(getDataTypeContainer());
-            await provider.detectTypingImport(doc.getText());
-            this.pushHintsToItems(provider.getRemainingHints(), items);
-            this.bottomOfListSortPrefix--;   
+            const detectTypingImport = provider.detectTypingImport(doc.getText());
+
+            this.pushHintsToItems(Object.values(PythonType), items, true);
+            this.itemSortPrefix++;
 
-            this.pushHintsToItems(Object.values(PythonType), items);
+            await detectTypingImport;
+            this.pushHintsToItems(provider.getRemainingHints(), items, false);
         }
         return Promise.resolve(new CompletionList(items, false));
     }

test/providers/completionProvider.test.ts

@@ -60,23 +60,25 @@ suite('ParamHintCompletionProvider', () => {
         assert.notEqual(actual, null, messageFor(data, expected, actual));
     });
 
-    test("provides default items", async () => {
+    test("provides default items if nothing is detected", async () => {
         let param = "notFound:";
-        let expected = Object.values(PythonType).sort();
+        let expected = typeHints().concat(typingHints());
         let result = await providerResult(provider, param);
 
         assert.notEqual(result, null);
-        let actual: string[] = [];
-        result?.items.forEach((item) => { actual.push(item.label.trim()); });
-
+        const actual: string[] | undefined = result?.items.map(item => item.label.trim());
         assert.deepEqual(actual, expected);
     });
 
     test("provides type estimations + default items", async () => {
         let param = "param:";
-        let expected = Object.values(PythonType).length + 1;
+        let expected = ["Class"].concat(typeHints()).concat(typingHints());
+
         let result = await providerResult(provider, param, "\n\nparam = Class()");
-        assert.equal(result?.items.length, expected);
+
+        assert.notEqual(result, null);
+        const actual: string[] | undefined = result?.items.map(item => item.label.trim());
+        assert.deepEqual(actual, expected);
     });
 
     test("does not provide items unless a function def is detected", async () => {
@@ -176,4 +178,20 @@ async function provideCompletionItems(
     const ctx = { triggerCharacter: paramHintTrigger, triggerKind: vsc.CompletionTriggerKind.TriggerCharacter };
 
     return provider.provideCompletionItems(doc, pos, token, ctx);
-}
+}
+
+const typeHints = (): string[] => Object.values(PythonType).sort();
+
+const typingHints = (): string[] => {
+    const prefix = "typing.";
+    return [
+        `Dict[`,
+        `List[`,
+        `Set[`,
+        `Tuple[`,
+        `${prefix}Dict[`,
+        `${prefix}List[`,
+        `${prefix}Set[`,
+        `${prefix}Tuple[`
+    ];
+};