Upgrade SCIP bindings to 0.9

Author: jupblb

MODULE.bazel

@@ -10,7 +10,7 @@ maven.install(
     artifacts = [
         "com.google.protobuf:protobuf-java-util:4.34.2",
         "org.projectlombok:lombok:1.18.46",
-        "org.scip-code:scip-java-bindings:0.8.0",
+        "org.scip-code:scip-java-bindings:0.9.0",
     ],
     known_contributing_modules = ["protobuf"],
     repositories = ["https://repo1.maven.org/maven2"],

gradle/libs.versions.toml

@@ -12,7 +12,7 @@ maven-plugin-api = "3.6.3"
 maven-project = "2.2.1"
 protobuf = "4.34.2"
 protobuf-plugin = "0.10.0"
-scip-bindings = "0.8.0"
+scip-bindings = "0.9.0"
 shadow = "9.4.3"
 spotless = "8.7.0"
 vanniktech-maven-publish = "0.35.0"

scip-aggregator/src/main/java/com/sourcegraph/scip_aggregator/ScipAggregator.java

@@ -1,6 +1,7 @@
 package com.sourcegraph.scip_aggregator;
 
 import com.google.protobuf.CodedInputStream;
+import com.sourcegraph.scip.ScipRanges;
 import com.sourcegraph.scip.ScipSymbols;
 import java.io.IOException;
 import java.nio.file.FileSystems;
@@ -153,12 +154,10 @@ private Document rewriteDocument(
     for (Occurrence occ : shard.getOccurrencesList()) {
       Occurrence.Builder rebuilt =
           Occurrence.newBuilder()
-              .addAllRange(occ.getRangeList())
               .setSymbol(rewriter.rewrite(occ.getSymbol()))
               .setSymbolRoles(occ.getSymbolRoles());
-      if (occ.getEnclosingRangeCount() > 0) {
-        rebuilt.addAllEnclosingRange(occ.getEnclosingRangeList());
-      }
+      ScipRanges.copyRange(occ, rebuilt);
+      ScipRanges.copyEnclosingRange(occ, rebuilt);
       out.addOccurrences(rebuilt);
     }
 

scip-javac/src/main/java/com/sourcegraph/scip_javac/ScipVisitor.java

@@ -2,6 +2,8 @@
 
 import com.sourcegraph.scip.LocalSymbolsCache;
 import com.sourcegraph.scip.ScipDocumentBuilder;
+import com.sourcegraph.scip.ScipRanges;
+import com.sourcegraph.scip.ScipRanges.Range;
 import com.sourcegraph.scip.ScipSymbols;
 import com.sun.source.tree.AnnotatedTypeTree;
 import com.sun.source.tree.ClassTree;
@@ -182,7 +184,7 @@ private void resolveMethodTree(MethodTree node, TreePath treePath) {
   private void resolveVariableTree(VariableTree node, TreePath treePath) {
     Element sym = trees.getElement(treePath);
     if (sym == null) return;
-    int[] range =
+    Range range =
         emitDefinition(sym, node, sym.getSimpleName(), CompilerRange.FROM_POINT_WITH_TEXT_SEARCH);
     if (sym.getKind() == ElementKind.ENUM_CONSTANT) {
       TreePath typeTreePath = nodes.get(node.getInitializer());
@@ -246,8 +248,8 @@ private void resolveNewClassTree(NewClassTree node, TreePath treePath) {
   // =======================================
   // Occurrence + SymbolInformation emission
   // =======================================
-  private int[] emitDefinition(Element sym, Tree tree, Name name, CompilerRange kind) {
-    int[] range = computeRange(tree, kind, sym, name == null ? null : name.toString());
+  private Range emitDefinition(Element sym, Tree tree, Name name, CompilerRange kind) {
+    Range range = computeRange(tree, kind, sym, name == null ? null : name.toString());
     if (range == null) return null;
     emitOccurrence(sym, range, SymbolRole.Definition_VALUE, computeEnclosingRange(tree));
     declTrees.put(sym, tree);
@@ -256,18 +258,18 @@ private int[] emitDefinition(Element sym, Tree tree, Name name, CompilerRange ki
   }
 
   private void emitReference(Element sym, Tree tree, Name name, CompilerRange kind) {
-    int[] range = computeRange(tree, kind, sym, name == null ? null : name.toString());
+    Range range = computeRange(tree, kind, sym, name == null ? null : name.toString());
     if (range == null) return;
     emitOccurrence(sym, range, 0 /* reference */, null);
   }
 
-  private void emitOccurrence(Element sym, int[] range, int role, int[] enclosingRange) {
+  private void emitOccurrence(Element sym, Range range, int role, Range enclosingRange) {
     String symbol = scipSymbol(sym);
     if (symbol.isEmpty()) return;
     Occurrence.Builder b = Occurrence.newBuilder().setSymbol(symbol).setSymbolRoles(role);
-    for (int v : range) b.addRange(v);
+    ScipRanges.setRange(b, range);
     if (enclosingRange != null) {
-      for (int v : enclosingRange) b.addEnclosingRange(v);
+      ScipRanges.setEnclosingRange(b, enclosingRange);
     }
     documentBuilder.addOccurrence(b.build());
   }
@@ -360,7 +362,7 @@ private SymbolInformation.Kind scipKind(Element sym) {
   // =======================================
   // Source position / range computation
   // =======================================
-  private int[] computeRange(Tree tree, CompilerRange kind, Element sym, String name) {
+  private Range computeRange(Tree tree, CompilerRange kind, Element sym, String name) {
     if (sym == null) return null;
     SourcePositions sourcePositions = trees.getSourcePositions();
     int start = (int) sourcePositions.getStartPosition(compUnitTree, tree);
@@ -394,7 +396,7 @@ private int[] computeRange(Tree tree, CompilerRange kind, Element sym, String na
     return lineMapRange(start, end);
   }
 
-  private int[] computeEnclosingRange(Tree tree) {
+  private Range computeEnclosingRange(Tree tree) {
     if (tree == null) return null;
     TreePath path = nodes.get(tree);
     if (path == null) return null;
@@ -413,7 +415,7 @@ private int[] computeEnclosingRange(Tree tree) {
     return lineMapRange(start, end);
   }
 
-  private int[] lineMapRange(int start, int end) {
+  private Range lineMapRange(int start, int end) {
     if (start == Diagnostic.NOPOS || end == Diagnostic.NOPOS || end <= start) return null;
     LineMap lineMap = compUnitTree.getLineMap();
     int startLine = (int) lineMap.getLineNumber(start) - 1;
@@ -431,8 +433,8 @@ private int[] lineMapRange(int start, int end) {
       endChar -= count * 7;
     }
 
-    if (startLine == endLine) return new int[] {startLine, startChar, endChar};
-    return new int[] {startLine, startChar, endLine, endChar};
+    if (startLine == endLine) return ScipRanges.singleLineRange(startLine, startChar, endChar);
+    return ScipRanges.range(startLine, startChar, endLine, endChar);
   }
 
   // =======================================

scip-kotlinc/src/main/kotlin/com/sourcegraph/scip_kotlinc/ScipTextDocumentBuilder.kt

@@ -1,6 +1,8 @@
 package com.sourcegraph.scip_kotlinc
 
 import com.sourcegraph.scip.ScipDocumentBuilder
+import com.sourcegraph.scip.ScipRanges
+import com.sourcegraph.scip.ScipRanges.Range
 import com.sourcegraph.scip.ScipShardPaths
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -22,7 +24,6 @@ import org.scip_code.scip.Document
 import org.scip_code.scip.Occurrence
 import org.scip_code.scip.SymbolInformation
 import org.scip_code.scip.SymbolRole
-import org.scip_code.scip.occurrence
 import org.scip_code.scip.relationship
 import org.scip_code.scip.signature
 import org.scip_code.scip.symbolInformation
@@ -98,29 +99,29 @@ class ScipTextDocumentBuilder(
         element: KtSourceElement,
         isDefinition: Boolean,
         enclosingSource: KtSourceElement?,
-    ): Occurrence = occurrence {
-        this.symbol = symbol.toString()
-        if (isDefinition) symbolRoles = SymbolRole.Definition.number
-        range += range(element).asIterable()
+    ): Occurrence {
+        val builder = Occurrence.newBuilder().setSymbol(symbol.toString())
+        if (isDefinition) builder.setSymbolRoles(SymbolRole.Definition.number)
+        ScipRanges.setRange(builder, range(element))
         if (enclosingSource != null) {
-            enclosingRange += enclosingRange(enclosingSource).asIterable()
+            ScipRanges.setEnclosingRange(builder, enclosingRange(enclosingSource))
         }
+        return builder.build()
     }
 
-    private fun range(element: KtSourceElement): IntArray {
+    private fun range(element: KtSourceElement): Range {
         val line = lineMap.lineNumber(element) - 1
         val startCol = lineMap.startCharacter(element)
         val endCol = lineMap.endCharacter(element)
-        return intArrayOf(line, startCol, endCol)
+        return ScipRanges.singleLineRange(line, startCol, endCol)
     }
 
-    private fun enclosingRange(element: KtSourceElement): IntArray {
+    private fun enclosingRange(element: KtSourceElement): Range {
         val startLine = lineMap.lineNumber(element) - 1
         val startCol = lineMap.startCharacter(element)
         val endLine = lineMap.lineNumberForOffset(element.endOffset) - 1
         val endCol = lineMap.columnForOffset(element.endOffset)
-        return if (startLine == endLine) intArrayOf(startLine, startCol, endCol)
-        else intArrayOf(startLine, startCol, endLine, endCol)
+        return ScipRanges.range(startLine, startCol, endLine, endCol)
     }
 
     private fun relativePath(): String =

scip-kotlinc/src/test/kotlin/com/sourcegraph/scip_kotlinc/test/ScipBuilders.kt

@@ -1,9 +1,10 @@
 package com.sourcegraph.scip_kotlinc.test
 
+import com.sourcegraph.scip.ScipRanges
+import com.sourcegraph.scip.ScipRanges.Range
 import org.scip_code.scip.Occurrence
 import org.scip_code.scip.SymbolInformation
 import org.scip_code.scip.SymbolRole
-import org.scip_code.scip.occurrence
 import org.scip_code.scip.relationship
 import org.scip_code.scip.signature
 import org.scip_code.scip.symbolInformation
@@ -38,33 +39,32 @@ class ScipRangeBuilder {
     var endLine: Int = -1
     var endCharacter: Int = 0
 
-    internal fun toIntList(): List<Int> {
+    internal fun toScipRange(): Range {
         val line = if (endLine < 0) startLine else endLine
-        return if (line == startLine) listOf(startLine, startCharacter, endCharacter)
-        else listOf(startLine, startCharacter, line, endCharacter)
+        return ScipRanges.range(startLine, startCharacter, line, endCharacter)
     }
 }
 
 @ScipBuilderDsl
 class ScipOccurrenceBuilder {
     var role: Int = REFERENCE
     var symbol: String = ""
-    private var range: List<Int>? = null
-    private var enclosingRange: List<Int>? = null
+    private var range: Range? = null
+    private var enclosingRange: Range? = null
 
     fun range(block: ScipRangeBuilder.() -> Unit) {
-        range = ScipRangeBuilder().apply(block).toIntList()
+        range = ScipRangeBuilder().apply(block).toScipRange()
     }
 
     fun enclosingRange(block: ScipRangeBuilder.() -> Unit) {
-        enclosingRange = ScipRangeBuilder().apply(block).toIntList()
+        enclosingRange = ScipRangeBuilder().apply(block).toScipRange()
     }
 
-    internal fun build(): Occurrence = occurrence {
-        symbol = this@ScipOccurrenceBuilder.symbol
-        symbolRoles = role
-        this@ScipOccurrenceBuilder.range?.let { range += it }
-        this@ScipOccurrenceBuilder.enclosingRange?.let { enclosingRange += it }
+    internal fun build(): Occurrence {
+        val builder = Occurrence.newBuilder().setSymbol(symbol).setSymbolRoles(role)
+        range?.let { ScipRanges.setRange(builder, it) }
+        enclosingRange?.let { ScipRanges.setEnclosingRange(builder, it) }
+        return builder.build()
     }
 }
 

scip-shared/src/main/java/com/sourcegraph/scip/ScipDocumentBuilder.java

@@ -1,7 +1,6 @@
 package com.sourcegraph.scip;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -21,8 +20,8 @@
  */
 public final class ScipDocumentBuilder {
   private static final Comparator<Occurrence> OCCURRENCE_ORDER =
-      Comparator.<Occurrence>comparingInt(o -> rangeStartLine(o))
-          .thenComparingInt(o -> rangeStartCharacter(o));
+      Comparator.<Occurrence>comparingInt(ScipRanges::rangeStartLine)
+          .thenComparingInt(ScipRanges::rangeStartCharacter);
 
   private final Map<OccurrenceKey, Occurrence> occurrences = new LinkedHashMap<>();
   private final Map<String, SymbolInformation> symbols = new LinkedHashMap<>();
@@ -49,21 +48,13 @@ public Document build(String language, String relativePath, String text) {
         .build();
   }
 
-  private static int rangeStartLine(Occurrence occurrence) {
-    return occurrence.getRangeCount() > 0 ? occurrence.getRange(0) : 0;
-  }
-
-  private static int rangeStartCharacter(Occurrence occurrence) {
-    return occurrence.getRangeCount() > 1 ? occurrence.getRange(1) : 0;
-  }
-
   private static final class OccurrenceKey {
-    private final List<Integer> range;
+    private final ScipRanges.Range range;
     private final String symbol;
     private final int roles;
 
     OccurrenceKey(Occurrence occurrence) {
-      this.range = Collections.unmodifiableList(new ArrayList<>(occurrence.getRangeList()));
+      this.range = ScipRanges.range(occurrence);
       this.symbol = occurrence.getSymbol();
       this.roles = occurrence.getSymbolRoles();
     }