Fix bug and marketplace publishing

Author: njqdev

CONTRIBUTING.md

@@ -0,0 +1,56 @@
+# Contributing
+
+All contributions are welcome. For instance bug fixes, increased test coverage and new features.
+
+
+## Pull Requests
+
+* Open pull requests to the dev branch, not master.
+* Run the unit tests to ensure no existing functionality has been affected.
+* If applicable, write new unit tests to test your changes.
+* If applicable, update [README.md](https://github.com/njqdev/vscode-python-typehint/blob/master/README.md) to reflect your changes.
+
+
+## Contributor License Agreement
+
+All contributions are subject to the following DCO.
+
+```
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+1 Letterman Drive
+Suite D4700
+San Francisco, CA, 94129
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 nj-q
+Copyright (c) 2020 njqdev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -2,7 +2,8 @@
 
 Provides type hint auto-completion for Python, with completion items for built-in types, classes and the typing module.
 
-![](demo.gif)
+
+![](static/demo.gif)
 
 ## Features
 
@@ -20,7 +21,7 @@ Provides type hint auto-completion for Python, with completion items for built-i
 
 ## Installation
 
-The extension can be installed manually with this [VSIX file](https://github.com/nj-q/vscode-python-typehint/releases/tag/v1.0.0).
+The extension can found on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=njqdev.vscode-python-typehint).
 
 ## Known Issues
 

package.json

@@ -2,12 +2,12 @@
 	"name": "vscode-python-typehint",
     "displayName": "Python Type Hint",
     "version": "1.0.0",
-    "publisher": "nj-q",
+    "publisher": "njqdev",
     "description": "Type hint completion for Python.",
-    "icon": "images/icon.png",
+    "icon": "static/icon.png",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/nj-q/vscode-python-typehint"
+		"url": "https://github.com/njqdev/vscode-python-typehint"
 	},
     "license": "MIT",
 	"categories": [
@@ -17,8 +17,8 @@
         "Python",
         "typehint",
         "completion",
-        "type",
-        "hint"
+        "autocompletion",
+        "parameter"
     ],
     "engines": {
 		"vscode": "^1.43.0"

src/completionProvider.ts

@@ -12,21 +12,24 @@ import {
 } from "vscode";
 import { TypeHintProvider } from "./typeHintProvider";
 import { paramHintTrigger, returnHintTrigger, PythonType, anyClassOrFunctionName } from "./python";
-import { TypeHint, labelFor } from "./typeHint";
 import { TypeHintSettings } from "./settings";
 
 
 abstract class CompletionProvider {
 
     protected pushTypesToItems(typeNames: PythonType[], completionItems: CompletionItem[]) {
         for (const typeName of typeNames) {
-            const item = new CompletionItem(labelFor(typeName), CompletionItemKind.TypeParameter);
+            const item = new CompletionItem(this.labelFor(typeName), CompletionItemKind.TypeParameter);
 
             // Add 999 to ensure they're sorted to the bottom of the CompletionList.
             item.sortText = `999${typeName}`;
             completionItems.push(item);
         }
     }
+
+    protected labelFor(typeName: string): string {
+        return " " + typeName;
+    }
 }
 
 /**
@@ -53,7 +56,7 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
             const precedingText = line.text.substring(0, pos.character - 1).trim();
 
             if (this.shouldProvideItems(precedingText, pos, doc)) {
-                const param: string = this.findParam(precedingText, pos);
+                const param: string = this.findParam(precedingText);
                 const provider = new TypeHintProvider(doc, this.settings);
 
                 if (param.length > 0) {
@@ -73,10 +76,9 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
      * Finds the parameter which is about to be type hinted.
      * 
      * @param precedingText Text preceding the active position.
-     * @param pos The active position.
      * @returns The parameter.
      */
-    private findParam(precedingText: string, pos: Position): string {
+    private findParam(precedingText: string): string {
         let param = "";
 
         let i = precedingText.length - 1;
@@ -89,21 +91,17 @@ export class ParamHintCompletionProvider extends CompletionProvider implements C
         return param.trim();
     }
 
-    private pushEstimationsToItems(typeHints: TypeHint[], items: CompletionItem[]) {
+    private pushEstimationsToItems(typeHints: string[], items: CompletionItem[]) {
 
         if (typeHints.length > 0) {
-            let typeHint = typeHints[0].label;
-            let item = new CompletionItem(typeHint, CompletionItemKind.TypeParameter);
-            item.sortText = `0${typeHint}`;
+            let item = new CompletionItem(this.labelFor(typeHints[0]), CompletionItemKind.TypeParameter);
+            item.sortText = `0${typeHints[0]}`;
             item.preselect = true;
-            item.insertText = typeHints[0].insertText;
             items.push(item);
 
             for (let i = 1; i < typeHints.length; i++) {
-                typeHint = typeHints[i].label;
-                item = new CompletionItem(typeHint, CompletionItemKind.TypeParameter);
-                item.sortText = `${i}${typeHint}`;
-                item.insertText = typeHints[i].insertText;
+                item = new CompletionItem(this.labelFor(typeHints[i]), CompletionItemKind.TypeParameter);
+                item.sortText = `${i}${typeHints[i]}`;
                 items.push(item);
             }       
         }

src/typeHint.ts

@@ -3,7 +3,6 @@ import { PythonType as PythonType, DataTypeContainer, getDataTypeContainer } fro
 import { TypeSearch, VariableSearchResult } from "./typeSearch";
 import { TypingHintProvider } from "./typingHintProvider";
 import { WorkspaceSearcher } from "./workspaceSearcher";
-import { TypeHint, labelFor } from "./typeHint";
 import { TypeHintSettings } from "./settings";
 
 /**
@@ -21,7 +20,7 @@ export class TypeHintProvider {
         PythonType.Float
     ];
     private typeContainer: DataTypeContainer = getDataTypeContainer();
-    private typesIncludedInResult: { [key: string]: string } = {};
+    private typeNamesIncludedInResult: string[] = [];
     private doc: TextDocument;
     private settings: TypeHintSettings;
 
@@ -41,8 +40,8 @@ export class TypeHintProvider {
      * @param param The parameter name.
      * @returns An array of type hints, ordered by estimation accuracy.
      */
-    public async getTypeHints(param: string): Promise<TypeHint[]> {
-        const typeHints: TypeHint[] = [];
+    public async getTypeHints(param: string): Promise<string[]> {
+        const typeHints: string[] = [];
         const documentText = this.doc.getText();
 
         const typingHintProvider = new TypingHintProvider(documentText, this.typeContainer);
@@ -114,7 +113,7 @@ export class TypeHintProvider {
         return null;
     }
 
-    private typeGuessFor(param: string, typeHints: TypeHint[]): string | null {
+    private typeGuessFor(param: string, typeHints: string[]): string | null {
         const typeGuesses: { [key: string]: string } = {
             "string": PythonType.String,
             "text": PythonType.String,
@@ -132,18 +131,37 @@ export class TypeHintProvider {
         }
         return null;
     }
+
+
+    private add(typeName: string, typeHints: string[]) {
+        typeName = typeName.trim();
+        if (this.typeNotIncluded(typeName)) {
+            typeHints.push(typeName);
+            this.typeNamesIncludedInResult.push(typeName);
+        }
+    }
+            
+    private typeNotIncluded(type: string): boolean {
+        return !this.typeNamesIncludedInResult.includes(type);
+    }
+
+    private tryAdd(type: string | null, typeHints: string[]) {
+        if (type) {
+            this.add(type, typeHints);
+        }
+    }
 
     private tryAddTypingHints(
         typingFound: boolean,
         searchResult: VariableSearchResult | null,
         typingHintProvider: TypingHintProvider,
-        typeHints: TypeHint[]
+        typeHints: string[]
     ) {
         if (typingFound) {
-            const hints: TypeHint[] | null = typingHintProvider.getTypingHints(searchResult);
+            const hints: string[] | null = typingHintProvider.getTypingHints(searchResult);
             if (hints) {
                 for (const hint of hints) {
-                    this.addTypeHint(hint, typeHints);
+                    this.add(hint, typeHints);
                 }
             }
         }
@@ -153,37 +171,13 @@ export class TypeHintProvider {
         typingFound: boolean,
         typeName: string,
         typingHintProvider: TypingHintProvider,
-        typeHints: TypeHint[]
+        typeHints: string[]
     ) {
         if (typingFound) {
             const typingHint = typingHintProvider.getTypingHint(typeName);
             if (typingHint) {
-                this.addTypeHint(typingHint, typeHints);
+                this.add(typingHint, typeHints);
             }
         }
     }
-
-    private typeNotIncluded(type: string): boolean {
-        return !(type in this.typesIncludedInResult);
-    }
-
-    private add(type: string, typeHints: TypeHint[]) {
-        if (this.typeNotIncluded(type)) {
-            typeHints.push({ label: labelFor(type) });
-            this.typesIncludedInResult[type] = type;
-        }
-    }
-    
-    private addTypeHint(hint: TypeHint, typeHints: TypeHint[]) {
-        if (this.typeNotIncluded(hint.label)) {
-            typeHints.push(hint);
-            this.typesIncludedInResult[hint.label] = hint.label;
-        }
-    }
-
-    private tryAdd(type: string | null, typeHints: TypeHint[]) {
-        if (type) {
-            this.add(type, typeHints);
-        }
-    }
 }

src/typeHintProvider.ts

@@ -138,9 +138,9 @@ export class TypeSearch {
             }
         }
         searches.pop();
-        for (const e of searches) {
-            const typeName = e[0];
-            if (new RegExp(e[2]).test(value)) {
+        for (const s of searches) {
+            const typeName = s[0];
+            if (new RegExp(s[2]).test(value)) {
                 return typeName;
             }
         }