refactor(pprof): store file's functions as a Record to minimize looping

In the `annotations()` we would previously loop over every function in a file, then loop over the function from `pprof top` to find information for the given function.
Since "top" results should remain ordered, it seems easier to return funcs as a Record<string, Func>

Author: bevzzz

provider/pprof/index.ts

@@ -61,36 +61,32 @@ const pprof: Provider = {
         }
 
         const anns: Annotation[] = []
+        top.nodes.forEach((node: Node, i: number) => {
+            const func = content.funcs[node.function]
+            if (!func) {
+                return
+            }
 
-        // TODO(1): turn Func[] into a Record<string, Func> for faster lookups (top output should be ordered, funcs don't need to).
-        for (const func of content.funcs) {
-            top.nodes.forEach((node: Node, i: number) => {
-                if (func.pprofRegex !== node.function) {
-                    return
-                }
-
-                let item: Item = {
-                    title: `[#${i + 1}] ${top.type}: ${node.cum}${top.unit}, ${node.cumPerc}% (cum)`,
-                }
+            let item: Item = {
+                title: `[#${i + 1}] ${top.type}: ${node.cum}${top.unit}, ${node.cumPerc}% (cum)`,
+            }
 
-                const list = pprof.list(node.function)
-                if (list) {
-                    item = {
-                        ...item,
-                        ai: {
-                            content: "Output of 'pprof -list' command for this function:\n" + list.raw,
-                        },
-                    }
+            const list = pprof.list(node.function)
+            if (list) {
+                item = {
+                    ...item,
+                    ai: {
+                        content: "Output of 'pprof -list' command for this function:\n" + list.raw,
+                    },
                 }
+            }
 
-                anns.push({
-                    uri: params.uri,
-                    range: func.range,
-                    item: item,
-                })
+            anns.push({
+                uri: params.uri,
+                range: func.range,
+                item: item,
             })
-        }
-
+        })
         return anns
     },
 }

provider/pprof/parser.test.ts

@@ -21,35 +21,30 @@ func (t Thing) String() string { return "thing" }
 
         expect(parseGolang(content)).toStrictEqual<Contents>({
             package: 'example',
-            funcs: [
-                {
+            funcs: {
+                'example.A': {
                     name: 'A',
                     range: { start: { line: 4, character: 5 }, end: { line: 4, character: 6 } },
-                    pprofRegex: 'example.A',
                 },
-                {
+                'example.b_func': {
                     name: 'b_func',
                     range: { start: { line: 5, character: 5 }, end: { line: 5, character: 11 } },
-                    pprofRegex: 'example.b_func',
                 },
-                {
+                'example.A2': {
                     name: 'A2',
                     range: { start: { line: 6, character: 5 }, end: { line: 6, character: 7 } },
-                    pprofRegex: 'example.A2',
                 },
-                {
+                'example.(*Thing).doStuff': {
                     name: 'doStuff',
                     range: { start: { line: 12, character: 16 }, end: { line: 12, character: 23 } },
-                    pprofRegex: 'example.(*Thing).doStuff',
                     receiver: '*Thing',
                 },
-                {
+                'example.(Thing).String': {
                     name: 'String',
                     range: { start: { line: 13, character: 15 }, end: { line: 13, character: 21 } },
-                    pprofRegex: 'example.(Thing).String',
                     receiver: 'Thing',
                 },
-            ],
+            },
         })
     })
 })

provider/pprof/parser.ts

@@ -6,14 +6,17 @@ const methodRegex = /^func \(\w+ (\*)?(\w+)\) (\w+)(?:\()/m
 
 export interface Contents {
     package: string
-    funcs: Func[]
+    
+    /** The key for each function is its fully-qualified name, e.g. example.MyFunc or example.(*Thing).MyMethod,
+     * as they are unique within the file.
+    */
+    funcs: Record<string, Func>
 }
 
 /** Func is a Go function or method with additional metadata to help locate it in the file and filter for in in `pprof`.  */
 export interface Func {
     name: string
     range: Range
-    pprofRegex: string
     receiver?: string
 }
 
@@ -25,7 +28,7 @@ export function parseGolang(source: string): Contents | null {
     const pkg = pkgMatch[1]
     const result: Contents = {
         package: pkg,
-        funcs: [],
+        funcs: {},
     }
 
     const lines = source.split('\n')
@@ -51,14 +54,13 @@ export function parseGolang(source: string): Contents | null {
                 const start = 5 // "func ".length
                 const { func, end } = readFuncName(start)
 
-                result.funcs.push({
+                result.funcs[`${pkg}.${func}`] = {
                     name: func,
                     range: {
                         start: { line: i, character: start },
                         end: { line: i, character: end },
                     },
-                    pprofRegex: `${pkg}.${func}`,
-                })
+                }
                 break
             }
             case methodRegex.test(line): {
@@ -81,15 +83,14 @@ export function parseGolang(source: string): Contents | null {
                 const start = rparen + 2
                 const { func, end } = readFuncName(start)
 
-                result.funcs.push({
+                result.funcs[`${pkg}.(${receiver}).${func}`] = {
                     name: func,
                     range: {
                         start: { line: i, character: start },
                         end: { line: i, character: end },
                     },
-                    pprofRegex: `${pkg}.(${receiver}).${func}`,
                     receiver: receiver,
-                })
+                }
                 break
             }
         }

provider/pprof/pprof.ts

@@ -202,7 +202,6 @@ export class Pprof {
         this.sources = sources
     }
 
-    // TODO: return raw output
     top(options: TopOptions): TopOutput | null {
         if (!this.sources.report) {
             return null
@@ -271,6 +270,10 @@ export class Pprof {
                 unit = node.unit
             }
 
+            // Should we include the raw output here the way we do in list()?
+            // It may include entries for other functions in the same package
+            // which are declared in different files, which might be a useful
+            // information to Cody.
             nodes.push({
                 function: node.func,
                 flat: parseFloat(node.flat),