[scopes] Add 'findOriginalFunctionName' method

This CL adds a new method that takes a generated position and spits out
the original function name of the surrounding function.

The method works with both GeneratedRanges and mappings. The
reason for this is twofold: "pasta" source map scopes only have
"OriginalScopes" and no generated ranges. And the proposed extension
API in https://crrev.com/c/5774044 also does not contain generated
ranges.

In both of these cases the implementation utilizes the normal source
map "mappings" to get to the original function scope.

As a follow-up, we'll consolidate the "ScopesEntry" interface (for
"pasta" source maps) and the "SourceMapScopesInfo" class (for the
official "scopes" proposal). We'll do this by converting the "pasta"
scopes into "OriginalScope" trees.

Bug: 40277685
Change-Id: I1a50eaca5c719616db3c2f7eb4e0227cddee2e2f
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6108439
Reviewed-by: Alex Rudenko <[email protected]>
Commit-Queue: Simon Zünd <[email protected]>

Author: szuend

front_end/core/sdk/SourceMapScopesInfo.test.ts

@@ -737,4 +737,88 @@ describe('SourceMapScopesInfo', () => {
       }
     });
   });
+
+  describe('findOriginalFunctionName', () => {
+    const [scopeInfoWithRanges, scopeInfoWithMappings] = (function() {
+      // Separate sandbox, otherwise global beforeEach/afterAll will reset our source map.
+      const sandbox = sinon.createSandbox();
+      const sourceMap = sandbox.createStubInstance(SDK.SourceMap.SourceMap);
+      sourceMap.findEntry.callsFake((line, column) => {
+        assert.strictEqual(line, 0);
+        switch (column) {
+          case 10:
+            return new SDK.SourceMap.SourceMapEntry(
+                line, column, /* sourceIndex */ 0, /* sourceUrl */ undefined, /* sourceLine */ 5, /* sourceColumn */ 0);
+          case 30:
+            return new SDK.SourceMap.SourceMapEntry(
+                line, column, /* sourceIndex */ 0, /* sourceUrl */ undefined, /* sourceLine */ 15,
+                /* sourceColumn */ 2);
+          case 50:
+            return new SDK.SourceMap.SourceMapEntry(
+                line, column, /* sourceIndex */ 0, /* sourceUrl */ undefined, /* sourceLine */ 25,
+                /* sourceColumn */ 4);
+          case 110:
+            return new SDK.SourceMap.SourceMapEntry(
+                line, column, /* sourceIndex */ 0, /* sourceUrl */ undefined, /* sourceLine */ 55,
+                /* sourceColumn */ 2);
+          case 150:
+            return null;
+        }
+        return null;
+      });
+      const names: string[] = [];
+      const originalScopes = [new OriginalScopeBuilder(names)
+                                  .start(0, 0, {kind: 'global'})
+                                  .start(10, 10, {kind: 'function', name: 'myAuthoredFunction', isStackFrame: true})
+                                  .start(20, 15, {kind: 'block'})
+                                  .end(30, 3)
+                                  .end(40, 1)
+                                  .start(50, 10, {kind: 'function', isStackFrame: true})
+                                  .end(60, 1)
+                                  .end(70, 0)
+                                  .build()];
+      const scopeInfoWithMappings =
+          SourceMapScopesInfo.parseFromMap(sourceMap, {names, originalScopes, generatedRanges: ''});
+      const generatedRanges = new GeneratedRangeBuilder(names)
+                                  .start(0, 0, {definition: {sourceIdx: 0, scopeIdx: 0}})
+                                  .start(0, 20, {definition: {sourceIdx: 0, scopeIdx: 1}})
+                                  .start(0, 40, {definition: {sourceIdx: 0, scopeIdx: 2}})
+                                  .end(0, 60)
+                                  .end(0, 80)
+                                  .start(0, 100, {definition: {sourceIdx: 0, scopeIdx: 5}})
+                                  .end(0, 120)
+                                  .start(0, 140)
+                                  .end(0, 160)
+                                  .end(0, 180)
+                                  .build();
+      const scopeInfoWithRanges = SourceMapScopesInfo.parseFromMap(sourceMap, {names, originalScopes, generatedRanges});
+      return [scopeInfoWithRanges, scopeInfoWithMappings];
+    })();
+
+    [{name: 'with GeneratedRanges', scopeInfo: scopeInfoWithRanges},
+     {name: 'with mappings', scopeInfo: scopeInfoWithMappings},
+    ].forEach(({name, scopeInfo}) => {
+      describe(name, () => {
+        it('provides the original name for a position inside a function', () => {
+          assert.strictEqual(scopeInfo.findOriginalFunctionName({line: 0, column: 30}), 'myAuthoredFunction');
+        });
+
+        it('provides the original name for a position inside a block scope of a function', () => {
+          assert.strictEqual(scopeInfo.findOriginalFunctionName({line: 0, column: 50}), 'myAuthoredFunction');
+        });
+
+        it('returns null for a position inside the global scope', () => {
+          assert.isNull(scopeInfo.findOriginalFunctionName({line: 0, column: 10}));
+        });
+
+        it('returns null for a position inside a range with no corresponding original scope', () => {
+          assert.isNull(scopeInfo.findOriginalFunctionName({line: 0, column: 150}));
+        });
+
+        it('returns the empty string for an unnamed function (not null)', () => {
+          assert.strictEqual(scopeInfo.findOriginalFunctionName({line: 0, column: 110}), '');
+        });
+      });
+    });
+  });
 });

front_end/core/sdk/SourceMapScopesInfo.ts

@@ -13,6 +13,7 @@ import {
   type GeneratedRange,
   type OriginalPosition,
   type OriginalScope,
+  type Position,
 } from './SourceMapScopes.js';
 
 export class SourceMapScopesInfo {
@@ -32,7 +33,7 @@ export class SourceMapScopesInfo {
   static parseFromMap(
       sourceMap: SourceMap,
       sourceMapJson: Pick<SourceMapV3Object, 'names'|'originalScopes'|'generatedRanges'>): SourceMapScopesInfo {
-    if (!sourceMapJson.originalScopes || !sourceMapJson.generatedRanges) {
+    if (!sourceMapJson.originalScopes || sourceMapJson.generatedRanges === undefined) {
       throw new Error('Cant create SourceMapScopesInfo without encoded scopes');
     }
     const scopeTrees = decodeOriginalScopes(sourceMapJson.originalScopes, sourceMapJson.names ?? []);
@@ -234,6 +235,67 @@ export class SourceMapScopesInfo {
 
     return rangeChain;
   }
+
+  /**
+   * Returns the authored function name of the function containing the provided generated position.
+   */
+  findOriginalFunctionName({line, column}: Position): string|null {
+    // There are 2 approaches:
+    //   1) Find the inner-most generated range containing the provided generated position
+    //      and use it's OriginalScope (then walk it outwards until we hit a function).
+    //   2) Use the mappings to turn the generated position into an original position.
+    //      Then find the inner-most original scope containing that original position.
+    //      Then walk it outwards until we hit a function.
+    //
+    // Both approaches should yield the same result (assuming the mappings are spec compliant
+    // w.r.t. generated ranges). But in the case of "pasta" scopes and extension provided
+    // scope info, we only have the OriginalScope parts and mappings without GeneratedRanges.
+
+    let originalInnerMostScope: OriginalScope|undefined;
+
+    if (this.#generatedRanges.length > 0) {
+      const rangeChain = this.#findGeneratedRangeChain(line, column);
+      originalInnerMostScope = rangeChain.at(-1)?.originalScope;
+    } else {
+      // No GeneratedRanges. Try to use mappings.
+      const entry = this.#sourceMap.findEntry(line, column);
+      if (entry === null || entry.sourceIndex === undefined) {
+        return null;
+      }
+      originalInnerMostScope =
+          this.#findOriginalScopeChain(
+                  {sourceIndex: entry.sourceIndex, line: entry.sourceLineNumber, column: entry.sourceColumnNumber})
+              .at(-1);
+    }
+
+    // Walk the original scope chain outwards until we find a function.
+    for (let originalScope = originalInnerMostScope; originalScope; originalScope = originalScope.parent) {
+      if (originalScope.isStackFrame) {
+        return originalScope.name ?? '';
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Given an original position, this returns all the surrounding original scopes from outer
+   * to inner.
+   */
+  #findOriginalScopeChain({sourceIndex, line, column}: OriginalPosition): OriginalScope[] {
+    const result: OriginalScope[] = [];
+
+    (function walkScopes(scopes: OriginalScope[]) {
+      for (const scope of scopes) {
+        if (!contains(scope, line, column)) {
+          continue;
+        }
+        result.push(scope);
+        walkScopes(scope.children);
+      }
+    })([this.#originalScopes[sourceIndex]]);
+
+    return result;
+  }
 }
 
 /**