refactor(sidekick): use string for PathSegment.Literal (#5871)

This change converts the Literal field in the PathSegment struct from
`*string` to just `string`. This simplifies object construction and
eliminates the need for safe pointer handling (nil checks and
dereferences) throughout the codebase.

Author: ianthehat

internal/sidekick/api/model.go

@@ -741,8 +741,8 @@ func (template *PathTemplate) FlatPath() string {
 	sep := ""
 	for _, segment := range template.Segments {
 		buffer.WriteString(sep)
-		if segment.Literal != nil {
-			buffer.WriteString(*segment.Literal)
+		if segment.Literal != "" {
+			buffer.WriteString(segment.Literal)
 		} else if segment.Variable != nil {
 			fmt.Fprintf(&buffer, "{%s}", strings.Join(segment.Variable.FieldPath, "."))
 		}
@@ -753,7 +753,7 @@ func (template *PathTemplate) FlatPath() string {
 
 // PathSegment is a segment of a path.
 type PathSegment struct {
-	Literal  *string
+	Literal  string
 	Variable *PathVariable
 }
 
@@ -773,7 +773,7 @@ func NewPathVariable(fields ...string) *PathVariable {
 
 // WithLiteral adds a literal to the path template.
 func (p *PathTemplate) WithLiteral(l string) *PathTemplate {
-	p.Segments = append(p.Segments, PathSegment{Literal: &l})
+	p.Segments = append(p.Segments, PathSegment{Literal: l})
 	return p
 }
 
@@ -822,7 +822,7 @@ func (v *PathVariable) WithAllowReserved() *PathVariable {
 
 // WithLiteral adds a literal to the path segment.
 func (s *PathSegment) WithLiteral(l string) *PathSegment {
-	s.Literal = &l
+	s.Literal = l
 	return s
 }
 

internal/sidekick/api/model_test.go

@@ -206,12 +206,11 @@ func TestPathTemplateBuilder(t *testing.T) {
 			WithMatchRecursive()).
 		WithVariableNamed("v2", "field").
 		WithVerb("verb")
-	name := "v1"
 	verb := "verb"
 	want := &PathTemplate{
 		Segments: []PathSegment{
 			{
-				Literal: &name,
+				Literal: "v1",
 			},
 			{
 				Variable: &PathVariable{

internal/sidekick/api/resource_identification.go

@@ -85,11 +85,11 @@ func identifyHeuristicTarget(method *Method, binding *PathBinding, vocabulary ma
 	// Iterate backwards over segments
 	for i := len(tmpl.Segments) - 1; i >= 0; i-- {
 		seg := tmpl.Segments[i]
-		if seg.Variable == nil || i == 0 || tmpl.Segments[i-1].Literal == nil {
+		if seg.Variable == nil || i == 0 || tmpl.Segments[i-1].Literal == "" {
 			continue
 		}
 
-		token := *tmpl.Segments[i-1].Literal
+		token := tmpl.Segments[i-1].Literal
 		if !vocabulary[token] && !isVersionString(token) {
 			continue // continue scanning backward if not in vocabulary
 		}
@@ -105,8 +105,8 @@ func identifyHeuristicTarget(method *Method, binding *PathBinding, vocabulary ma
 				prevSeg := tmpl.Segments[firstIndex-1]
 
 				// Case 1: The preceding segment is a standalone literal (e.g., "global")
-				if prevSeg.Literal != nil {
-					if isVersionString(*prevSeg.Literal) {
+				if prevSeg.Literal != "" {
+					if isVersionString(prevSeg.Literal) {
 						break // Stop at version strings (e.g., "v1")
 					}
 					firstIndex--
@@ -115,11 +115,11 @@ func identifyHeuristicTarget(method *Method, binding *PathBinding, vocabulary ma
 
 				// Case 2: The preceding segment is a variable. It must be paired with a literal.
 				if prevSeg.Variable != nil {
-					if firstIndex < 2 || tmpl.Segments[firstIndex-2].Literal == nil {
+					if firstIndex < 2 || tmpl.Segments[firstIndex-2].Literal == "" {
 						break // Variable near the beginning, cannot form a pair
 					}
 
-					prevLiteralVal := *tmpl.Segments[firstIndex-2].Literal
+					prevLiteralVal := tmpl.Segments[firstIndex-2].Literal
 
 					// If the literal is a known collection, include the pair and continue
 					if vocabulary[prevLiteralVal] {
@@ -257,15 +257,15 @@ func constructTemplate(method *Method, segments []PathSegment) ([]PathSegment, e
 
 	var result []PathSegment
 	h := "//" + host
-	result = append(result, PathSegment{Literal: &h})
+	result = append(result, PathSegment{Literal: h})
 
 	for _, seg := range segments {
-		if seg.Literal != nil {
-			l := *seg.Literal
+		if seg.Literal != "" {
+			l := seg.Literal
 			if isVersionString(l) {
 				continue
 			}
-			result = append(result, PathSegment{Literal: &l})
+			result = append(result, PathSegment{Literal: l})
 		} else if seg.Variable != nil {
 			result = append(result, PathSegment{Variable: &PathVariable{
 				FieldPath: seg.Variable.FieldPath,

internal/sidekick/api/resource_name_heuristic.go

@@ -88,8 +88,8 @@ func BuildHeuristicVocabulary(model *API) map[string]bool {
 			for i := len(tmpl.Segments) - 1; i >= 0; i-- {
 				seg := tmpl.Segments[i]
 				if seg.Variable != nil {
-					if i > 0 && tmpl.Segments[i-1].Literal != nil {
-						token := *tmpl.Segments[i-1].Literal
+					if i > 0 && tmpl.Segments[i-1].Literal != "" {
+						token := tmpl.Segments[i-1].Literal
 						// Do not add API version strings (e.g., v1, v1beta1) to the vocabulary
 						if isVersionString(token) {
 							continue

internal/sidekick/api/test.go

@@ -284,15 +284,14 @@ func ParseTemplateForTest(template string) []PathSegment {
 	if strings.HasPrefix(template, "//") {
 		host = "//" + parts[0]
 	}
-	segments = append(segments, PathSegment{Literal: &host})
+	segments = append(segments, PathSegment{Literal: host})
 
 	for _, part := range parts[1:] {
 		if strings.HasPrefix(part, "{") && strings.HasSuffix(part, "}") {
 			fieldPath := strings.Split(part[1:len(part)-1], ".")
 			segments = append(segments, PathSegment{Variable: &PathVariable{FieldPath: fieldPath}})
 		} else {
-			l := part
-			segments = append(segments, PathSegment{Literal: &l})
+			segments = append(segments, PathSegment{Literal: part})
 		}
 	}
 	return segments

internal/sidekick/api/xref.go

@@ -411,12 +411,11 @@ func toResourceNamePattern(pattern ResourcePattern, skipLast bool) *ResourceName
 	var segments []ResourceNameSegment
 	for i := 0; i < len(pattern); i++ {
 		s := pattern[i]
-		if s.Literal != nil && strings.HasPrefix(*s.Literal, "//") {
+		if strings.HasPrefix(s.Literal, "//") {
 			continue
 		}
-		seg := ResourceNameSegment{}
-		if s.Literal != nil {
-			seg.Literal = *s.Literal
+		seg := ResourceNameSegment{
+			Literal: s.Literal,
 		}
 		if s.Variable != nil && len(s.Variable.FieldPath) > 0 {
 			// The parser used for parsing resource name patterns is the same used for
@@ -429,7 +428,7 @@ func toResourceNamePattern(pattern ResourcePattern, skipLast bool) *ResourceName
 		}
 
 		// Try to combine with next segment if this is a literal and next is variable
-		if s.Literal != nil && i+1 < len(pattern) && pattern[i+1].Variable != nil {
+		if s.Literal != "" && i+1 < len(pattern) && pattern[i+1].Variable != nil {
 			if len(pattern[i+1].Variable.FieldPath) > 0 {
 				seg.Variable = pattern[i+1].Variable.FieldPath[0]
 			}

internal/sidekick/dart/dart.go

@@ -170,9 +170,9 @@ func httpPathFmt(pathInfo *api.PathInfo) string {
 	t := pathInfo.Bindings[0].PathTemplate
 	for _, segment := range t.Segments {
 		switch {
-		case segment.Literal != nil:
+		case segment.Literal != "":
 			builder.WriteString("/")
-			builder.WriteString(*segment.Literal)
+			builder.WriteString(segment.Literal)
 		case segment.Variable != nil:
 			// Form '${request.foo!.bar!.baz}'.
 			builder.WriteString("/${request")

internal/sidekick/gcloud/path.go

@@ -108,8 +108,8 @@ func pathFormatFromSegments(segments []api.PathSegment) string {
 	var parts []string
 	for _, seg := range segments {
 		switch {
-		case seg.Literal != nil:
-			parts = append(parts, *seg.Literal)
+		case seg.Literal != "":
+			parts = append(parts, seg.Literal)
 		case seg.Variable != nil && len(seg.Variable.FieldPath) > 0:
 			parts = append(parts, "%s")
 			hasVar = true

internal/sidekick/parser/discovery/uritemplate.go

@@ -70,7 +70,7 @@ func ParseUriTemplate(uriTemplate string) (*api.PathTemplate, error) {
 			return nil, err
 		}
 		pos += width
-		template.Verb = literal.Literal
+		template.Verb = &literal.Literal
 	}
 	if pos != len(uriTemplate) {
 		return nil, fmt.Errorf("trailing data (%q) cannot be parsed as a URI template", uriTemplate[pos:])
@@ -150,5 +150,5 @@ func parseLiteral(input string) (*api.PathSegment, int, error) {
 	if tail != "" && tail[0] != slash {
 		return nil, index, fmt.Errorf("found unexpected character %v in literal %q, stopped at position %v", tail[0], input, index)
 	}
-	return &api.PathSegment{Literal: &literal}, width, nil
+	return &api.PathSegment{Literal: literal}, width, nil
 }

internal/sidekick/parser/discovery/uritemplate_test.go

@@ -141,7 +141,7 @@ func TestParseLiteral(t *testing.T) {
 			t.Errorf("expected a successful parse with input=%s, err=%v", test.input, err)
 			continue
 		}
-		if diff := cmp.Diff(&api.PathSegment{Literal: &test.want}, gotSegment); diff != "" {
+		if diff := cmp.Diff(&api.PathSegment{Literal: test.want}, gotSegment); diff != "" {
 			t.Errorf("mismatch [%s] (-want, +got):\n%s", test.input, diff)
 		}
 		if len(test.want) != gotWidth {