Drop semanticdb prefix from indexer-internal symbol APIs

ScipSymbols.fromSemanticdbSymbol becomes ScipSymbols.format. Helpers
named semanticdbXxx in GlobalSymbolsCache/SymbolsCache/ScipVisitor drop
the misleading prefix; the SemanticdbSymbols utility class is kept since
it encapsulates the symbol grammar SCIP adopted from SemanticDB.

Author: jupblb

scip-java/src/main/scala/com/sourcegraph/scip_java/ScipSymbol.scala

@@ -42,10 +42,8 @@ object ScipSymbol {
     }
   }
 
-  private def parseDescriptors(
-      semanticdbSymbol: String
-  ): List[SymbolDescriptor] = {
-    val descriptor = SymbolDescriptor.parseFromSymbol(semanticdbSymbol)
+  private def parseDescriptors(symbol: String): List[SymbolDescriptor] = {
+    val descriptor = SymbolDescriptor.parseFromSymbol(symbol)
     if (descriptor.owner == SemanticdbSymbols.ROOT_PACKAGE)
       Nil
     else

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/GlobalSymbolsCache.java

@@ -13,7 +13,7 @@
 
 import static com.sourcegraph.semanticdb_javac.Debugging.pprint;
 
-/** Cache of SemanticDB symbols that can be referenced between files. */
+/** Cache of symbol strings shared across files. */
 public final class GlobalSymbolsCache {
 
   private final IdentityHashMap<Element, String> globals = new IdentityHashMap<>();
@@ -23,19 +23,19 @@ public GlobalSymbolsCache(SemanticdbJavacOptions options) {
     this.options = options;
   }
 
-  public String semanticdbSymbol(Element sym, LocalSymbolsCache locals) {
+  public String symbol(Element sym, LocalSymbolsCache locals) {
     String result = globals.get(sym);
     if (result != null) return result;
     String localResult = locals.get(sym);
     if (localResult != null) return localResult;
-    result = uncachedSemanticdbSymbol(sym, locals);
+    result = uncachedSymbol(sym, locals);
     if (SemanticdbSymbols.isGlobal(result)) {
       globals.put(sym, result);
     }
     return result;
   }
 
-  private String uncachedSemanticdbSymbol(Element sym, LocalSymbolsCache locals) {
+  private String uncachedSymbol(Element sym, LocalSymbolsCache locals) {
     if (sym == null) return SemanticdbSymbols.ROOT_PACKAGE;
 
     if (sym instanceof PackageElement) {
@@ -63,10 +63,10 @@ private String uncachedSemanticdbSymbol(Element sym, LocalSymbolsCache locals) {
 
     if (isAnonymousClass(sym) || isLocalVariable(sym)) return locals.put(sym);
 
-    String owner = semanticdbSymbol(sym.getEnclosingElement(), locals);
+    String owner = symbol(sym.getEnclosingElement(), locals);
     if (SemanticdbSymbols.isLocal(owner)) return locals.put(sym);
 
-    SemanticdbSymbols.Descriptor desc = semanticdbDescriptor(sym);
+    SemanticdbSymbols.Descriptor desc = descriptor(sym);
     if (options.verboseEnabled && desc.kind == SemanticdbSymbols.Descriptor.Kind.None) {
       if (sym instanceof QualifiedNameable)
         pprint(((QualifiedNameable) sym).getQualifiedName().toString());
@@ -93,7 +93,7 @@ private boolean isAnonymousClass(Element sym) {
     return sym instanceof TypeElement && sym.getSimpleName().length() == 0;
   }
 
-  private SemanticdbSymbols.Descriptor semanticdbDescriptor(Element sym) {
+  private SemanticdbSymbols.Descriptor descriptor(Element sym) {
     if (sym instanceof TypeElement) {
       return new SemanticdbSymbols.Descriptor(
           SemanticdbSymbols.Descriptor.Kind.Type, sym.getSimpleName().toString());

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/ScipSymbols.java

@@ -1,19 +1,18 @@
 package com.sourcegraph.semanticdb_javac;
 
 /**
- * Converts SemanticDB-style symbol strings into the placeholder SCIP form expected by the
- * aggregator. The compiler plug-in doesn't know the final Maven coordinates, so globals are
- * prefixed with {@link #PLACEHOLDER_PREFIX} and the aggregator rewrites them into {@code "scip-java
- * maven <g> <a> <v> <descriptor>"}. Locals use the canonical {@code "local N"} form and pass
- * through unchanged.
+ * Wraps descriptor strings into SCIP symbol strings. The compiler plug-in doesn't know the final
+ * Maven coordinates, so globals are prefixed with {@link #PLACEHOLDER_PREFIX} and the aggregator
+ * rewrites them into {@code "scip-java maven <g> <a> <v> <descriptor>"}. Locals use the canonical
+ * {@code "local N"} form and pass through unchanged.
  */
 public final class ScipSymbols {
 
   public static final String PLACEHOLDER_PREFIX = ". . . . ";
 
   private ScipSymbols() {}
 
-  public static String fromSemanticdbSymbol(String symbol) {
+  public static String format(String symbol) {
     if (symbol == null || symbol.isEmpty()) return "";
     if (SemanticdbSymbols.isLocal(symbol)) {
       return "local " + symbol.substring("local".length());

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/ScipVisitor.java

@@ -54,8 +54,8 @@
 
 /**
  * Walks a typechecked compilation unit and builds a {@link Document}. Symbols come from {@link
- * GlobalSymbolsCache} via {@link ScipSymbols#fromSemanticdbSymbol(String)} and signatures from
- * {@link ScipSignatureFormatter}.
+ * GlobalSymbolsCache} via {@link ScipSymbols#format(String)} and signatures from {@link
+ * ScipSignatureFormatter}.
  */
 public final class ScipVisitor extends TreePathScanner<Void, Void> {
 
@@ -128,36 +128,36 @@ private Optional<ScipRange> emitSymbolOccurrence(
   private void emitOccurrence(
       Element sym, Optional<ScipRange> range, int roles, Optional<ScipRange> enclosingRange) {
     if (sym == null || !range.isPresent()) return;
-    String semanticdbSymbol = semanticdbSymbol(sym);
-    if (semanticdbSymbol.equals(SemanticdbSymbols.NONE)) return;
+    String symbol = symbol(sym);
+    if (symbol.equals(SemanticdbSymbols.NONE)) return;
 
     Occurrence.Builder occ =
         Occurrence.newBuilder()
             .addAllRange(range.get().asScipRange())
-            .setSymbol(ScipSymbols.fromSemanticdbSymbol(semanticdbSymbol))
+            .setSymbol(ScipSymbols.format(symbol))
             .setSymbolRoles(roles);
     enclosingRange.ifPresent(r -> occ.addAllEnclosingRange(r.asScipRange()));
     occurrences.add(occ.build());
   }
 
   private void emitSymbolInformation(Element sym, Tree tree) {
-    String semanticdbSymbol = semanticdbSymbol(sym);
-    if (semanticdbSymbol.equals(SemanticdbSymbols.NONE)) return;
+    String symbol = symbol(sym);
+    if (symbol.equals(SemanticdbSymbols.NONE)) return;
 
     SymbolInformation.Builder builder =
         SymbolInformation.newBuilder()
-            .setSymbol(ScipSymbols.fromSemanticdbSymbol(semanticdbSymbol))
+            .setSymbol(ScipSymbols.format(symbol))
             .setDisplayName(sym.getSimpleName().toString())
             .setKind(scipKind(sym));
 
-    if (SemanticdbSymbols.isLocal(semanticdbSymbol)) {
-      String enclosingSymbol = semanticdbSymbol(sym.getEnclosingElement());
+    if (SemanticdbSymbols.isLocal(symbol)) {
+      String enclosingSymbol = symbol(sym.getEnclosingElement());
       if (enclosingSymbol != null && !enclosingSymbol.equals(SemanticdbSymbols.NONE)) {
-        builder.setEnclosingSymbol(ScipSymbols.fromSemanticdbSymbol(enclosingSymbol));
+        builder.setEnclosingSymbol(ScipSymbols.format(enclosingSymbol));
       }
     }
 
-    String documentation = semanticdbDocumentation(tree);
+    String documentation = documentation(tree);
     if (documentation != null && !documentation.isEmpty()) {
       builder.addDocumentation(documentation);
     }
@@ -179,12 +179,11 @@ private void emitSymbolInformation(Element sym, Tree tree) {
         break;
       case METHOD:
         for (String overridden :
-            semanticdbOverrides(
-                (ExecutableElement) sym, sym.getEnclosingElement(), new HashSet<>())) {
+            overrides((ExecutableElement) sym, sym.getEnclosingElement(), new HashSet<>())) {
           if (isIgnoredOverriddenSymbol(overridden)) continue;
           builder.addRelationships(
               Relationship.newBuilder()
-                  .setSymbol(ScipSymbols.fromSemanticdbSymbol(overridden))
+                  .setSymbol(ScipSymbols.format(overridden))
                   .setIsImplementation(true)
                   .setIsReference(supportsReferenceRel));
         }
@@ -211,11 +210,11 @@ private void emitSymbolInformation(Element sym, Tree tree) {
 
   private void addParentRelationships(
       SymbolInformation.Builder builder, TypeElement sym, boolean supportsReferenceRel) {
-    for (String parent : semanticdbParentSymbols(sym)) {
+    for (String parent : parentSymbols(sym)) {
       if (isIgnoredOverriddenSymbol(parent)) continue;
       builder.addRelationships(
           Relationship.newBuilder()
-              .setSymbol(ScipSymbols.fromSemanticdbSymbol(parent))
+              .setSymbol(ScipSymbols.format(parent))
               .setIsImplementation(true)
               .setIsReference(supportsReferenceRel));
     }
@@ -462,8 +461,8 @@ private void resolveNewClassTree(NewClassTree node, TreePath treePath) {
     }
   }
 
-  private String semanticdbSymbol(Element sym) {
-    return globals.semanticdbSymbol(sym, locals);
+  private String symbol(Element sym) {
+    return globals.symbol(sym, locals);
   }
 
   private Optional<ScipRange> scipRangeOf(Tree tree, CompilerRange kind, Element sym, String name) {
@@ -568,39 +567,38 @@ private static String sourceText(CompilationUnitTree tree) {
     }
   }
 
-  private List<String> semanticdbParentSymbols(TypeElement typeElement) {
+  private List<String> parentSymbols(TypeElement typeElement) {
     ArrayList<String> parentSymbols = new ArrayList<>();
-    Set<TypeElement> parentElements = semanticdbParentTypeElements(typeElement, new HashSet<>());
+    Set<TypeElement> parentElements = parentTypeElements(typeElement, new HashSet<>());
     for (TypeElement parentElement : parentElements) {
-      String ssym = semanticdbSymbol(parentElement);
+      String ssym = symbol(parentElement);
       if (!Objects.equals(ssym, SemanticdbSymbols.NONE)) {
         parentSymbols.add(ssym);
       }
     }
     return parentSymbols;
   }
 
-  private Set<TypeElement> semanticdbParentTypeElements(
-      TypeElement typeElement, Set<TypeElement> result) {
+  private Set<TypeElement> parentTypeElements(TypeElement typeElement, Set<TypeElement> result) {
     TypeMirror superType = typeElement.getSuperclass();
-    semanticdbParentSymbol(superType, result);
+    parentSymbol(superType, result);
     for (TypeMirror interfaceType : typeElement.getInterfaces()) {
-      semanticdbParentSymbol(interfaceType, result);
+      parentSymbol(interfaceType, result);
     }
     return result;
   }
 
-  private void semanticdbParentSymbol(TypeMirror elementType, Set<TypeElement> result) {
+  private void parentSymbol(TypeMirror elementType, Set<TypeElement> result) {
     if (!(elementType instanceof NoType)) {
       Element superElement = types.asElement(elementType);
       if (superElement instanceof TypeElement) {
         result.add((TypeElement) superElement);
-        semanticdbParentTypeElements((TypeElement) superElement, result);
+        parentTypeElements((TypeElement) superElement, result);
       }
     }
   }
 
-  private Set<String> semanticdbOverrides(
+  private Set<String> overrides(
       ExecutableElement sym, Element enclosingElement, Set<String> overriddenSymbols) {
     if (enclosingElement instanceof TypeElement) {
       List<? extends TypeMirror> superTypes = types.directSupertypes(enclosingElement.asType());
@@ -616,15 +614,15 @@ private Set<String> semanticdbOverrides(
                 ExecutableElement enclosedExecutableElement = (ExecutableElement) enclosedElement;
                 if (elements.overrides(
                     sym, enclosedExecutableElement, (TypeElement) sym.getEnclosingElement())) {
-                  String symbol = semanticdbSymbol(enclosedExecutableElement);
+                  String symbol = symbol(enclosedExecutableElement);
                   overriddenSymbols.add(symbol);
                   methodFound = true;
-                  semanticdbOverrides(enclosedExecutableElement, superElement, overriddenSymbols);
+                  overrides(enclosedExecutableElement, superElement, overriddenSymbols);
                 }
               }
             }
             if (!methodFound) {
-              semanticdbOverrides(sym, superElement, overriddenSymbols);
+              overrides(sym, superElement, overriddenSymbols);
             }
           }
         }
@@ -651,7 +649,7 @@ private static String sourceRelativePath(
     return out.toString();
   }
 
-  private String semanticdbDocumentation(Tree tree) {
+  private String documentation(Tree tree) {
     try {
       TreePath treePath = nodes.get(tree);
       String doc = trees.getDocComment(treePath);

semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/ScipSymbols.kt

@@ -1,16 +1,15 @@
 package com.sourcegraph.semanticdb_kotlinc
 
 /**
- * Converts SemanticDB-style symbol strings into the placeholder SCIP form expected by the
- * aggregator: globals are prefixed with [PLACEHOLDER_PREFIX] (rewritten to
- * `scip-java maven <g> <a> <v> <descriptor>` once coordinates are known), locals use the canonical
- * `local N` form and pass through unchanged. Mirrors the Java `ScipSymbols` helper.
+ * Wraps descriptor strings into SCIP symbol strings: globals are prefixed with [PLACEHOLDER_PREFIX]
+ * (rewritten to `scip-java maven <g> <a> <v> <descriptor>` once coordinates are known), locals use
+ * the canonical `local N` form and pass through unchanged. Mirrors the Java `ScipSymbols` helper.
  */
 object ScipSymbols {
 
     const val PLACEHOLDER_PREFIX: String = ". . . . "
 
-    fun fromSemanticdbSymbol(symbol: Symbol): String {
+    fun format(symbol: Symbol): String {
         if (symbol == Symbol.NONE) return ""
         val raw = symbol.toString()
         if (symbol.isLocal()) {

semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/ScipTextDocumentBuilder.kt

@@ -73,7 +73,7 @@ class ScipTextDocumentBuilder(
             Occurrence
                 .newBuilder()
                 .addAllRange(scipRange(element))
-                .setSymbol(ScipSymbols.fromSemanticdbSymbol(symbol))
+                .setSymbol(ScipSymbols.format(symbol))
                 .setSymbolRoles(roles)
         if (enclosingSource != null) {
             builder.addAllEnclosingRange(scipEnclosingRange(enclosingSource))
@@ -88,7 +88,7 @@ class ScipTextDocumentBuilder(
         element: KtSourceElement,
         context: CheckerContext,
     ) {
-        val scipSymbolStr = ScipSymbols.fromSemanticdbSymbol(symbol)
+        val scipSymbolStr = ScipSymbols.format(symbol)
         val builder =
             SymbolInformation
                 .newBuilder()
@@ -109,7 +109,7 @@ class ScipTextDocumentBuilder(
 
         val supportsRefRel = supportsReferenceRelationship(firBasedSymbol)
         for (parent in parentOrOverriddenSymbols(firBasedSymbol, context)) {
-            val parentSymbolStr = ScipSymbols.fromSemanticdbSymbol(parent)
+            val parentSymbolStr = ScipSymbols.format(parent)
             if (parentSymbolStr.isEmpty()) continue
             builder.addRelationships(
                 Relationship.newBuilder()

semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/SymbolsCache.kt

@@ -65,15 +65,15 @@ class GlobalSymbolsCache {
         locals[symbol]?.let {
             return it
         }
-        return uncachedSemanticdbSymbol(symbol, locals).also {
+        return uncachedSymbol(symbol, locals).also {
             if (it.isGlobal()) globals[symbol] = it
         }
     }
     private fun getSymbol(symbol: FqName): Symbol {
         packages[symbol]?.let {
             return it
         }
-        return uncachedSemanticdbSymbol(symbol).also { if (it.isGlobal()) packages[symbol] = it }
+        return uncachedSymbol(symbol).also { if (it.isGlobal()) packages[symbol] = it }
     }
 
     private fun skip(symbol: FirBasedSymbol<*>?): Boolean {
@@ -82,7 +82,7 @@ class GlobalSymbolsCache {
     }
 
     @OptIn(SymbolInternals::class)
-    private fun uncachedSemanticdbSymbol(
+    private fun uncachedSymbol(
         symbol: FirBasedSymbol<*>?,
         locals: LocalSymbolsCache
     ): Symbol {
@@ -94,12 +94,12 @@ class GlobalSymbolsCache {
 
         if (owner.isLocal() || owner == Symbol.NONE) return locals + symbol
 
-        val semanticdbDescriptor = semanticdbDescriptor(symbol)
+        val descriptor = descriptor(symbol)
 
-        return Symbol.createGlobal(owner, semanticdbDescriptor)
+        return Symbol.createGlobal(owner, descriptor)
     }
 
-    private fun uncachedSemanticdbSymbol(symbol: FqName): Symbol {
+    private fun uncachedSymbol(symbol: FqName): Symbol {
         if (symbol.isRoot) return Symbol.ROOT_PACKAGE
 
         val owner = this.getSymbol(symbol.parent())
@@ -138,7 +138,7 @@ class GlobalSymbolsCache {
     }
 
     @OptIn(SymbolInternals::class)
-    private fun semanticdbDescriptor(symbol: FirBasedSymbol<*>): SemanticdbSymbolDescriptor {
+    private fun descriptor(symbol: FirBasedSymbol<*>): SemanticdbSymbolDescriptor {
         return when {
             symbol is FirAnonymousObjectSymbol ->
                 symbol.source?.let { source ->

tests/unit/src/test/scala/tests/ScipSymbolsSuite.scala

@@ -17,18 +17,18 @@ class ScipSymbolsSuite extends FunSuite {
 
   test("global symbol gets placeholder prefix") {
     assertEquals(
-      ScipSymbols.fromSemanticdbSymbol("com/example/Foo#bar()."),
+      ScipSymbols.format("com/example/Foo#bar()."),
       ". . . . com/example/Foo#bar()."
     )
   }
 
   test("local symbol gets canonical SCIP form") {
-    assertEquals(ScipSymbols.fromSemanticdbSymbol("local42"), "local 42")
+    assertEquals(ScipSymbols.format("local42"), "local 42")
   }
 
   test("empty / null symbol stays empty") {
-    assertEquals(ScipSymbols.fromSemanticdbSymbol(""), "")
-    assertEquals(ScipSymbols.fromSemanticdbSymbol(null), "")
+    assertEquals(ScipSymbols.format(""), "")
+    assertEquals(ScipSymbols.format(null), "")
   }
 
   // PackageTable that always returns no package; isolates SymbolRewriter from classpath.