tweak pause points (#5771)

Author: jasonLaster

.travis.yml

@@ -10,7 +10,7 @@ env:
   global:
     - DISPLAY=':99.0'
     - YARN_VERSION='0.24.5'
-    - MC_COMMIT='0b997836c7cf' # https://hg.mozilla.org/mozilla-central/shortlog
+    - MC_COMMIT='5bc910c1f477' # https://hg.mozilla.org/mozilla-central/shortlog
 
 notifications:
   slack:

src/test/mochitest/browser_dbg-sourcemaps.js

@@ -63,7 +63,7 @@ add_task(async function() {
 
   // Test breaking on a breakpoint
   await addBreakpoint(dbg, "entry.js", 15);
-  is(getBreakpoints(getState()).size, 2, "Two breakpoints exist");
+  is(getBreakpoints(getState()).size, 1, "One breakpoint exists");
   assertBreakpointExists(dbg, entrySrc, 15);
 
   invokeInTab("keepMeAlive");

src/workers/parser/pausePoints.js

@@ -1,6 +1,23 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
+
+// @flow
+
 import { traverseAst } from "./utils/ast";
 import * as t from "@babel/types";
 
+import type { AstLocation } from "./types";
+import type { BabelNode } from "@babel/types";
+import type { SimplePath } from "./utils/simple-path";
+
+export type PausePoint = {|
+  location: AstLocation,
+  types: {| breakpoint: boolean, stepOver: boolean |}
+|};
+
+export type PausePoints = PausePoint[];
+
 const isControlFlow = node =>
   t.isForStatement(node) || t.isWhileStatement(node) || t.isIfStatement(node);
 
@@ -15,69 +32,69 @@ const inExpression = parent =>
   t.isCallExpression(parent.node) ||
   t.isTemplateLiteral(parent.node);
 
-export function getPausePoints(sourceId) {
+export function getPausePoints(sourceId: string) {
   const state = [];
   traverseAst(sourceId, { enter: onEnter }, state);
   return state;
 }
 
-function formatNode(location, types) {
-  return { location, types };
-}
-
-function onEnter(node, ancestors, state) {
+function onEnter(node: BabelNode, ancestors: SimplePath[], state) {
   const parent = ancestors[ancestors.length - 1];
 
-  if (isAssignment(node) || isImport(node) || isControlFlow(node)) {
-    state.push(
-      formatNode(node.loc.start, { breakpoint: true, stepOver: true })
-    );
+  if (
+    isAssignment(node) ||
+    isImport(node) ||
+    isControlFlow(node) ||
+    t.isDebuggerStatement(node)
+  ) {
+    addPoint(state, node.loc.start);
   }
 
   if (isReturn(node)) {
     if (t.isCallExpression(node.argument)) {
-      state.push(
-        formatNode(node.loc.start, { breakpoint: false, stepOver: false })
-      );
+      addEmptyPoint(state, node.loc.start);
     } else {
-      state.push(
-        formatNode(node.loc.start, { breakpoint: true, stepOver: true })
-      );
+      addPoint(state, node.loc.start);
     }
   }
 
   if (t.isCallExpression(node)) {
-    state.push(
-      formatNode(node.loc.start, {
-        breakpoint: true,
-
-        // NOTE: we do not want to land inside an expression e.g. [], {}, call
-        stepOver: !inExpression(parent)
-      })
-    );
-  }
+    addPoint(state, node.loc.start, {
+      breakpoint: true,
 
-  if (t.isDebuggerStatement(node)) {
-    state.push(
-      formatNode(node.loc.start, { breakpoint: true, stepOver: true })
-    );
+      // NOTE: we do not want to land inside an expression e.g. [], {}, call
+      stepOver: !inExpression(parent)
+    });
   }
 
   if (t.isFunction(node)) {
     const { line, column } = node.loc.end;
-    state.push(formatNode(node.loc.start, { breakpoint: true }));
-    state.push(
-      formatNode(
-        { line, column: column - 1 },
-        { breakpoint: true, stepOver: true }
-      )
-    );
+    addBreakPoint(state, node.loc.start);
+    addPoint(state, { line, column: column - 1 });
   }
 
   if (t.isProgram(node)) {
     const lastStatement = node.body[node.body.length - 1];
-    state.push(
-      formatNode(lastStatement.loc.end, { breakpoint: true, stepOver: true })
-    );
+    addPoint(state, lastStatement.loc.end);
   }
 }
+
+function formatNode(location, types) {
+  return { location, types };
+}
+
+function addPoint(
+  state,
+  location,
+  types = { breakpoint: true, stepOver: true }
+) {
+  state.push(formatNode(location, types));
+}
+
+function addEmptyPoint(state, location) {
+  addPoint(state, location, { breakpoint: false, stepOver: false });
+}
+
+function addBreakPoint(state, location) {
+  addPoint(state, location, { breakpoint: true, stepOver: false });
+}