feat(coverage): Demangling of Java function names in coverage results (#388)

This commit adds demangling support for Java. I couldn't find any good
third-party library for this, so I quickly implemented my own, based on
https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2

It might still be have a couple of bugs, but at least for my simple
smoke tests, demangling seems to work just fine.

Co-authored-by: Cameron Martin <cameronmartin123@gmail.com>

Author: vogelsgesang

src/test-explorer/lcov_parser.ts

@@ -2,6 +2,113 @@ import * as vscode from "vscode";
 import * as path from "path";
 import { assert } from "../assert";
 
+/**
+ * Demangle JVM method names.
+ *
+ * See https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2
+ */
+function demangleJVMTypeNames(mangled: string): string[] | undefined {
+  let arrayCnt = 0;
+  const types = [] as string[];
+  const flushType = (type: string) => {
+    for (let i = 0; i < arrayCnt; ++i) {
+      type += "[]";
+    }
+    types.push(type);
+    arrayCnt = 0;
+  };
+  let idx = 0;
+  while (idx < mangled.length) {
+    switch (mangled[idx]) {
+      case "B":
+        flushType("bool");
+        break;
+      case "C":
+        flushType("char");
+        break;
+      case "D":
+        flushType("double");
+        break;
+      case "F":
+        flushType("float");
+        break;
+      case "I":
+        flushType("int");
+        break;
+      case "J":
+        flushType("long");
+        break;
+      case "S":
+        flushType("short");
+        break;
+      case "Z":
+        flushType("boolean");
+        break;
+      case "V":
+        flushType("void");
+        break;
+      case "[":
+        ++arrayCnt;
+        break;
+      case "L": {
+        const startIdx = idx + 1;
+        while (idx < mangled.length && mangled[idx] !== ";") ++idx;
+        if (idx === mangled.length) return undefined;
+        const fullClassName = mangled.substring(startIdx, idx - startIdx + 1);
+        const shortClassName = fullClassName.split("/").pop();
+        flushType(shortClassName);
+        break;
+      }
+      default:
+        return undefined;
+    }
+    ++idx;
+  }
+  if (arrayCnt) return undefined;
+  return types;
+}
+
+function demangleJVMTypeName(mangled: string): string | undefined {
+  const demangled = demangleJVMTypeNames(mangled) ?? [];
+  if (demangled.length !== 1) return undefined;
+  return demangled[0];
+}
+
+/**
+ * Demangle JVM method names.
+ *
+ * See https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3
+ *
+ * Examples:
+ * ```
+ *   com/example/myproject/Greeter::<clinit> ()V
+ *   com/example/myproject/Greeter::<init> ()V
+ *   com/example/myproject/Greeter::convertStreamToString (Ljava/io/InputStream;)Ljava/lang/String;
+ *   com/example/myproject/Greeter::hello (Ljava/lang/String;)V
+ *   com/example/myproject/Greeter::main ([Ljava/lang/String;)V
+ * ```
+ */
+function demangleJVMMethodName(mangled: string): string | undefined {
+  const match = mangled.match(
+    // eslint-disable-next-line max-len
+    /^([\p{XIDS}\p{XIDC}/]+)::([\p{XIDS}\p{XIDC}<>]+) \(([\p{XIDS}\p{XIDC};/[]*)\)([\p{XIDS}\p{XIDC};/[]*)$/u,
+  );
+  if (!match) return undefined;
+  const fullClassName = match[1];
+  const functionName = match[2];
+  const mangledArgList = match[3];
+  const mangledReturnType = match[4];
+
+  const shortClassName = fullClassName.split("/").pop();
+  const argList = demangleJVMTypeNames(mangledArgList);
+  if (!argList) return undefined;
+  const argListStr = argList.join(", ");
+  const returnType = demangleJVMTypeName(mangledReturnType);
+  if (!returnType) return undefined;
+
+  return `${returnType} ${shortClassName}::${functionName}(${argListStr})`;
+}
+
 /**
  * Coverage data from a Bazel run.
  *
@@ -111,20 +218,20 @@ export function parseLcov(
             location = new vscode.Position(startLine, 0);
           }
           if (!info.functionsByLine.has(startLine)) {
-            // TODO: For Java, C++ and Rust the function names should be demangled.
+            // TODO: Also add demangling for C++ and Rust.
             // https://internals.rust-lang.org/t/symbol-mangling-of-rust-vs-c/7222
             // https://github.com/rust-lang/rustc-demangle
-            // https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3
             //
             // Tested with:
             // * Go -> no function names, only line coverage
             // * C++ -> mangled names
             // * Java -> mangled names
             // * Rust -> mangled names
             // Not tested with Python, Swift, Kotlin etc.
+            const demangled = demangleJVMMethodName(funcName) ?? funcName;
             info.functionsByLine.set(
               startLine,
-              new vscode.DeclarationCoverage(funcName, 0, location),
+              new vscode.DeclarationCoverage(demangled, 0, location),
             );
           }
           functionsByName.set(funcName, info.functionsByLine.get(startLine));

test/lcov_parser.test.ts

@@ -96,13 +96,12 @@ describe("The lcov parser", () => {
     it("function coverage details", () => {
       const initFunc = getFunctionByLine(fileCov, 24);
       assert(initFunc !== undefined);
-      assert.equal(initFunc.name, "com/example/myproject/Greeter::<init> ()V");
+      assert.equal(initFunc.name, "void Greeter::<init>()");
       assert.equal(initFunc.executed, 1);
       const convertFunc = getFunctionByLine(fileCov, 28);
       assert.equal(
         convertFunc.name,
-        "com/example/myproject/Greeter::convertStreamToString " +
-          "(Ljava/io/InputStream;)Ljava/lang/String;",
+        "String Greeter::convertStreamToString(InputStream)",
       );
       assert.equal(convertFunc.executed, 0);
     });