go: add Compare/Contains methods on *Occurrence

Author: jupblb

bindings/go/scip/flatten.go

@@ -64,11 +64,7 @@ func FlattenOccurrences(occurrences []*Occurrence) []*Occurrence {
 	for _, occurrence := range occurrences[1:] {
 		top := flattened[len(flattened)-1]
 
-		if !occurrenceRangesEqual(top, occurrence) {
-			flattened = append(flattened, occurrence)
-			continue
-		}
-		if top.Symbol != occurrence.Symbol {
+		if top.Compare(occurrence) != 0 {
 			flattened = append(flattened, occurrence)
 			continue
 		}

bindings/go/scip/occurrence_range.go

@@ -1,5 +1,7 @@
 package scip
 
+import "strings"
+
 // SourceRange returns the source range of this occurrence and whether one is
 // set. `typed_range` takes precedence over the deprecated `range` field.
 // Malformed deprecated ranges (length != 3 or 4) are reported as missing; use
@@ -50,6 +52,28 @@ func (occ *Occurrence) SetEnclosingSourceRange(r Range) {
 	occ.TypedEnclosingRange = &Occurrence_MultiLineEnclosingRange{MultiLineEnclosingRange: r.ToMultiLineRange()}
 }
 
+// Compare orders occurrences in the canonical SCIP ordering: ascending by
+// source range, with symbol name as a tiebreaker. Returns -1, 0, or +1.
+//
+// Occurrences missing a source range compare as if their range were the
+// zero range; such occurrences are illegal per the SCIP spec and should be
+// surfaced via `scip lint`.
+func (occ *Occurrence) Compare(other *Occurrence) int {
+	r1, _ := occ.SourceRange()
+	r2, _ := other.SourceRange()
+	if c := r1.CompareStrict(r2); c != 0 {
+		return c
+	}
+	return strings.Compare(occ.Symbol, other.Symbol)
+}
+
+// Contains reports whether the source range of this occurrence contains the
+// given position. Returns false if the occurrence has no range.
+func (occ *Occurrence) Contains(pos Position) bool {
+	r, ok := occ.SourceRange()
+	return ok && r.Contains(pos)
+}
+
 // ToRange returns this single-line range as a Range.
 func (sr *SingleLineRange) ToRange() Range {
 	return Range{

bindings/go/scip/occurrence_range_test.go

@@ -139,3 +139,37 @@ func TestOccurrence_SetEnclosingSourceRange(t *testing.T) {
 	require.True(t, ok)
 	require.Equal(t, &MultiLineRange{StartLine: 1, StartCharacter: 0, EndLine: 5, EndCharacter: 1}, tr.MultiLineEnclosingRange)
 }
+
+func TestOccurrence_Compare(t *testing.T) {
+	mkOcc := func(r []int32, sym string) *Occurrence {
+		return &Occurrence{Range: r, Symbol: sym}
+	}
+	tests := []struct {
+		name string
+		a, b *Occurrence
+		want int
+	}{
+		{"equal", mkOcc([]int32{1, 0, 5}, "x"), mkOcc([]int32{1, 0, 5}, "x"), 0},
+		{"earlier range", mkOcc([]int32{0, 0, 5}, "x"), mkOcc([]int32{1, 0, 5}, "x"), -1},
+		{"later range", mkOcc([]int32{2, 0, 5}, "x"), mkOcc([]int32{1, 0, 5}, "x"), 1},
+		{"same range, earlier symbol", mkOcc([]int32{1, 0, 5}, "a"), mkOcc([]int32{1, 0, 5}, "b"), -1},
+		{"same range, later symbol", mkOcc([]int32{1, 0, 5}, "b"), mkOcc([]int32{1, 0, 5}, "a"), 1},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			require.Equal(t, tc.want, tc.a.Compare(tc.b))
+		})
+	}
+}
+
+func TestOccurrence_Contains(t *testing.T) {
+	occ := &Occurrence{Range: []int32{2, 5, 10}}
+	require.True(t, occ.Contains(Position{2, 5}))
+	require.True(t, occ.Contains(Position{2, 9}))
+	require.False(t, occ.Contains(Position{2, 4}))
+	require.False(t, occ.Contains(Position{2, 10}))
+	require.False(t, occ.Contains(Position{3, 0}))
+
+	empty := &Occurrence{}
+	require.False(t, empty.Contains(Position{0, 0}))
+}

bindings/go/scip/sort.go

@@ -49,18 +49,13 @@ func FindOccurrences(occurrences []*Occurrence, targetLine, targetCharacter int3
 	var filtered []*Occurrence
 	pos := Position{targetLine, targetCharacter}
 	for _, occurrence := range occurrences {
-		if r, _ := occurrence.SourceRange(); r.Contains(pos) {
+		if occurrence.Contains(pos) {
 			filtered = append(filtered, occurrence)
 		}
 	}
 
-	sort.Slice(filtered, func(i, j int) bool {
-		// Ordered so that the least precise (largest) range comes last
-		ri, _ := filtered[i].SourceRange()
-		rj, _ := filtered[j].SourceRange()
-		return ri.CompareStrict(rj) > 0
-	})
-
+	// Ordered so that the least precise (largest) range comes last.
+	slices.SortFunc(filtered, func(a, b *Occurrence) int { return b.Compare(a) })
 	return filtered
 }
 
@@ -69,27 +64,10 @@ func FindOccurrences(occurrences []*Occurrence, targetLine, targetCharacter int3
 // come before the enclosed. If there are multiple occurrences with the exact same range, then the
 // occurrences are sorted by symbol name.
 func SortOccurrences(occurrences []*Occurrence) []*Occurrence {
-	sort.Slice(occurrences, func(i, j int) bool {
-		r1, _ := occurrences[i].SourceRange()
-		r2, _ := occurrences[j].SourceRange()
-		if ret := r1.CompareStrict(r2); ret != 0 {
-			return ret < 0
-		}
-		return occurrences[i].Symbol < occurrences[j].Symbol
-	})
-
+	slices.SortFunc(occurrences, (*Occurrence).Compare)
 	return occurrences
 }
 
-// occurrenceRangesEqual compares the source ranges of two occurrences for
-// equality, normalizing across the deprecated `repeated int32` and the typed
-// `typed_range` encodings.
-func occurrenceRangesEqual(a, b *Occurrence) bool {
-	ra, _ := a.SourceRange()
-	rb, _ := b.SourceRange()
-	return ra.CompareStrict(rb) == 0
-}
-
 // SortRanges sorts the given range slice (in-place) and returns it (for convenience). Ranges are
 // sorted in ascending order of starting position, where enclosing ranges come before the enclosed.
 func SortRanges(ranges []Range) []Range {