fix: Refactor getMethodLine to handle fully qualified symbols and improve method resolution

Done via a combination of
- match arg list directly with string from log, if no match then try again with the outer class name stripped from the args since the source code probably does not reference it (but could)
- strip spaces from arg list so they can also be compared

Author: lukecotter

lana/src/salesforce/ApexParser/ApexSymbolLocator.ts

@@ -26,39 +26,69 @@ 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, fullyQualifiedSymbol: string): SymbolLocation {
   const result: SymbolLocation = { character: 0, line: 1, isExactMatch: true };
 
-  if (symbols[0] === rootNode.name) {
-    symbols = symbols.slice(1);
+  if (fullyQualifiedSymbol.indexOf('(') === -1) {
+    return result;
   }
 
-  if (!symbols.length) {
-    return result;
+  // NOTE: The symbol may contain namespaces as symbols from the debug log are fully qualified e.g myns.MyClass.InnerClass.method(args)
+  // We are attempting rudamentary handling of the case where symbols contain namespace but the parsed class does not but no guarantees it work in all cases.
+
+  // There are two possible symbol types method and constructor, args are optional
+  // MyClass.method(args) - method,  MyClass.InnerClass.method(args) - method
+  // MyClass(args) - constuctor, MyClass.InnerClass(args) - constuctor
+
+  // Find the Namespace of the supplied symbol, if there is one.
+  const outerClassNode = rootNode.children?.[0];
+  let outerClassName = outerClassNode?.name ?? '';
+  const endNsIndex = fullyQualifiedSymbol.indexOf(outerClassName);
+  const namespace = endNsIndex > 0 ? fullyQualifiedSymbol.slice(0, endNsIndex - 1) : '';
+  if (namespace) {
+    outerClassName = namespace + '.' + outerClassName;
+    // Remove the leading namespace as most likely the source code will not have it, for symbols in this file.
+    fullyQualifiedSymbol = fullyQualifiedSymbol.replace(namespace + '.', '');
   }
 
+  // strip all whitespace to make comparisons easier
+  fullyQualifiedSymbol = fullyQualifiedSymbol.replaceAll(' ', '').toLowerCase();
+
+  // This is the index of the first '(' which indicates method args or constructor args.
+  const methodArgsIndex = fullyQualifiedSymbol.indexOf('(');
+  // We can't tell the difference between InnerClass constructor and outer class method call.
+  // As such className could either be the class name or the method name, we need to check.
+  const className = fullyQualifiedSymbol.slice(0, methodArgsIndex);
   let currentRoot: ApexNode | undefined = rootNode;
+  // Keep iterating until we find the last symbol that is a class.
+  // The next symbol might be a method or might be invalid.
+  for (const symbol of className.split('.')) {
+    const nextRoot = findClassNode(currentRoot, symbol, namespace);
+    if (!nextRoot) {
+      break;
+    }
 
-  for (const symbol of symbols) {
-    if (isClassSymbol(symbol)) {
-      currentRoot = findClassNode(currentRoot, symbol);
+    currentRoot = nextRoot;
+  }
 
-      if (!currentRoot) {
-        result.isExactMatch = false;
-        result.missingSymbol = symbol;
-        break;
-      }
-    } else {
-      const methodNode = findMethodNode(currentRoot, symbol);
+  if (currentRoot) {
+    result.line = currentRoot.line ?? 1;
+    result.character = currentRoot.idCharacter ?? 0;
+  }
 
-      if (!methodNode) {
-        result.line = currentRoot.line ?? 1;
-        result.character = currentRoot.idCharacter ?? 0;
-        result.isExactMatch = false;
-        result.missingSymbol = symbol;
-        break;
-      }
+  // TODO: enchance to find constructors as well as methods
 
+  // This is the method name before the args list, this may actually be a class name though so we need to check.
+  // e.g for MyClass.InnerClass(args) we get InnerClass(args) but is this a method of InnerClass constructor?
+  const qualifiedMethodName = fullyQualifiedSymbol.slice(className.lastIndexOf('.') + 1);
+  if (qualifiedMethodName && currentRoot) {
+    const methodNode = findMethodNode(currentRoot, qualifiedMethodName, outerClassName);
+
+    if (!methodNode) {
+      result.line = currentRoot.line ?? 1;
+      result.isExactMatch = false;
+      result.missingSymbol = qualifiedMethodName;
+    } else {
       result.line = methodNode.line;
       result.character = methodNode.idCharacter;
     }
@@ -67,22 +97,50 @@ export function getMethodLine(rootNode: ApexNode, symbols: string[]): SymbolLoca
   return result;
 }
 
-function isClassSymbol(symbol: string): boolean {
-  return !symbol.includes('(');
-}
+function findClassNode(root: ApexNode, symbol: string, namespace: string): ApexNode | undefined {
+  const classNode = root.children?.find(
+    (child) => child.name === symbol && child.nature === 'Class',
+  );
+  if (classNode) {
+    return classNode;
+  }
+
+  if (namespace) {
+    return root.children?.find(
+      (child) => child.name === symbol.replaceAll(namespace + '.', '') && child.nature === 'Class',
+    );
+  }
 
-function findClassNode(root: ApexNode, symbol: string): ApexNode | undefined {
-  return root.children?.find((child) => child.name === symbol && child.nature === 'Class');
+  return undefined;
 }
 
-function findMethodNode(root: ApexNode, symbol: string): ApexMethodNode | undefined {
-  const [methodName, params] = symbol.split('(');
-  const paramStr = params?.replace(')', '').trim();
+function findMethodNode(
+  root: ApexNode,
+  symbol: string,
+  outerClassName: string,
+): ApexMethodNode | undefined {
+  const [methodName, args = ''] = symbol.slice(0, -1).split('(');
+  let params = args;
+
+  const methodNode = root.children?.find(
+    (child) =>
+      child.name === methodName &&
+      child.nature === 'Method' &&
+      (params === undefined || (child as ApexMethodNode).params.toLowerCase() === params),
+  ) as ApexMethodNode;
+
+  if (methodNode) {
+    return methodNode;
+  }
 
+  // Try again but with the class name removed from args list. args from the debug log are fully qualified but they are not necessarily in the file,
+  // as we only need to qualify for external types to the file.
+  // (MyClass.ObjectArg) vs (ObjectArg) where MyClass is current class.
+  params = params.replaceAll(outerClassName + '.', '');
   return root.children?.find(
     (child) =>
       child.name === methodName &&
       child.nature === 'Method' &&
-      (paramStr === undefined || (child as ApexMethodNode).params === paramStr),
+      (params === undefined || (child as ApexMethodNode).params.toLowerCase() === params),
   ) as ApexMethodNode;
 }

lana/src/salesforce/ApexParser/ApexVisitor.ts

@@ -18,7 +18,7 @@ type ApexNature = 'Class' | 'Method';
 export interface ApexNode {
   /** The type of Apex construct (Class or Method) */
   nature?: ApexNature;
-  /** The name of the class or method */
+  /** The name of the class or method, in lower case */
   name?: string;
   /** Child nodes (nested classes or methods) */
   children?: ApexNode[];
@@ -87,7 +87,7 @@ export class ApexVisitor implements ApexParserVisitor<ApexNode> {
 
     return {
       nature: 'Class',
-      name: ctx.id().Identifier()?.toString() ?? '',
+      name: ident.text.toLowerCase(),
       children: ctx.children?.length ? this.visitChildren(ctx).children : [],
       line: start.line,
       idCharacter: ident.start.charPositionInLine ?? 0,
@@ -100,7 +100,7 @@ export class ApexVisitor implements ApexParserVisitor<ApexNode> {
 
     return {
       nature: 'Method',
-      name: ctx.id().Identifier()?.toString() ?? '',
+      name: ident.text.toLowerCase(),
       children: ctx.children?.length ? this.visitChildren(ctx).children : [],
       params: this.getParameters(ctx.formalParameters()),
       line: start.line,
@@ -118,7 +118,11 @@ 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.replaceAll(' ', '').toLowerCase())
+        .join(',') ?? ''
+    );
   }
 
   private forNode(node: ApexNode, anonHandler: (n: ApexNode) => void) {