Add latest changes from gitlab-org/gitlab@16-2-stable-eev16.2.0-rc42

8 files changed, 198 insertions, 60 deletions

diff --git a/workhorse/internal/lsif_transformer/parser/hovers.go b/workhorse/internal/lsif_transformer/parser/hovers.go
index 33d45829295..b78c64d1556 100644
--- a/workhorse/internal/lsif_transformer/parser/hovers.go
+++ b/workhorse/internal/lsif_transformer/parser/hovers.go
@@ -30,11 +30,6 @@ type HoverRef struct {
 	HoverId     Id `json:"inV"`
 }
 
-type ResultSetRef struct {
-	ResultSetId Id `json:"outV"`
-	RefId       Id `json:"inV"`
-}
-
 func NewHovers() (*Hovers, error) {
 	file, err := os.CreateTemp("", "hovers")
 	if err != nil {
@@ -67,18 +62,14 @@ func (h *Hovers) Read(label string, line []byte) error {
 		if err := h.addHoverRef(line); err != nil {
 			return err
 		}
-	case "textDocument/references":
-		if err := h.addResultSetRef(line); err != nil {
-			return err
-		}
 	}
 
 	return nil
 }
 
-func (h *Hovers) For(refId Id) json.RawMessage {
+func (h *Hovers) For(resultSetId Id) json.RawMessage {
 	var offset Offset
-	if err := h.Offsets.Entry(refId, &offset); err != nil || offset.Len == 0 {
+	if err := h.Offsets.Entry(resultSetId, &offset); err != nil || offset.Len == 0 {
 		return nil
 	}
 
@@ -143,17 +134,3 @@ func (h *Hovers) addHoverRef(line []byte) error {
 
 	return h.Offsets.SetEntry(hoverRef.ResultSetId, &offset)
 }
-
-func (h *Hovers) addResultSetRef(line []byte) error {
-	var ref ResultSetRef
-	if err := json.Unmarshal(line, &ref); err != nil {
-		return err
-	}
-
-	var offset Offset
-	if err := h.Offsets.Entry(ref.ResultSetId, &offset); err != nil {
-		return nil
-	}
-
-	return h.Offsets.SetEntry(ref.RefId, &offset)
-}
diff --git a/workhorse/internal/lsif_transformer/parser/hovers_test.go b/workhorse/internal/lsif_transformer/parser/hovers_test.go
index 5b2166c07a1..0a6cba8a411 100644
--- a/workhorse/internal/lsif_transformer/parser/hovers_test.go
+++ b/workhorse/internal/lsif_transformer/parser/hovers_test.go
@@ -13,7 +13,7 @@ func TestHoversRead(t *testing.T) {
 	require.NoError(t, h.Offsets.Entry(2, &offset))
 	require.Equal(t, Offset{At: 0, Len: 19}, offset)
 
-	require.Equal(t, `[{"value":"hello"}]`, string(h.For(1)))
+	require.Equal(t, `[{"value":"hello"}]`, string(h.For(3)))
 
 	require.NoError(t, h.Close())
 }
@@ -24,7 +24,6 @@ func setupHovers(t *testing.T) *Hovers {
 
 	require.NoError(t, h.Read("hoverResult", []byte(`{"id":"2","label":"hoverResult","result":{"contents": ["hello"]}}`)))
 	require.NoError(t, h.Read("textDocument/hover", []byte(`{"id":4,"label":"textDocument/hover","outV":"3","inV":2}`)))
-	require.NoError(t, h.Read("textDocument/references", []byte(`{"id":"3","label":"textDocument/references","outV":3,"inV":"1"}`)))
 
 	return h
 }
diff --git a/workhorse/internal/lsif_transformer/parser/ranges.go b/workhorse/internal/lsif_transformer/parser/ranges.go
index 0b4bd588e16..56472a34447 100644
--- a/workhorse/internal/lsif_transformer/parser/ranges.go
+++ b/workhorse/internal/lsif_transformer/parser/ranges.go
@@ -7,15 +7,10 @@ import (
 	"strconv"
 )
 
-const (
-	definitions = "definitions"
-	references  = "references"
-)
-
 type Ranges struct {
 	DefRefs    map[Id]Item
 	References *References
-	Hovers     *Hovers
+	ResultSet  *ResultSet
 	Cache      *cache
 }
 
@@ -25,9 +20,9 @@ type RawRange struct {
 }
 
 type Range struct {
-	Line      int32 `json:"line"`
-	Character int32 `json:"character"`
-	RefId     Id
+	Line        int32 `json:"line"`
+	Character   int32 `json:"character"`
+	ResultSetId Id
 }
 
 type RawItem struct {
@@ -51,7 +46,7 @@ type SerializedRange struct {
 }
 
 func NewRanges() (*Ranges, error) {
-	hovers, err := NewHovers()
+	resultSet, err := NewResultSet()
 	if err != nil {
 		return nil, err
 	}
@@ -69,8 +64,8 @@ func NewRanges() (*Ranges, error) {
 	return &Ranges{
 		DefRefs:    make(map[Id]Item),
 		References: references,
-		Hovers:     hovers,
 		Cache:      cache,
+		ResultSet:  resultSet,
 	}, nil
 }
 
@@ -85,7 +80,7 @@ func (r *Ranges) Read(label string, line []byte) error {
 			return err
 		}
 	default:
-		return r.Hovers.Read(label, line)
+		return r.ResultSet.Read(label, line)
 	}
 
 	return nil
@@ -108,9 +103,9 @@ func (r *Ranges) Serialize(f io.Writer, rangeIds []Id, docs map[Id]string) error
 		serializedRange := SerializedRange{
 			StartLine:      entry.Line,
 			StartChar:      entry.Character,
-			DefinitionPath: r.definitionPathFor(docs, entry.RefId),
-			Hover:          r.Hovers.For(entry.RefId),
-			References:     r.References.For(docs, entry.RefId),
+			DefinitionPath: r.definitionPathFor(docs, entry.ResultSetId),
+			Hover:          r.ResultSet.Hovers.For(entry.ResultSetId),
+			References:     r.References.For(docs, entry.ResultSetId),
 		}
 		if err := encoder.Encode(serializedRange); err != nil {
 			return err
@@ -133,7 +128,7 @@ func (r *Ranges) Close() error {
 	for _, err := range []error{
 		r.Cache.Close(),
 		r.References.Close(),
-		r.Hovers.Close(),
+		r.ResultSet.Close(),
 	} {
 		if err != nil {
 			return err
@@ -168,23 +163,23 @@ func (r *Ranges) addItem(line []byte) error {
 		return err
 	}
 
-	if rawItem.Property != definitions && rawItem.Property != references {
-		return nil
-	}
-
 	if len(rawItem.RangeIds) == 0 {
 		return errors.New("no range IDs")
 	}
 
-	var references []Item
+	resultSetRef, err := r.ResultSet.RefById(rawItem.RefId)
+	if err != nil {
+		return nil
+	}
 
+	var references []Item
 	for _, rangeId := range rawItem.RangeIds {
 		rg, err := r.getRange(rangeId)
 		if err != nil {
-			return err
+			break
 		}
 
-		rg.RefId = rawItem.RefId
+		rg.ResultSetId = resultSetRef.Id
 
 		if err := r.Cache.SetEntry(rangeId, rg); err != nil {
 			return err
@@ -195,14 +190,19 @@ func (r *Ranges) addItem(line []byte) error {
 			DocId: rawItem.DocId,
 		}
 
-		if rawItem.Property == definitions {
-			r.DefRefs[rawItem.RefId] = item
+		definitionItem := r.DefRefs[resultSetRef.Id]
+		if item == definitionItem {
+			continue
+		}
+
+		if resultSetRef.IsDefinition() {
+			r.DefRefs[resultSetRef.Id] = item
 		} else {
 			references = append(references, item)
 		}
 	}
 
-	if err := r.References.Store(rawItem.RefId, references); err != nil {
+	if err := r.References.Store(resultSetRef.Id, references); err != nil {
 		return err
 	}
 
diff --git a/workhorse/internal/lsif_transformer/parser/ranges_test.go b/workhorse/internal/lsif_transformer/parser/ranges_test.go
index 807945b41b1..bab132115e6 100644
--- a/workhorse/internal/lsif_transformer/parser/ranges_test.go
+++ b/workhorse/internal/lsif_transformer/parser/ranges_test.go
@@ -11,17 +11,17 @@ func TestRangesRead(t *testing.T) {
 	r, cleanup := setup(t)
 	defer cleanup()
 
-	firstRange := Range{Line: 1, Character: 2, RefId: 4}
+	firstRange := Range{Line: 1, Character: 2, ResultSetId: 4}
 	rg, err := r.getRange(1)
 	require.NoError(t, err)
 	require.Equal(t, &firstRange, rg)
 
-	secondRange := Range{Line: 5, Character: 4, RefId: 4}
+	secondRange := Range{Line: 5, Character: 4, ResultSetId: 4}
 	rg, err = r.getRange(2)
 	require.NoError(t, err)
 	require.Equal(t, &secondRange, rg)
 
-	thirdRange := Range{Line: 7, Character: 4, RefId: 4}
+	thirdRange := Range{Line: 7, Character: 4, ResultSetId: 4}
 	rg, err = r.getRange(3)
 	require.NoError(t, err)
 	require.Equal(t, &thirdRange, rg)
@@ -49,9 +49,17 @@ func setup(t *testing.T) (*Ranges, func()) {
 	require.NoError(t, r.Read("range", []byte(`{"id":"2","label":"range","start":{"line":5,"character":4}}`)))
 	require.NoError(t, r.Read("range", []byte(`{"id":"3","label":"range","start":{"line":7,"character":4}}`)))
 
-	require.NoError(t, r.Read("item", []byte(`{"id":5,"label":"item","property":"definitions","outV":"4","inVs":[1],"document":"6"}`)))
-	require.NoError(t, r.Read("item", []byte(`{"id":"6","label":"item","property":"references","outV":4,"inVs":["2"],"document":"7"}`)))
-	require.NoError(t, r.Read("item", []byte(`{"id":"7","label":"item","property":"references","outV":4,"inVs":["3"],"document":"7"}`)))
+	require.NoError(t, r.Read("resultSet", []byte(`{"id":"4","label":"resultSet"}`)))
+	require.NoError(t, r.Read("referenceResult", []byte(`{"id":"5","label":"referenceResult"}`)))
+	require.NoError(t, r.Read("definitionResult", []byte(`{"id":"6","label":"definitionResult"}`)))
+
+	require.NoError(t, r.Read("textDocument/references", []byte(`{"id":7,"label":"textDocument/references","outV":"4","inV":5}`)))
+	require.NoError(t, r.Read("textDocument/definition", []byte(`{"id":8,"label":"textDocument/definition","outV":"4","inV":6}`)))
+
+	require.NoError(t, r.Read("item", []byte(`{"id":10,"label":"item","outV":"6","inVs":[1,14],"document":"6"}`)))
+	require.NoError(t, r.Read("item", []byte(`{"id":11,"label":"item","outV":"5","inVs":[1,15],"document":"6"}`)))
+	require.NoError(t, r.Read("item", []byte(`{"id":"12","label":"item","outV":5,"inVs":["2"],"document":"7"}`)))
+	require.NoError(t, r.Read("item", []byte(`{"id":"13","label":"item","outV":5,"inVs":["3"],"document":"7"}`)))
 
 	cleanup := func() {
 		require.NoError(t, r.Close())
diff --git a/workhorse/internal/lsif_transformer/parser/result_set.go b/workhorse/internal/lsif_transformer/parser/result_set.go
new file mode 100644
index 00000000000..aa0b212d0ca
--- /dev/null
+++ b/workhorse/internal/lsif_transformer/parser/result_set.go
@@ -0,0 +1,100 @@
+package parser
+
+import (
+	"encoding/json"
+)
+
+type Property int8
+
+const (
+	DefinitionProp Property = iota
+	ReferencesProp
+)
+
+type ResultSet struct {
+	Hovers *Hovers
+	Cache  *cache
+}
+
+type ResultSetRef struct {
+	Id       Id
+	Property Property
+}
+
+type RawResultSetRef struct {
+	ResultSetId Id `json:"outV"`
+	RefId       Id `json:"inV"`
+}
+
+func NewResultSet() (*ResultSet, error) {
+	hovers, err := NewHovers()
+	if err != nil {
+		return nil, err
+	}
+
+	cache, err := newCache("results-set-refs", &ResultSetRef{})
+	if err != nil {
+		return nil, err
+	}
+
+	return &ResultSet{
+		Hovers: hovers,
+		Cache:  cache,
+	}, nil
+}
+
+func (r *ResultSet) Read(label string, line []byte) error {
+	switch label {
+	case "textDocument/references":
+		if err := r.addResultSetRef(line, ReferencesProp); err != nil {
+			return err
+		}
+	case "textDocument/definition":
+		if err := r.addResultSetRef(line, DefinitionProp); err != nil {
+			return err
+		}
+	default:
+		return r.Hovers.Read(label, line)
+	}
+
+	return nil
+}
+
+func (r *ResultSet) RefById(refId Id) (*ResultSetRef, error) {
+	var ref ResultSetRef
+	if err := r.Cache.Entry(refId, &ref); err != nil {
+		return nil, err
+	}
+
+	return &ref, nil
+}
+
+func (r *ResultSet) Close() error {
+	for _, err := range []error{
+		r.Cache.Close(),
+		r.Hovers.Close(),
+	} {
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r *ResultSet) addResultSetRef(line []byte, property Property) error {
+	var rawRef RawResultSetRef
+	if err := json.Unmarshal(line, &rawRef); err != nil {
+		return err
+	}
+
+	ref := &ResultSetRef{
+		Id:       rawRef.ResultSetId,
+		Property: property,
+	}
+
+	return r.Cache.SetEntry(rawRef.RefId, ref)
+}
+
+func (r *ResultSetRef) IsDefinition() bool {
+	return r.Property == DefinitionProp
+}
diff --git a/workhorse/internal/lsif_transformer/parser/result_set_test.go b/workhorse/internal/lsif_transformer/parser/result_set_test.go
new file mode 100644
index 00000000000..9a7e6a1d037
--- /dev/null
+++ b/workhorse/internal/lsif_transformer/parser/result_set_test.go
@@ -0,0 +1,48 @@
+package parser
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestResultSetRead(t *testing.T) {
+	r := setupResultSet(t)
+
+	var ref ResultSetRef
+	require.NoError(t, r.Cache.Entry(2, &ref))
+	require.Equal(t, ResultSetRef{Id: 1, Property: ReferencesProp}, ref)
+	require.False(t, ref.IsDefinition())
+
+	require.NoError(t, r.Cache.Entry(4, &ref))
+	require.Equal(t, ResultSetRef{Id: 3, Property: DefinitionProp}, ref)
+	require.True(t, ref.IsDefinition())
+
+	require.NoError(t, r.Close())
+}
+
+func TestResultSetRefById(t *testing.T) {
+	r := setupResultSet(t)
+
+	ref, err := r.RefById(2)
+	require.NoError(t, err)
+	require.Equal(t, &ResultSetRef{Id: 1, Property: ReferencesProp}, ref)
+	require.False(t, ref.IsDefinition())
+
+	ref, err = r.RefById(4)
+	require.NoError(t, err)
+	require.Equal(t, &ResultSetRef{Id: 3, Property: DefinitionProp}, ref)
+	require.True(t, ref.IsDefinition())
+
+	require.NoError(t, r.Close())
+}
+
+func setupResultSet(t *testing.T) *ResultSet {
+	r, err := NewResultSet()
+	require.NoError(t, err)
+
+	require.NoError(t, r.Read("textDocument/references", []byte(`{"id":4,"label":"textDocument/references","outV":"1","inV":2}`)))
+	require.NoError(t, r.Read("textDocument/definition", []byte(`{"id":5,"label":"textDocument/definition","outV":"3","inV":4}`)))
+
+	return r
+}
diff --git a/workhorse/internal/senddata/contentprocessor/contentprocessor_test.go b/workhorse/internal/senddata/contentprocessor/contentprocessor_test.go
index e863935be6f..28a8d905ff2 100644
--- a/workhorse/internal/senddata/contentprocessor/contentprocessor_test.go
+++ b/workhorse/internal/senddata/contentprocessor/contentprocessor_test.go
@@ -85,6 +85,12 @@ func TestSetProperContentTypeAndDisposition(t *testing.T) {
 			body:               "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 330 82\"><title>SVG logo combined with the W3C logo, set horizontally</title><desc>The logo combines three entities displayed horizontall</desc><metadata>",
 		},
 		{
+			desc:               "Incomplete SVG start tag",
+			contentType:        "image/svg+xml",
+			contentDisposition: "attachment",
+			body:               "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"",
+		},
+		{
 			desc:               "Application type",
 			contentType:        "application/octet-stream",
 			contentDisposition: "attachment",
diff --git a/workhorse/internal/utils/svg/svg.go b/workhorse/internal/utils/svg/svg.go
index b209cb5bf33..72bda6d656f 100644
--- a/workhorse/internal/utils/svg/svg.go
+++ b/workhorse/internal/utils/svg/svg.go
@@ -13,7 +13,7 @@ import (
 
 var (
 	htmlCommentRegex = regexp.MustCompile(`(?i)<!--([\s\S]*?)-->`)
-	svgRegex         = regexp.MustCompile(`(?i)^\s*(?:<\?xml[^>]*>\s*)?(?:<!doctype svg[^>]*>\s*)?<svg[^>]*>`)
+	svgRegex         = regexp.MustCompile(`(?i)^\s*(?:<\?xml[^>]*>\s*)?(?:<!doctype svg[^>]*>\s*)?<svg[^>]*`)
 )
 
 // isBinary checks if the given buffer is a binary file.