feat(visitors): support blockless if-statements

 - `if (true); else if (false); else;` - empty statement branch
 - `if (true) true; else if (false) false; else null;` - blockless statements

Author: olegskl

src/instrumenters.js

@@ -51,3 +51,26 @@ export function instrumentClassProperty(path, state, tags = ['statement', 'prope
   const marker = createMarker(state, {loc, tags}, node);
   value.replaceWith(marker);
 }
+
+export function instrumentConditionBranch(path, state, tags = ['branch']) {
+  if (path.isBlockStatement()) {
+    // before: if (true) {};
+    // after: if (true) { instrument(0); };
+    instrumentBlock('body', path, state, tags);
+  } else if (path.isEmptyStatement()) {
+    // before: if (true);
+    // after: if (true) instrument(0);
+    const marker = createMarker(state, {loc: path.node.loc, tags});
+    path.replaceWith(markAsInstrumented(
+      t.expressionStatement(marker)
+    ));
+  } else {
+    // before: if (true) true;
+    // after: if (true) { instrument(0); true; }
+    const branchBody = t.blockStatement([path.node]);
+    const locEnd = path.node.loc.end;
+    branchBody.loc = {start: locEnd, end: locEnd};
+    path.replaceWith(markAsInstrumented(branchBody));
+    instrumentBlock('body', path, state, tags);
+  }
+}

src/visitors.js

@@ -6,6 +6,7 @@ import {
   instrumentExpression,
   instrumentObjectProperty,
   instrumentClassProperty,
+  instrumentConditionBranch,
   isInstrumentableStatement
 } from './instrumenters';
 
@@ -111,25 +112,23 @@ export default safeguardVisitors({
   // Source: if (true) {}
   // Instrumented: ++count; if (++count, true) { ++count; } else { ++count; }
   IfStatement(path, state) {
-    // There is always a "consequent" branch:
-    instrumentBlock('body', path.get('consequent'), state, ['branch']);
-
-    // An "alternate" branch may exist:
-    const alternate = path.get('alternate');
-    if (alternate.isBlockStatement()) {
-      instrumentBlock('body', path.get('alternate'), state, ['branch']);
-    } else if (!alternate.isIfStatement()) {
-      const body = t.blockStatement([]);
-      const locEnd = path.node.loc.end;
-      body.loc = {start: locEnd, end: locEnd};
-      alternate.replaceWith(body);
-      instrumentBlock('body', alternate, state, ['branch']);
-    }
-
     // We want to instrument entire if-statements as statements:
     if (path.key !== 'alternate') {
       instrumentStatement(path, state);
     }
+
+    // Consequent branch:
+    instrumentConditionBranch(path.get('consequent'), state, ['branch']);
+
+    // Alternate branch:
+    if (!path.has('alternate')) {
+      const placeholder = t.emptyStatement();
+      placeholder.loc = {start: path.node.loc.end, end: path.node.loc.end};
+      path.get('alternate').replaceWith(placeholder);
+      instrumentConditionBranch(path.get('alternate'), state, ['branch']);
+    } else if (!path.get('alternate').isIfStatement()) {
+      instrumentConditionBranch(path.get('alternate'), state, ['branch']);
+    }
   },
 
   // Source: case 'a':

test/fixture/if-statements-empty.fixture.js

@@ -0,0 +1,5 @@
+/* eslint-disable */
+
+if (true); // one branch (taken)
+else if (false); // one branch (not taken)
+else; // one branch (not taken)

test/fixture/if-statements-no-block.fixture.js

@@ -0,0 +1,5 @@
+/* eslint-disable */
+
+if (true) true; // one branch (taken)
+else if (false) false; // one branch (not taken)
+else null; // one branch (not taken)

test/spec/if-statements.spec.js

@@ -34,6 +34,42 @@ test('coverage should count if-statement branches', t => {
   });
 });
 
+test('coverage should count empty branches in if-statements', t => {
+  t.plan(3);
+  runFixture('if-statements-empty').then(({locations}) => {
+    const branchLocations = locations.filter(isBranch);
+    const executedOnceBranchLocations = branchLocations
+      .filter(l => l.count === 1);
+    const executedNeverBranchLocations = branchLocations
+      .filter(l => l.count === 0);
+
+    // There are three branches (all implicit):
+    t.equal(branchLocations.length, 3);
+    // Only one of the three branches has actually run:
+    t.equal(executedOnceBranchLocations.length, 1);
+    // Other two branches have never run:
+    t.equal(executedNeverBranchLocations.length, 2);
+  });
+});
+
+test('coverage should count blockless branches in if-statements', t => {
+  t.plan(3);
+  runFixture('if-statements-no-block').then(({locations}) => {
+    const branchLocations = locations.filter(isBranch);
+    const executedOnceBranchLocations = branchLocations
+      .filter(l => l.count === 1);
+    const executedNeverBranchLocations = branchLocations
+      .filter(l => l.count === 0);
+
+    // There are three branches (all implicit):
+    t.equal(branchLocations.length, 3);
+    // Only one of the three branches has actually run:
+    t.equal(executedOnceBranchLocations.length, 1);
+    // Other two branches have never run:
+    t.equal(executedNeverBranchLocations.length, 2);
+  });
+});
+
 test('coverage should count missing alternate branches in if-statements', t => {
   t.plan(2);
   runFixture('if-statements-no-alternate').then(({locations}) => {