Update: Add check for node.body in referencer (#2)

* Add check for node.body in referencer

* Add comment explaining the node.body check

* Allow tests to run with babel

We will remove this soon but need to add tests for new features
in the mean time.

* Add typescript-eslint-parser as dev dependency

This used in tests for typescript features.

* Strict scope should be false when there is no body

This fixes an issue with typescript having an empty body
for some functions

* Add tests for typescript scope analysis

This includes a test for multiple call signatures.

* Add check for node.body in referencer

Add comment explaining the node.body check

Allow tests to run with babel

We will remove this soon but need to add tests for new features
in the mean time.

Add typescript-eslint-parser as dev dependency

This used in tests for typescript features.

Strict scope should be false when there is no body

This fixes an issue with typescript having an empty body
for some functions

Add tests for typescript scope analysis

This includes a test for multiple call signatures.

Add comment explaining the node.body check

Allow tests to run with babel

We will remove this soon but need to add tests for new features
in the mean time.

Strict scope should be false when there is no body

This fixes an issue with typescript having an empty body
for some functions

Add tests for typescript scope analysis

This includes a test for multiple call signatures.

Author: corbinu

package.json

@@ -48,6 +48,7 @@
     "gulp-sourcemaps": "^1.6.0",
     "gulp-tag-version": "^1.3.0",
     "lazypipe": "^1.0.1",
-    "vinyl-source-stream": "^1.1.0"
+    "vinyl-source-stream": "^1.1.0",
+    "typescript-eslint-parser": "^1.0.0"
   }
-}
+}

src/referencer.js

@@ -222,11 +222,15 @@ export default class Referencer extends esrecurse.Visitor {
             });
         }
 
-        // Skip BlockStatement to prevent creating BlockStatement scope.
-        if (node.body.type === Syntax.BlockStatement) {
-            this.visitChildren(node.body);
-        } else {
-            this.visit(node.body);
+        // In TypeScript there are a number of function-like constructs which have no body,
+        // so check it exists before traversing
+        if (node.body) {
+            // Skip BlockStatement to prevent creating BlockStatement scope.
+            if (node.body.type === Syntax.BlockStatement) {
+                this.visitChildren(node.body);
+            } else {
+                this.visit(node.body);
+            }
         }
 
         this.close(node);

src/scope.js

@@ -61,6 +61,10 @@ function isStrictScope(scope, block, isMethodDefinition, useDirective) {
         } else {
             body = block.body;
         }
+
+        if (!body) {
+            return false;
+        }
     } else if (scope.type === 'global') {
         body = block;
     } else {

test/typescript.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Typescript scope tests
+ * @author Reyad Attiyat
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+require("babel-register");
+
+const expect = require('chai').expect,
+    parse = require('typescript-eslint-parser').parse,
+    analyze = require('../src').analyze;
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe('typescript', () => {
+    describe('multiple call signatures', () => {
+        it('should create a function scope', () => {
+            const ast = parse(`
+                function foo(bar: number): number;
+                function foo(bar: string): string;
+                function foo(bar: string | number): string | number {
+                    return bar;
+                }
+            `);
+
+            const scopeManager = analyze(ast);
+
+            expect(scopeManager.scopes).to.have.length(4);
+
+            const globalScope = scopeManager.scopes[0];
+            expect(globalScope.type).to.be.equal('global');
+            expect(globalScope.variables).to.have.length(1);
+            expect(globalScope.references).to.have.length(0);
+            expect(globalScope.isArgumentsMaterialized()).to.be.true;
+
+            // Function scopes
+            let scope = scopeManager.scopes[1];
+            expect(scope.type).to.be.equal('function');
+            expect(scope.variables).to.have.length(2);
+            expect(scope.variables[0].name).to.be.equal('arguments');
+            expect(scope.isArgumentsMaterialized()).to.be.false;
+            expect(scope.references).to.have.length(0);
+
+            scope = scopeManager.scopes[2];
+            expect(scope.type).to.be.equal('function');
+            expect(scope.variables).to.have.length(2);
+            expect(scope.variables[0].name).to.be.equal('arguments');
+            expect(scope.isArgumentsMaterialized()).to.be.false;
+            expect(scope.references).to.have.length(0);
+
+            scope = scopeManager.scopes[3];
+            expect(scope.type).to.be.equal('function');
+            expect(scope.variables).to.have.length(2);
+            expect(scope.variables[0].name).to.be.equal('arguments');
+            expect(scope.isArgumentsMaterialized()).to.be.false;
+            expect(scope.references).to.have.length(1);
+
+
+        });
+    });
+});