Merge pull request #17 from esnext-coverage/feat/visitors-hoist-functions

feat(visitors): hoist function declarations

Author: olegskl

src/visitors.js

@@ -173,13 +173,18 @@ export default safeguardVisitors({
     instrumentStatement(path, state);
   },
 
-  Function(path, state) {
-    if (path.node.kind === 'constructor') {
-      instrumentBlock('body', path.get('body'), state, ['function', 'constructor']);
-    } else {
-      instrumentBlock('body', path.get('body'), state, ['function']);
-    }
-    instrumentStatement(path, state);
+  FunctionExpression(path, state) {
+    instrumentBlock('body', path.get('body'), state, ['function']);
+  },
+
+  FunctionDeclaration(path, state) {
+    const loc = path.node.loc;
+    const marker = createMarker(state, {loc, tags: ['statement']});
+    path.findParent(parent => parent.isBlock())
+      .unshiftContainer('body', markAsInstrumented(
+        t.expressionStatement(marker)
+      ));
+    instrumentBlock('body', path.get('body'), state, ['function']);
   },
 
   // Source: x => {}
@@ -214,11 +219,18 @@ export default safeguardVisitors({
     instrumentObjectProperty(path, state);
   },
 
+  ClassProperty(path, state) {
+    instrumentClassProperty(path, state);
+  },
+
+  ClassMethod(path, state) {
+    instrumentBlock('body', path.get('body'), state, ['function']);
+  },
+
   ClassBody(path, state) {
     const parent = path.parentPath;
     const body = path.get('body');
     const methods = body.filter(node => node.isMethod());
-    const props = body.filter(node => !node.isMethod());
     const methodMarkers = methods.map(method => {
       const tags = ['statement', 'method'];
       const loc = method.node.loc;
@@ -237,10 +249,6 @@ export default safeguardVisitors({
         t.sequenceExpression([...methodMarkers, parent.node])
       ));
     }
-
-    props.forEach(prop => {
-      instrumentClassProperty(prop, state);
-    });
   }
 
 });

test/fixture/classes.fixture.js

@@ -5,7 +5,7 @@ class A {
   p = // one statement (executed twice)
     1; // one expression (executed twice)
   constructor() { // one statement
-    // one constructor function (executed twice)
+    // one function (executed twice)
   }
   foo() { // one statement
     // one method function

test/fixture/export-statements.fixture.js

@@ -2,6 +2,7 @@
 export const a = 'a'; // one expression
 
 // one export statement
+// one hoisted function declaration statement
 export function foo() {} // one function
 
 // one export statement

test/fixture/function-after-return.fixture.js

@@ -0,0 +1,10 @@
+// One statement:
+function foo() {
+  // One statement:
+  return bar();
+  // One statement:
+  function bar() {}
+}
+
+// One statement:
+foo();

test/spec/classes.spec.js

@@ -1,7 +1,6 @@
 import test from 'tape';
 import runFixture from './helpers/run';
 import {
-  isConstructor,
   isExpression,
   isStatement,
   isFunction
@@ -55,15 +54,6 @@ test('coverage should count expressions in classes', t => {
 // Class methods
 // --------------------
 
-test('coverage should count class constructors', t => {
-  t.plan(1);
-  runFixture('classes').then(locations => {
-    const constructorLocations = locations.filter(isConstructor);
-    // There is only one constructor:
-    t.equal(constructorLocations.length, 1);
-  });
-});
-
 test('coverage should count class methods and track their executions', t => {
   t.plan(3);
   runFixture('classes').then(locations => {

test/spec/exports.spec.js

@@ -25,7 +25,7 @@ test('coverage should count exports', t => {
 test('coverage should count exports as statements', t => {
   t.plan(2);
   runFixture('export-statements').then(locations => {
-    const exportStatements = locations.filter(isStatement);
+    const exportStatements = locations.filter(isExport).filter(isStatement);
     const executedOnceStatements = exportStatements
       .filter(el => el.count === 1);
 

test/spec/functions.spec.js

@@ -16,6 +16,25 @@ test('coverage should count function declarations', t => {
   });
 });
 
+test('coverage should count functions declared after return statment', t => {
+  t.plan(3);
+  runFixture('function-after-return').then(locations => {
+    const functionLocations = locations.filter(isFunction);
+    const statementLocations = locations.filter(isStatement);
+    const declaredOnceFunctionLocations = functionLocations
+      .filter(el => el.count === 1);
+    const executedOnceStatementLocations = statementLocations
+      .filter(el => el.count === 1);
+
+    // There are two functions:
+    t.equal(functionLocations.length, 2);
+    // Both functions have been declared once:
+    t.equal(declaredOnceFunctionLocations.length, 2);
+    // All statements have been executed once:
+    t.equal(executedOnceStatementLocations.length, 4);
+  });
+});
+
 test('coverage should count function executions', t => {
   t.plan(4);
   runFixture('function-executions').then(locations => {

test/spec/helpers/tag-assert.js

@@ -6,10 +6,6 @@ export function isFunction({tags}) {
   return tags.some(tag => tag === 'function');
 }
 
-export function isConstructor({tags}) {
-  return tags.some(tag => tag === 'constructor');
-}
-
 export function isBranch({tags}) {
   return tags.some(tag => tag === 'branch');
 }