feat: improve go-to definition

lana/package.json

@@ -185,7 +185,6 @@
     "vscode:prepublish": "rm -rf out && pnpm -w run build"
   },
   "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/Context.ts

@@ -1,43 +1,38 @@
 /*
  * Copyright (c) 2020 Certinia Inc. All rights reserved.
  */
-import { workspace, type ExtensionContext } from 'vscode';
+import { Uri, type ExtensionContext } from 'vscode';
 
 import { ShowAnalysisCodeLens } from './codelenses/ShowAnalysisCodeLens.js';
 import { RetrieveLogFile } from './commands/RetrieveLogFile.js';
 import { ShowLogAnalysis } from './commands/ShowLogAnalysis.js';
 import { Display } from './display/Display.js';
 import { WhatsNewNotification } from './display/WhatsNewNotification.js';
-import { SymbolFinder } from './salesforce/codesymbol/SymbolFinder.js';
-import { VSWorkspace } from './workspace/VSWorkspace.js';
+import type { ApexSymbol } from './salesforce/codesymbol/ApexSymbolParser.js';
+import { VSWorkspaceManager } from './workspace/VSWorkspaceManager.js';
 
 export class Context {
-  symbolFinder = new SymbolFinder();
   context: ExtensionContext;
   display: Display;
-  workspaces: VSWorkspace[] = [];
+  workspaceManager = new VSWorkspaceManager();
 
   constructor(context: ExtensionContext, display: Display) {
     this.context = context;
     this.display = display;
 
-    if (workspace.workspaceFolders) {
-      this.workspaces = workspace.workspaceFolders.map((folder) => {
-        return new VSWorkspace(folder);
-      });
-    }
-
     RetrieveLogFile.apply(this);
     ShowLogAnalysis.apply(this);
     ShowAnalysisCodeLens.apply(this);
     WhatsNewNotification.apply(this);
   }
 
-  async findSymbol(symbol: string): Promise<string[]> {
-    const path = await this.symbolFinder.findSymbol(this.workspaces, symbol);
-    if (!path.length) {
-      this.display.showErrorMessage(`Type '${symbol}' was not found in workspace`);
+  async findSymbol(apexSymbol: ApexSymbol): Promise<Uri | null> {
+    const path = await this.workspaceManager.findSymbol(apexSymbol);
+
+    if (!path) {
+      this.display.showErrorMessage(`Type '${apexSymbol.fullSymbol}' was not found in workspace`);
     }
+
     return path;
   }
 }

lana/src/__mocks__/vscode.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025 Certinia Inc. All rights reserved.
+ */
+/* eslint-disable @typescript-eslint/naming-convention */
+
+export const RelativePattern = jest.fn();
+
+export const Uri = {
+  file: jest.fn((path: string) => ({ fsPath: path })),
+  joinPath: jest.fn((base: { fsPath: string }, ...paths: string[]) => ({
+    fsPath: [base.fsPath, ...paths].join('/'),
+  })),
+};
+
+export const workspace = {
+  findFiles: jest.fn(),
+  openTextDocument: jest.fn(),
+  workspaceFolders: [],
+  asRelativePath: jest.fn((uri: { fsPath: string } | string) =>
+    typeof uri === 'string' ? uri : uri.fsPath,
+  ),
+};
+
+export const window = {
+  showInformationMessage: jest.fn(),
+  showErrorMessage: jest.fn(),
+  showWarningMessage: jest.fn(),
+  createOutputChannel: jest.fn(() => ({
+    appendLine: jest.fn(),
+    show: jest.fn(),
+  })),
+};

lana/src/display/OpenFileInPackage.ts

@@ -1,69 +1,44 @@
 /*
  * Copyright (c) 2020 Certinia Inc. All rights reserved.
  */
-import { sep } from 'path';
 import {
+  commands,
   Position,
   Selection,
-  Uri,
   ViewColumn,
   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';
+import { parseSymbol } from '../salesforce/codesymbol/ApexSymbolParser.js';
 
 export class OpenFileInPackage {
   static async openFileForSymbol(context: Context, symbolName: string): Promise<void> {
     if (!symbolName?.trim()) {
       return;
     }
 
-    const parts = symbolName.split('.');
-    const fileName = parts[0]?.trim();
+    await context.workspaceManager.initialiseWorkspaceProjectInfo();
+    const apexSymbol = parseSymbol(symbolName, context.workspaceManager.getAllProjects());
 
-    const paths = await context.findSymbol(fileName as string);
-    if (!paths.length) {
-      return;
-    }
+    const uri = await context.findSymbol(apexSymbol);
 
-    const matchingWs = context.workspaces.filter((ws) => {
-      const found = paths.findIndex((p) => p.startsWith(ws.path()));
-      if (found > -1) {
-        return ws;
-      }
-    });
-
-    const [wsPath] =
-      matchingWs.length > 1
-        ? await QuickPick.pick(
-            matchingWs.map((p) => new Item(p.name(), p.path(), '')),
-            new Options('Select a workspace:'),
-          )
-        : [new Item(matchingWs[0]?.name() || '', matchingWs[0]?.path() || '', '')];
-    if (!wsPath) {
+    if (!uri) {
       return;
     }
 
-    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);
+    const symbolLocation = getMethodLine(parsedRoot, apexSymbol);
 
     if (!symbolLocation.isExactMatch) {
       context.display.showErrorMessage(
-        `Symbol '${symbolLocation.missingSymbol}' could not be found in file '${fileName}'`,
+        `Symbol '${symbolLocation.missingSymbol}' could not be found in file '${apexSymbol.fullSymbol}'`,
       );
     }
     const zeroIndexedLineNumber = symbolLocation.line - 1;
@@ -77,6 +52,6 @@ export class OpenFileInPackage {
       selection: new Selection(pos, pos),
     };
 
-    context.display.showFile(path, options);
+    commands.executeCommand('vscode.open', uri, options);
   }
 }

lana/src/display/QuickPickWorkspace.ts

@@ -9,9 +9,11 @@ import { Item, Options, QuickPick } from './QuickPick.js';
 
 export class QuickPickWorkspace {
   static async pickOrReturn(context: Context): Promise<string> {
-    if (context.workspaces.length > 1) {
+    const workspaceFolders = context.workspaceManager.workspaceFolders;
+
+    if (workspaceFolders.length > 1) {
       const [workspace] = await QuickPick.pick(
-        context.workspaces.map((ws) => new Item(ws.name(), ws.path(), '')),
+        workspaceFolders.map((ws) => new Item(ws.name(), ws.path(), '')),
         new Options('Select a workspace:'),
       );
 
@@ -20,8 +22,8 @@ export class QuickPickWorkspace {
       } else {
         throw new Error('No workspace selected');
       }
-    } else if (context.workspaces.length === 1) {
-      return context.workspaces[0]?.path() || '';
+    } else if (workspaceFolders.length === 1) {
+      return workspaceFolders[0]?.path() || '';
     } else {
       if (window.activeTextEditor) {
         return parse(window.activeTextEditor.document.fileName).dir;

lana/src/salesforce/ApexParser/ApexSymbolLocator.ts

@@ -8,6 +8,7 @@ import {
   CommonTokenStream,
 } from '@apexdevtools/apex-parser';
 import { CharStreams } from 'antlr4ts';
+import type { ApexSymbol } from '../codesymbol/ApexSymbolParser';
 import { ApexVisitor, type ApexMethodNode, type ApexNode } from './ApexVisitor';
 
 export type SymbolLocation = {
@@ -25,61 +26,71 @@ export function parseApex(apexCode: string): ApexNode {
   return new ApexVisitor().visit(parser.compilationUnit());
 }
 
-export function getMethodLine(rootNode: ApexNode, symbols: string[]): SymbolLocation {
+export function getMethodLine(rootNode: ApexNode, apexSymbol: ApexSymbol): SymbolLocation {
   const result: SymbolLocation = { line: 1, isExactMatch: true };
 
-  if (symbols[0] === rootNode.name) {
-    symbols = symbols.slice(1);
+  let currentRoot: ApexNode | undefined = rootNode;
+
+  if (currentRoot.name !== apexSymbol.outerClass) {
+    currentRoot = findClassNode(currentRoot, apexSymbol.outerClass);
   }
 
-  if (!symbols.length) {
+  if (!currentRoot) {
+    result.isExactMatch = false;
+    result.missingSymbol = apexSymbol.outerClass;
     return result;
   }
 
-  let currentRoot: ApexNode | undefined = rootNode;
+  if (apexSymbol.innerClass) {
+    currentRoot = findClassNode(currentRoot, apexSymbol.innerClass);
 
-  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;
+    if (!currentRoot) {
+      result.isExactMatch = false;
+      result.missingSymbol = apexSymbol.innerClass;
+      return result;
     }
   }
 
-  return result;
-}
+  const methodNode = findMethodNode(currentRoot, apexSymbol);
 
-function isClassSymbol(symbol: string): boolean {
-  return !symbol.includes('(');
+  if (!methodNode) {
+    result.line = currentRoot.line ?? 1;
+    result.isExactMatch = false;
+    result.missingSymbol = apexSymbol.method + '(' + apexSymbol.parameters + ')';
+    return result;
+  }
+
+  result.line = methodNode.line;
+
+  return result;
 }
 
 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();
+function findMethodNode(root: ApexNode, apexSymbol: ApexSymbol): ApexMethodNode | undefined {
+  const qualifierString = apexSymbol.namespace
+    ? `${apexSymbol.namespace}|${apexSymbol.outerClass}`
+    : apexSymbol.outerClass;
 
   return root.children?.find(
     (child) =>
-      child.name === methodName &&
+      child.name === apexSymbol.method &&
       child.nature === 'Method' &&
-      (paramStr === undefined || (child as ApexMethodNode).params === paramStr),
+      (apexSymbol.parameters === '' ||
+        matchesUnqualified(
+          qualifierString,
+          (child as ApexMethodNode).params,
+          apexSymbol.parameters,
+        )),
   ) as ApexMethodNode;
 }
+
+function matchesUnqualified(qualifierString: string, str1: string, str2: string): boolean {
+  const regex = new RegExp(`\\b(?:${qualifierString}|System)\\.`, 'gi');
+  const unqualifiedStr1 = str1.replace(regex, '');
+  const unqualifiedStr2 = str2.replace(regex, '');
+
+  return unqualifiedStr1 === unqualifiedStr2;
+}

lana/src/salesforce/ApexParser/ApexVisitor.ts

@@ -78,7 +78,7 @@ export class ApexVisitor implements ApexParserVisitor<ApexNode> {
 
   private getParameters(ctx: FormalParametersContext): string {
     const paramsList = ctx.formalParameterList()?.formalParameter();
-    return paramsList?.map((param) => param.typeRef().typeName(0)?.text).join(', ') ?? '';
+    return paramsList?.map((param) => param.typeRef().text).join(', ') ?? '';
   }
 
   private forNode(node: ApexNode, anonHandler: (n: ApexNode) => void) {