[breakpoints] Use symbols from store (#5191)

Author: jasonLaster

src/actions/breakpoints/addBreakpoint.js

@@ -9,7 +9,7 @@ import {
   getASTLocation,
   assertLocation
 } from "../../utils/breakpoint";
-import { getSource } from "../../selectors";
+import { getSource, getSymbols } from "../../selectors";
 import { getGeneratedLocation } from "../../utils/source-maps";
 
 export default async function addBreakpoint(
@@ -50,7 +50,8 @@ export default async function addBreakpoint(
     newGeneratedLocation
   );
 
-  const astLocation = await getASTLocation(sourceRecord, newLocation);
+  const symbols = getSymbols(getState(), sourceRecord);
+  const astLocation = await getASTLocation(sourceRecord, symbols, newLocation);
 
   const newBreakpoint = {
     id,

src/utils/breakpoint/astBreakpointLocation.js

@@ -8,6 +8,7 @@ import { getSymbols } from "../../workers/parser";
 
 import type { Scope, AstPosition } from "../../workers/parser/types";
 import type { Location, Source, ASTLocation } from "debugger-html";
+import type { Symbols } from "../../reducers/types";
 
 export function containsPosition(a: AstPosition, b: AstPosition) {
   const startsBefore =
@@ -46,15 +47,15 @@ export function findClosestScope(functions: Scope[], location: Location) {
   }, null);
 }
 
-export async function getASTLocation(
+export function getASTLocation(
   source: Source,
+  symbols: Symbols,
   location: Location
-): Promise<ASTLocation> {
+): ASTLocation {
   if (source.isWasm) {
     return { name: undefined, offset: location };
   }
 
-  const symbols = await getSymbols(source);
   const functions = [...symbols.functions];
 
   const scope = findClosestScope(functions, location);

src/utils/breakpoint/tests/astBreakpointLocation.spec.js

@@ -1,57 +1,59 @@
 import { getASTLocation } from "../astBreakpointLocation.js";
 import { getSource } from "../../../workers/parser/tests/helpers";
-import * as I from "immutable";
-
-describe("ast", () => {
-  describe("valid location", () => {
-    it("returns the scope and offset", async () => {
-      const source = I.Map(getSource("math"));
-      const location = { line: 6, column: 0 };
-      const astLocation = await getASTLocation(source, location);
-      expect(astLocation.name).toBe("math");
-      expect(astLocation).toMatchSnapshot();
-    });
+import getSymbols from "../../../workers/parser/getSymbols";
+import cases from "jest-in-case";
 
-    it("returns name for a nested anon fn as the parent func", async () => {
-      const source = I.Map(getSource("outOfScope"));
-      const location = { line: 25, column: 0 };
-      const astLocation = await getASTLocation(source, location);
-      expect(astLocation.name).toBe("outer");
-      expect(astLocation).toMatchSnapshot();
-    });
+import * as I from "immutable";
 
-    it("returns name for a nested named fn", async () => {
-      const source = I.Map(getSource("outOfScope"));
-      const location = { line: 5, column: 0 };
-      const astLocation = await getASTLocation(source, location);
-      expect(astLocation.name).toBe("inner");
-      expect(astLocation).toMatchSnapshot();
-    });
+async function setup({ fileName, location, functionName }) {
+  const source = I.Map(getSource(fileName));
+  const symbols = getSymbols(source.toJS());
 
-    it("returns name for an anon fn with a named variable", async () => {
-      const source = I.Map(getSource("outOfScope"));
-      const location = { line: 40, column: 0 };
-      const astLocation = await getASTLocation(source, location);
-      expect(astLocation.name).toBe("globalDeclaration");
-      expect(astLocation).toMatchSnapshot();
-    });
-  });
+  const astLocation = getASTLocation(source, symbols, location);
+  expect(astLocation.name).toBe(functionName);
+  expect(astLocation).toMatchSnapshot();
+}
 
-  describe("invalid location", () => {
-    it("returns the scope name for global scope as undefined", async () => {
-      const source = I.Map(getSource("class"));
-      const location = { line: 10, column: 0 };
-      const astLocation = await getASTLocation(source, location);
-      expect(astLocation.name).toBe(undefined);
-      expect(astLocation).toMatchSnapshot();
-    });
+describe("ast", () => {
+  cases("valid location", setup, [
+    {
+      name: "returns the scope and offset",
+      fileName: "math",
+      location: { line: 6, column: 0 },
+      functionName: "math"
+    },
+    {
+      name: "returns name for a nested anon fn as the parent func",
+      fileName: "outOfScope",
+      location: { line: 25, column: 0 },
+      functionName: "outer"
+    },
+    {
+      name: "returns name for a nested named fn",
+      fileName: "outOfScope",
+      location: { line: 5, column: 0 },
+      functionName: "inner"
+    },
+    {
+      name: "returns name for an anon fn with a named variable",
+      fileName: "outOfScope",
+      location: { line: 40, column: 0 },
+      functionName: "globalDeclaration"
+    }
+  ]);
 
-    it("returns name for an anon fn in global scope as undefined", async () => {
-      const source = I.Map(getSource("outOfScope"));
-      const location = { line: 44, column: 0 };
-      const astLocation = await getASTLocation(source, location);
-      expect(astLocation.name).toBe(undefined);
-      expect(astLocation).toMatchSnapshot();
-    });
-  });
+  cases("invalid location", setup, [
+    {
+      name: "returns the scope name for global scope as undefined",
+      fileName: "class",
+      location: { line: 10, column: 0 },
+      functionName: undefined
+    },
+    {
+      name: "returns name for an anon fn in global scope as undefined",
+      fileName: "outOfScope",
+      location: { line: 44, column: 0 },
+      functionName: undefined
+    }
+  ]);
 });