Cleanup

Author: njqdev

src/completionProvider.ts

@@ -75,7 +75,7 @@ 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 precedingText The text before the active position.
      * @returns The parameter.
      */
     private findParam(precedingText: string): string {

src/python.ts

@@ -17,6 +17,9 @@ export class DataType {
     }
 }
 
+/**
+ * Container with type name keys and data type values.
+ */
 export interface DataTypeContainer {
      [key: string]: DataType 
 };

src/settings.ts

@@ -1,5 +1,8 @@
-import { workspace, Event, EventEmitter, window } from "vscode";
+import { workspace, Event, EventEmitter } from "vscode";
 
+/**
+ * Container of user settings.
+ */
 export class TypeHintSettings {
 
     private searchLimit = 20;

src/test/suite/common.ts

@@ -1,11 +1,10 @@
 
 
 export const getErrorMessage = (
-    testCase: string,
-    expected: any,
+    testCase: TestCase,
     actual: any
 ): string => {
-   return `${actual} == ${expected}. \n[Test case]: ${testCase}`;
+   return `${actual} == ${testCase.expected}. \n[Test data]: ${testCase.data}`;
 };
 
 export interface TestCase {

src/test/suite/typeSearch/detection.test.ts

@@ -9,23 +9,23 @@ suite('CodeSearch.detectType', function() {
 
         let src = "11";
         let actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "-11";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "0b10";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "0o10";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "0x10";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
 
@@ -34,19 +34,19 @@ suite('CodeSearch.detectType', function() {
 
         let src = "12.3";
         let actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = ".3";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "-.3";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "1 + 2 - 1 * 2 /  2.0";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("detects complex numbers", async () => {
@@ -63,31 +63,31 @@ suite('CodeSearch.detectType', function() {
 
         let src = "'test'";
         let actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "\"test\"'";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "('test')";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "'''t\nest''')";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("detects bools", async () => {
         const expected = "bool";
 
         let src = "True";
         let actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "False";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("detects lists", async () => {
@@ -103,27 +103,27 @@ suite('CodeSearch.detectType', function() {
 
         let src = "{ 5: 'j'}";
         let actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "{ (1,2): (3) }";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "{'':11}";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("detects tuples", async () => {
         const expected = "tuple";
 
         let src = "('dont return str please', 'ok')";
         let actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = " ( '4' , '5' )";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("detects sets", async () => {
@@ -135,14 +135,14 @@ suite('CodeSearch.detectType', function() {
 
         src = "{1, 2}";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "{1 , 2}";
         actual = TypeSearch.detectType(src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
-    test("detects type() call", async () => {
+    test("detects type() call", () => {
         const testCases: TestCase[] = [
             { data: "int('2')", expected: "int"},
             { data: "bool(true)", expected: "bool"},
@@ -153,7 +153,7 @@ suite('CodeSearch.detectType', function() {
             { data: "set([1])", expected: "set"}
         ];
         for (const c of testCases) {
-            let actual = await TypeSearch.detectType(c.data);
+            let actual = TypeSearch.detectType(c.data);
             assert.equal(actual, c.expected);
         }
     });
@@ -176,7 +176,7 @@ suite('CodeSearch.variableWithSameName', function() {
         let param = "var";
         let actual = await TypeSearch.variableWithSameName(param, src);
 
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("detects variable types if initialized in the document", async () => {
@@ -187,25 +187,25 @@ suite('CodeSearch.variableWithSameName', function() {
         let src = `${line}\n\ndef main():\n\tx = 5`;
         let param = "var";
         let actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
 
         // Variable with the same name initialized below
         src = `x = 5\n${line}`;
         actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("considers value to be an object initializtion if title case", async () => {
         let expected = "TestClass";
         let src = `var = ${expected}(x)`;
         let param = "var";
         let actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
 
         expected = "test.test.TestClass";
         src = `var = ${expected}(x)`;
         actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("returns null for title case functions (if the function is defined in the document)", async () => {
@@ -215,27 +215,27 @@ suite('CodeSearch.variableWithSameName', function() {
         let src = `def Func(x):\n\tpass\n\n${line}`;
         let param = "var";
         let actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("detects function return values if type hinted", async () => {
         const expected = "int";
         let src = "def test() -> int:\n\treturn 1\n\nvar = test()";
         let param = "var";
         let actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
 
         src = "def test(self) -> int:\n\treturn 1\n\nvar = cls.test()";
         actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("doesn't consider function calls to be variables", async () => {
         const expected = null;
         let src = `obj = call()`;
         let param = "var";
         let actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("ignores single-line comments", async () => {
@@ -244,6 +244,6 @@ suite('CodeSearch.variableWithSameName', function() {
         let src = `# obj = 5\n${line}`;
         let param = "var";
         let actual = await TypeSearch.variableWithSameName(param, src);
-        assert.equal(actual?.typeName, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual?.typeName, expected, getErrorMessage({ data: src, expected }, actual));
     });
 });

src/test/suite/typeSearch/findImport.test.ts

@@ -37,12 +37,12 @@ suite('CodeSearch.findImport', function() {
         let expected = "Type";
         let src = "from module import " + expected;
         let actual = TypeSearch.findImport(detectedType, src, false);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
 
         detectedType = "package.x.y_test.Type";
         src = "from package.x.y_test import " + expected;
         actual = TypeSearch.findImport(detectedType, src, false);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected, getErrorMessage({ data: src, expected }, actual));
     });
 
     test("object.Type --> returns object.Type for from X import object", () => {

src/test/suite/typeSearch/hintOfSimilarParam.test.ts

@@ -9,7 +9,7 @@ suite('CodeSearch.hintOfSimilarParam', function() {
         const param = "test";
         let src = `def func(${param}: str):\ndef test(self, ${param}:`;
         let actual = TypeSearch.hintOfSimilarParam(param, src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected);
     });
 
     test("finds param with preceding parameters", () => {
@@ -18,7 +18,7 @@ suite('CodeSearch.hintOfSimilarParam', function() {
 
         let src = `def func(self, p1: int,${param}: str):\ndef test(self, ${param}:`;
         let actual = TypeSearch.hintOfSimilarParam(param, src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected);
     });
 
     test("finds param with trailing parameters", () => {
@@ -27,7 +27,7 @@ suite('CodeSearch.hintOfSimilarParam', function() {
 
         let src = `def func(self, ${param}: str,new: int):\ndef test(self, ${param}:`;
         let actual = TypeSearch.hintOfSimilarParam(param, src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected);
     });
 
     test("handles line breaks in function definition", () => {
@@ -36,7 +36,7 @@ suite('CodeSearch.hintOfSimilarParam', function() {
 
         let src = `def func(\n\t${param}: str,new: int):\ndef test(self, ${param}:`;
         let actual = TypeSearch.hintOfSimilarParam(param, src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected);
     });
 
     test("doesn't match param name within other text", () => {
@@ -45,7 +45,7 @@ suite('CodeSearch.hintOfSimilarParam', function() {
 
         let src = `def func(text${param}: str,new: int):\ndef test(self, text${param}:`;
         let actual = TypeSearch.hintOfSimilarParam(param, src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected);
     });
 
     test("excludes default values", () => {
@@ -54,6 +54,6 @@ suite('CodeSearch.hintOfSimilarParam', function() {
 
         let src = `def func(${param}: str = 'exclude',new: int):\ndef test(self, text${param}:`;
         let actual = TypeSearch.hintOfSimilarParam(param, src);
-        assert.equal(actual, expected, getErrorMessage(src, expected, actual));
+        assert.equal(actual, expected);
     });
 });

src/typeHintProvider.ts

@@ -28,6 +28,7 @@ export class TypeHintProvider {
      * Constructs a new TypeHintProvider.
      * 
      * @param doc The active document.
+     * @param settings User settings.
      */
     constructor(doc: TextDocument, settings: TypeHintSettings) {
         this.doc = doc;

src/typeSearch.ts

@@ -27,7 +27,6 @@ export class VariableSearchResult {
 }
 
 export class TypeSearch {
-
 
     /**
      * Searches for a class with the same name as object and returns the name if found.
@@ -84,14 +83,12 @@ export class TypeSearch {
 
                 const hintedCallMatch = regExp.exec(documentText);
 
-                if (hintedCallMatch) {
-                    if (hintedCallMatch.length === 2) {
-                        return new VariableSearchResult(
-                            hintedCallMatch[1],
-                            EstimationSource.FunctionDefinition,
-                            valueAssignment
-                        );
-                    }
+                if (hintedCallMatch && hintedCallMatch.length === 2) {
+                    return new VariableSearchResult(
+                        hintedCallMatch[1],
+                        EstimationSource.FunctionDefinition,
+                        valueAssignment
+                    );
                 }
             }
             return null;
@@ -110,7 +107,7 @@ export class TypeSearch {
         return null;
     }
 
-        /**
+    /**
      * Detects the type of a value, if it is a built in Python type.
      * 
      * @returns The type name or null if not found.
@@ -226,8 +223,6 @@ export class TypeSearch {
 
     /**
      * Detects if an object is imported.
-     * 
-     * @returns The imported value.
      */
     private static isImported(object: string, documentText: string, checkForAsImports: boolean = true): boolean {