fix: Be more friendly to ts-node. (#352)

ts-node gets angry when coverageData.hash is set after coverageData is
declared, add it to the initial object instead of setting it separately.

Also only output `Function` if a replacement is found in scope.

Fixes #336

packages/istanbul-lib-instrument/src/visitor.js

@@ -515,10 +515,13 @@ const codeVisitor = {
     ConditionalExpression: entries(coverTernary),
     LogicalExpression: entries(coverLogicalExpression)
 };
-const globalTemplateFunction = template(`
+const globalTemplateAlteredFunction = template(`
         var Function = (function(){}).constructor;
         var global = (new Function(GLOBAL_COVERAGE_SCOPE))();
 `);
+const globalTemplateFunction = template(`
+        var global = (new Function(GLOBAL_COVERAGE_SCOPE))();
+`);
 const globalTemplateVariable = template(`
         var global = GLOBAL_COVERAGE_SCOPE;
 `);
@@ -534,7 +537,6 @@ const coverageTemplate = template(`
         if (coverage[path] && coverage[path].hash === hash) {
             return coverage[path];
         }
-        coverageData.hash = hash;
         return coverage[path] = coverageData;
     })();
 `);
@@ -619,15 +621,25 @@ function programVisitor(
             const hash = createHash(SHA)
                 .update(JSON.stringify(coverageData))
                 .digest('hex');
+            coverageData.hash = hash;
             const coverageNode = T.valueToNode(coverageData);
             delete coverageData[MAGIC_KEY];
+            delete coverageData.hash;
             let gvTemplate;
             if (opts.coverageGlobalScopeFunc) {
-                gvTemplate = globalTemplateFunction({
-                    GLOBAL_COVERAGE_SCOPE: T.stringLiteral(
-                        'return ' + opts.coverageGlobalScope
-                    )
-                });
+                if (path.scope.getBinding('Function')) {
+                    gvTemplate = globalTemplateAlteredFunction({
+                        GLOBAL_COVERAGE_SCOPE: T.stringLiteral(
+                            'return ' + opts.coverageGlobalScope
+                        )
+                    });
+                } else {
+                    gvTemplate = globalTemplateFunction({
+                        GLOBAL_COVERAGE_SCOPE: T.stringLiteral(
+                            'return ' + opts.coverageGlobalScope
+                        )
+                    });
+                }
             } else {
                 gvTemplate = globalTemplateVariable({
                     GLOBAL_COVERAGE_SCOPE: opts.coverageGlobalScope

packages/istanbul-lib-instrument/test/util/verifier.js

@@ -73,7 +73,13 @@ class Verifier {
         );
         const initial = readInitialCoverage(this.getGeneratedCode());
         assert.ok(initial);
-        assert.deepEqual(initial.coverageData, this.result.emptyCoverage);
+        assert.deepEqual(
+            initial.coverageData,
+            Object.assign(
+                { hash: initial.coverageData.hash },
+                this.result.emptyCoverage
+            )
+        );
         assert.ok(initial.path);
         if (this.result.file) {
             assert.equal(initial.path, this.result.file);

packages/istanbul-lib-instrument/test/varia.test.js

@@ -202,6 +202,30 @@ describe('varia', () => {
         assert.ok(code.match(/cov_(.+);export class App extends/));
     });
 
+    it('declares Function when needed', () => {
+        const v = verifier.create(
+            'function Function() {}',
+            { generateOnly: true },
+            { esModules: true }
+        );
+        assert.ok(!v.err);
+
+        const code = v.getGeneratedCode();
+        assert.ok(code.match(/var Function\s*=/));
+    });
+
+    it('does not declare Function when not needed', () => {
+        const v = verifier.create(
+            'function differentFunction() {}',
+            { generateOnly: true },
+            { esModules: true }
+        );
+        assert.ok(!v.err);
+
+        const code = v.getGeneratedCode();
+        assert.ok(!code.match(/var Function\s*=/));
+    });
+
     it('does not add extra parenthesis when superclass is an identifier', () => {
         const v = verifier.create('class App extends Component {};', {
             generateOnly: true