Update: add proper scope analysis (fixes #535)

analyze-scope.js

@@ -89,14 +89,23 @@ class Referencer extends OriginalReferencer {
                 id,
                 new Definition("FunctionName", id, node, null, null, null)
             );
+
+            // Remove overload definition to avoid confusion of no-redeclare rule.
+            const { defs, identifiers } = upperScope.set.get(id.name);
+            for (let i = 0; i < defs.length; ++i) {
+                const def = defs[i];
+                if (def.type === "FunctionName" && def.node.type === "TSEmptyBodyFunctionDeclaration") {
+                    defs.splice(i, 1);
+                    identifiers.splice(i, 1);
+                    break;
+                }
+            }
         } else if (type === "FunctionExpression" && id) {
             scopeManager.__nestFunctionExpressionNameScope(node);
         }
 
         // Process the type parameters
-        if (typeParameters) {
-            this.visit(typeParameters);
-        }
+        this.visit(typeParameters);
 
         // Open the function scope.
         scopeManager.__nestFunctionScope(node, this.isInnerMethodDefinition);
@@ -128,17 +137,13 @@ class Referencer extends OriginalReferencer {
         }
 
         // Process the return type.
-        if (returnType) {
-            this.visit(returnType);
-        }
+        this.visit(returnType);
 
         // Process the body.
-        if (body) {
-            if (body.type === "BlockStatement") {
-                this.visitChildren(body);
-            } else {
-                this.visit(body);
-            }
+        if (body.type === "BlockStatement") {
+            this.visitChildren(body);
+        } else {
+            this.visit(body);
         }
 
         // Close the function scope.
@@ -147,15 +152,37 @@ class Referencer extends OriginalReferencer {
 
     /**
      * Override.
-     * Ignore it in the type mode.
+     * Visit decorators.
+     * @param {ClassDeclaration|ClassExpression} node The class node to visit.
+     * @returns {void}
+     */
+    visitClass(node) {
+        this.visitDecorators(node.decorators);
+        super.visitClass(node);
+    }
+
+    /**
+     * Override.
+     * Don't create the reference object in the type mode.
      * @param {Identifier} node The Identifier node to visit.
      * @returns {void}
      */
     Identifier(node) {
-        if (this.typeMode) {
-            return;
+        if (!this.typeMode) {
+            super.Identifier(node);
         }
-        super.Identifier(node);
+        this.visit(node.typeAnnotation);
+    }
+
+    /**
+     * Override.
+     * Visit decorators.
+     * @param {MethodDefinition} node The MethodDefinition node to visit.
+     * @returns {void}
+     */
+    MethodDefinition(node) {
+        this.visitDecorators(node.decorators);
+        super.MethodDefinition(node);
     }
 
     /**
@@ -177,6 +204,74 @@ class Referencer extends OriginalReferencer {
         this.typeMode = false;
     }
 
+    /**
+     * Don't create the reference object for the key if not computed.
+     * @param {TSEmptyBodyFunctionDeclaration} node The TSEmptyBodyFunctionDeclaration node to visit.
+     * @returns {void}
+     */
+    ClassProperty(node) {
+        const upperTypeMode = this.typeMode;
+        const { computed, decorators, key, typeAnnotation, value } = node;
+
+        this.typeMode = false;
+        this.visitDecorators(decorators);
+        if (computed) {
+            this.visit(key);
+        }
+        this.typeMode = true;
+        this.visit(typeAnnotation);
+        this.typeMode = false;
+        this.visit(value);
+
+        this.typeMode = upperTypeMode;
+    }
+
+    /**
+     * Define the variable of this function declaration only once.
+     * Because to avoid confusion of `no-redeclare` rule by overloading.
+     * @param {TSEmptyBodyFunctionDeclaration} node The TSEmptyBodyFunctionDeclaration node to visit.
+     * @returns {void}
+     */
+    TSEmptyBodyFunctionDeclaration(node) {
+        const upperTypeMode = this.typeMode;
+        const scope = this.currentScope();
+        const { id, typeParameters, params, returnType } = node;
+
+        // Ignore this if other overloadings have already existed.
+        const variable = scope.set.get(id.name);
+        const defs = variable && variable.defs;
+        const existed = defs && defs.some(d => d.type === "FunctionName");
+        if (!existed) {
+            scope.__define(
+                id,
+                new Definition("FunctionName", id, node, null, null, null)
+            );
+        }
+
+        // Find `typeof` expressions.
+        this.typeMode = true;
+        this.visit(typeParameters);
+        params.forEach(this.visit, this);
+        this.visit(returnType);
+        this.typeMode = upperTypeMode;
+    }
+
+    /**
+     * Create reference objects for the references in parameters and return type.
+     * @param {TSEmptyBodyFunctionExpression} node The TSEmptyBodyFunctionExpression node to visit.
+     * @returns {void}
+     */
+    TSEmptyBodyFunctionExpression(node) {
+        const upperTypeMode = this.typeMode;
+        const { typeParameters, params, returnType } = node;
+
+        this.typeMode = true;
+        this.visit(typeParameters);
+        params.forEach(this.visit, this);
+        this.visit(returnType);
+        this.typeMode = upperTypeMode;
+    }
+
     /**
      * Don't make variable because it declares only types.
      * Switch to the type mode and visit child nodes to find `typeof x` expression in type declarations.
@@ -224,7 +319,7 @@ class Referencer extends OriginalReferencer {
     }
 
     /**
-     * Create reference objects for the references are in `typeof` expression.
+     * Create reference objects for the references in `typeof` expression.
      * @param {TSTypeQuery} node The TSTypeQuery node to visit.
      * @returns {void}
      */
@@ -238,6 +333,53 @@ class Referencer extends OriginalReferencer {
         }
     }
 
+    /**
+     * Create reference objects for the references in computed keys.
+     * @param {TSPropertySignature} node The TSPropertySignature node to visit.
+     * @returns {void}
+     */
+    TSPropertySignature(node) {
+        const upperTypeMode = this.typeMode;
+        const { computed, key, typeAnnotation, initializer } = node;
+
+        if (computed) {
+            this.typeMode = false;
+            this.visit(key);
+            this.typeMode = true;
+        } else {
+            this.typeMode = true;
+            this.visit(key);
+        }
+        this.visit(typeAnnotation);
+        this.visit(initializer);
+
+        this.typeMode = upperTypeMode;
+    }
+
+    /**
+     * Create reference objects for the references in computed keys.
+     * @param {TSMethodSignature} node The TSMethodSignature node to visit.
+     * @returns {void}
+     */
+    TSMethodSignature(node) {
+        const upperTypeMode = this.typeMode;
+        const { computed, key, typeParameters, params, typeAnnotation } = node;
+
+        if (computed) {
+            this.typeMode = false;
+            this.visit(key);
+            this.typeMode = true;
+        } else {
+            this.typeMode = true;
+            this.visit(key);
+        }
+        this.visit(typeParameters);
+        params.forEach(this.visit, this);
+        this.visit(typeAnnotation); // Maybe returnType?
+
+        this.typeMode = upperTypeMode;
+    }
+
     /**
      * Create variable object for the enum.
      * The enum declaration creates a scope for the enum members.
@@ -296,6 +438,17 @@ class Referencer extends OriginalReferencer {
             this.visit(initializer);
         }
     }
+
+    /**
+     * Process decorators.
+     * @param {Decorator[]|undefined} decorators The decorator nodes to visit.
+     * @returns {void}
+     */
+    visitDecorators(decorators) {
+        if (decorators) {
+            decorators.forEach(this.visit, this);
+        }
+    }
 }
 
 module.exports = function(ast, parserOptions, extraOptions) {

tests/fixtures/scope-analysis/class-properties.ts

@@ -0,0 +1,5 @@
+const s = Symbol()
+class A {
+    a: typeof s
+    [s]: number
+}

tests/fixtures/scope-analysis/computed-properties-in-interface.ts

@@ -0,0 +1,5 @@
+const s1 = Symbol(), s2 = Symbol()
+interface A {
+    [s1]: number
+    [s2](s1: number, s2: number): number;
+}

tests/fixtures/scope-analysis/computed-properties-in-type.ts

@@ -0,0 +1,5 @@
+const s1 = Symbol(), s2 = Symbol()
+type A = {
+    [s1]: number
+    [s2](s1: number, s2: number): number;
+}

tests/fixtures/scope-analysis/decorators.ts

@@ -0,0 +1,13 @@
+function dec(target: any) {
+}
+function gec() {
+    return (target: any, proeprtyKey: string) => {}
+}
+
+@dec
+class C {
+    @gec() field: string
+    @gec() method(): string {
+        return ""
+    }
+}

tests/fixtures/scope-analysis/function-overload-2.ts

@@ -0,0 +1,2 @@
+function f(): void
+function f(a: number): void

tests/fixtures/scope-analysis/function-overload.ts

@@ -0,0 +1,5 @@
+function f(): void
+function f(a: number): void
+function f(a?: number): void {
+    // do something.
+}

tests/fixtures/scope-analysis/method-overload.ts

@@ -0,0 +1,8 @@
+const s = Symbol()
+class A {
+    f(): void
+    f(a: typeof s): void
+    f(a?: any): void {
+        // do something.
+    }
+}