Merge pull request #655 from jjocoulter/bug/go-to-goes-to-wrong-class

feat: go to code -  go to symbol rather than line number

Author: lcottercertinia

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- 🎯 **Call Tree Go To**: Go-to links in call tree now navigate to method definition instead of where method was called from ([#632] [#200])
 - ⚡ **Log parsing**: improved performance ([#552])
 
 ## [1.18.1] 2025-07-09
@@ -401,6 +402,8 @@ Skipped due to adopting odd numbering for pre releases and even number for relea
 
 <!-- Unreleased -->
 
+[#632]: https://github.com/certinia/debug-log-analyzer/issues/632
+[#200]: https://github.com/certinia/debug-log-analyzer/issues/200
 [#552]: https://github.com/certinia/debug-log-analyzer/issues/552
 
 <!-- v1.18.0 -->

jest.config.js

@@ -1,31 +1,39 @@
+const defaultConfig = {
+  testEnvironment: 'node',
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.(ts|js)?$': [
+      '@swc/jest',
+      {
+        jsc: {
+          target: 'esnext',
+          parser: { decorators: true, syntax: 'typescript' },
+        },
+      },
+    ],
+  },
+  transformIgnorePatterns: [
+    // allow lit/@lit transformation
+    '<rootDir>/node_modules/(?!@?lit)',
+  ],
+  testPathIgnorePatterns: ['<rootDir>/node_modules/', '<rootDir>/out/'],
+  extensionsToTreatAsEsm: ['.ts', '.tsx'],
+};
+
 /** @type {import('@jest/types').Config.InitialOptions} */
 export default {
   projects: [
     {
+      ...defaultConfig,
       displayName: 'log-viewer',
       rootDir: '<rootDir>/log-viewer',
-      testEnvironment: 'node',
-
-      moduleNameMapper: {
-        '^(\\.{1,2}/.*)\\.js$': '$1',
-      },
-      transform: {
-        '^.+\\.(ts|js)?$': [
-          '@swc/jest',
-          {
-            jsc: {
-              target: 'esnext',
-              parser: { decorators: true, syntax: 'typescript' },
-            },
-          },
-        ],
-      },
-      transformIgnorePatterns: [
-        // allow lit/@lit transformation
-        '<rootDir>/node_modules/(?!@?lit)',
-      ],
-      testPathIgnorePatterns: ['<rootDir>/node_modules/', '<rootDir>/out/'],
-      extensionsToTreatAsEsm: ['.ts', '.tsx'],
+    },
+    {
+      ...defaultConfig,
+      displayName: 'lana',
+      rootDir: '<rootDir>/lana',
     },
   ],
 };

lana/package.json

@@ -176,6 +176,7 @@
   },
   "dependencies": {
     "@apexdevtools/apex-ls": "^5.10.0",
+    "@apexdevtools/apex-parser": "^4.4.0",
     "@apexdevtools/sfdx-auth-helper": "^2.1.0",
     "@salesforce/apex-node": "^1.6.2"
   },

lana/src/commands/LogView.ts

@@ -66,14 +66,9 @@ export class LogView {
           }
 
           case 'openType': {
-            const { typeName } = <{ typeName: string; text: string }>payload;
-            if (typeName) {
-              const [className, lineNumber] = typeName.split('-');
-              let line;
-              if (lineNumber) {
-                line = parseInt(lineNumber);
-              }
-              OpenFileInPackage.openFileForSymbol(context, className || '', line);
+            const symbol = <string>payload;
+            if (symbol) {
+              OpenFileInPackage.openFileForSymbol(context, symbol);
             }
             break;
           }

lana/src/display/Display.ts

@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2020 Certinia Inc. All rights reserved.
  */
-import { Uri, commands, window, type MessageOptions } from 'vscode';
+import { Uri, commands, window, type MessageOptions, type TextDocumentShowOptions } from 'vscode';
 
 import { appName } from '../AppSettings.js';
 
@@ -23,7 +23,7 @@ export class Display {
     window.showErrorMessage(s, options);
   }
 
-  showFile(path: string): void {
-    commands.executeCommand('vscode.open', Uri.file(path.trim()));
+  showFile(path: string, options: TextDocumentShowOptions = {}): void {
+    commands.executeCommand('vscode.open', Uri.file(path.trim()), options);
   }
 }

lana/src/display/OpenFileInPackage.ts

@@ -7,23 +7,29 @@ import {
   Selection,
   Uri,
   ViewColumn,
-  commands,
+  workspace,
   type TextDocumentShowOptions,
 } from 'vscode';
 
 import { Context } from '../Context.js';
 import { Item, Options, QuickPick } from './QuickPick.js';
 
+import { getMethodLine, parseApex } from '../salesforce/ApexParser/ApexSymbolLocator.js';
+
 export class OpenFileInPackage {
-  static async openFileForSymbol(
-    context: Context,
-    name: string,
-    lineNumber?: number,
-  ): Promise<void> {
-    const paths = await context.findSymbol(name);
+  static async openFileForSymbol(context: Context, symbolName: string): Promise<void> {
+    if (!symbolName?.trim()) {
+      return;
+    }
+
+    const parts = symbolName.split('.');
+    const fileName = parts[0]?.trim();
+
+    const paths = await context.findSymbol(fileName as string);
     if (!paths.length) {
       return;
     }
+
     const matchingWs = context.workspaces.filter((ws) => {
       const found = paths.findIndex((p) => p.startsWith(ws.path()));
       if (found > -1) {
@@ -38,24 +44,39 @@ export class OpenFileInPackage {
             new Options('Select a workspace:'),
           )
         : [new Item(matchingWs[0]?.name() || '', matchingWs[0]?.path() || '', '')];
+    if (!wsPath) {
+      return;
+    }
 
-    if (wsPath && lineNumber) {
-      const zeroBasedLine = lineNumber - 1;
-      const linePosition = new Position(zeroBasedLine, 0);
-
-      const options: TextDocumentShowOptions = {
-        preserveFocus: false,
-        preview: false,
-        viewColumn: ViewColumn.Active,
-        selection: new Selection(linePosition, linePosition),
-      };
-
-      const wsPathTrimmed = wsPath.description.trim();
-      const path =
-        paths.find((e) => {
-          return e.startsWith(wsPathTrimmed + sep);
-        }) || '';
-      commands.executeCommand('vscode.open', Uri.file(path), options);
+    const wsPathTrimmed = wsPath.description.trim();
+    const path =
+      paths.find((e) => {
+        return e.startsWith(wsPathTrimmed + sep);
+      }) || '';
+
+    const uri = Uri.file(path);
+    const document = await workspace.openTextDocument(uri);
+
+    const parsedRoot = parseApex(document.getText());
+
+    const symbolLocation = getMethodLine(parsedRoot, parts);
+
+    if (!symbolLocation.isExactMatch) {
+      context.display.showErrorMessage(
+        `Symbol '${symbolLocation.missingSymbol}' could not be found in file '${fileName}'`,
+      );
     }
+    const zeroIndexedLineNumber = symbolLocation.line - 1;
+
+    const pos = new Position(zeroIndexedLineNumber, 0);
+
+    const options: TextDocumentShowOptions = {
+      preserveFocus: false,
+      preview: false,
+      viewColumn: ViewColumn.Active,
+      selection: new Selection(pos, pos),
+    };
+
+    context.display.showFile(path, options);
   }
 }

lana/src/salesforce/ApexParser/ApexSymbolLocator.ts

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2025 Certinia Inc. All rights reserved.
+ */
+import {
+  ApexLexer,
+  ApexParser,
+  CaseInsensitiveInputStream,
+  CommonTokenStream,
+} from '@apexdevtools/apex-parser';
+import { CharStreams } from 'antlr4ts';
+import { ApexVisitor, type ApexMethodNode, type ApexNode } from './ApexVisitor';
+
+export type SymbolLocation = {
+  line: number;
+  isExactMatch: boolean;
+  missingSymbol?: string;
+};
+
+export function parseApex(apexCode: string): ApexNode {
+  const parser = new ApexParser(
+    new CommonTokenStream(
+      new ApexLexer(new CaseInsensitiveInputStream(CharStreams.fromString(apexCode))),
+    ),
+  );
+  return new ApexVisitor().visit(parser.compilationUnit());
+}
+
+export function getMethodLine(rootNode: ApexNode, symbols: string[]): SymbolLocation {
+  const result: SymbolLocation = { line: 1, isExactMatch: true };
+
+  if (symbols[0] === rootNode.name) {
+    symbols = symbols.slice(1);
+  }
+
+  if (!symbols.length) {
+    return result;
+  }
+
+  let currentRoot: ApexNode | undefined = rootNode;
+
+  for (const symbol of symbols) {
+    if (isClassSymbol(symbol)) {
+      currentRoot = findClassNode(currentRoot, symbol);
+
+      if (!currentRoot) {
+        result.isExactMatch = false;
+        result.missingSymbol = symbol;
+        break;
+      }
+    } else {
+      const methodNode = findMethodNode(currentRoot, symbol);
+
+      if (!methodNode) {
+        result.line = currentRoot.line ?? 1;
+        result.isExactMatch = false;
+        result.missingSymbol = symbol;
+        break;
+      }
+
+      result.line = methodNode.line;
+    }
+  }
+
+  return result;
+}
+
+function isClassSymbol(symbol: string): boolean {
+  return !symbol.includes('(');
+}
+
+function findClassNode(root: ApexNode, symbol: string): ApexNode | undefined {
+  return root.children?.find((child) => child.name === symbol && child.nature === 'Class');
+}
+
+function findMethodNode(root: ApexNode, symbol: string): ApexMethodNode | undefined {
+  const [methodName, params] = symbol.split('(');
+  const paramStr = params?.replace(')', '').trim();
+
+  return root.children?.find(
+    (child) =>
+      child.name === methodName &&
+      child.nature === 'Method' &&
+      (paramStr === undefined || (child as ApexMethodNode).params === paramStr),
+  ) as ApexMethodNode;
+}

lana/src/salesforce/ApexParser/ApexVisitor.ts

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2025 Certinia Inc. All rights reserved.
+ */
+import type {
+  ApexParserVisitor,
+  ClassDeclarationContext,
+  FormalParametersContext,
+  MethodDeclarationContext,
+} from '@apexdevtools/apex-parser';
+import type { ErrorNode, ParseTree, RuleNode, TerminalNode } from 'antlr4ts/tree';
+
+type ApexNature = 'Class' | 'Method';
+
+export interface ApexNode {
+  nature?: ApexNature;
+  name?: string;
+  children?: ApexNode[];
+  line?: number;
+}
+
+export type ApexMethodNode = ApexNode & {
+  nature: 'Method';
+  params: string;
+  line: number;
+};
+
+type VisitableApex = ParseTree & {
+  accept<Result>(visitor: ApexParserVisitor<Result>): Result;
+};
+
+export class ApexVisitor implements ApexParserVisitor<ApexNode> {
+  visit(ctx: ParseTree): ApexNode {
+    return ctx ? (ctx as VisitableApex).accept(this) : {};
+  }
+
+  visitChildren(ctx: RuleNode): ApexNode {
+    const children: ApexNode[] = [];
+
+    for (let index = 0; index < ctx.childCount; index++) {
+      const child = ctx.getChild(index);
+      const node = this.visit(child);
+      if (!node) {
+        continue;
+      }
+
+      this.forNode(node, (anon) => children.push(anon));
+    }
+
+    return { children };
+  }
+
+  visitClassDeclaration(ctx: ClassDeclarationContext): ApexNode {
+    return {
+      nature: 'Class',
+      name: ctx.id().Identifier()?.toString() ?? '',
+      children: ctx.children?.length ? this.visitChildren(ctx).children : [],
+      line: ctx.start.line,
+    };
+  }
+
+  visitMethodDeclaration(ctx: MethodDeclarationContext): ApexMethodNode {
+    return {
+      nature: 'Method',
+      name: ctx.id().Identifier()?.toString() ?? '',
+      children: ctx.children?.length ? this.visitChildren(ctx).children : [],
+      params: this.getParameters(ctx.formalParameters()),
+      line: ctx.start.line,
+    };
+  }
+
+  visitTerminal(_ctx: TerminalNode): ApexNode {
+    return {};
+  }
+
+  visitErrorNode(_ctx: ErrorNode): ApexNode {
+    return {};
+  }
+
+  private getParameters(ctx: FormalParametersContext): string {
+    const paramsList = ctx.formalParameterList()?.formalParameter();
+    return paramsList?.map((param) => param.typeRef().typeName(0)?.text).join(', ') ?? '';
+  }
+
+  private forNode(node: ApexNode, anonHandler: (n: ApexNode) => void) {
+    if (this.isAnonNode(node)) {
+      anonHandler(node);
+    } else if (node.children?.length) {
+      node.children.forEach((child) => anonHandler(child));
+    }
+  }
+
+  private isAnonNode(node: ApexNode) {
+    return !!node.nature;
+  }
+}