fix: go2proto slices of int weren't working (#3713)

cmd/go2proto/main.go

@@ -144,10 +144,11 @@ func (m Message) DeclName() string { return m.Name }
 type Field struct {
 	ID          int
 	Name        string
-	Type        string
+	OriginType  string // The original type of the field, eg. int, string, float32, etc.
+	ProtoType   string // The type of the field in the generated .proto file.
+	ProtoGoType string // The type of the field in the generated Go protobuf code. eg. int -> int64.
 	Optional    bool
 	Repeated    bool
-	ProtoGoType string
 	Pointer     bool
 }
 
@@ -531,21 +532,26 @@ func parsePBTag(tag string) (pbTag, error) {
 }
 
 func (s *State) applyFieldType(t types.Type, field *Field) error {
+	field.OriginType = t.String()
 	switch t := t.(type) {
 	case *types.Named:
 		if err := s.extractDecl(t.Obj(), t); err != nil {
 			return err
 		}
 		ref := t.Obj().Pkg().Path() + "." + t.Obj().Name()
 		if bt, ok := stdTypes[ref]; ok {
-			field.Type = bt.ref
+			field.ProtoType = bt.ref
+			field.ProtoGoType = protoName(bt.ref)
+			field.OriginType = t.Obj().Name()
 		} else {
-			field.Type = t.Obj().Name()
+			field.ProtoType = t.Obj().Name()
+			field.ProtoGoType = protoName(t.Obj().Name())
+			field.OriginType = t.Obj().Name()
 		}
 
 	case *types.Slice:
 		if t.Elem().String() == "byte" {
-			field.Type = "bytes"
+			field.ProtoType = "bytes"
 		} else {
 			field.Repeated = true
 			return s.applyFieldType(t.Elem(), field)
@@ -554,31 +560,30 @@ func (s *State) applyFieldType(t types.Type, field *Field) error {
 	case *types.Pointer:
 		field.Pointer = true
 		if _, ok := t.Elem().(*types.Slice); ok {
-			return fmt.Errorf("pointer to named type is not supported")
+			return fmt.Errorf("pointer to slice is not supported")
 		}
 		return s.applyFieldType(t.Elem(), field)
 
 	default:
+		field.OriginType = t.String()
+		field.ProtoType = t.String()
 		field.ProtoGoType = t.String()
 		switch t.String() {
 		case "int":
-			field.Type = "int64"
+			field.ProtoType = "int64"
 			field.ProtoGoType = "int64"
 
 		case "uint":
-			field.Type = "uint64"
+			field.ProtoType = "uint64"
 			field.ProtoGoType = "uint64"
 
 		case "float64":
-			field.Type = "double"
-			field.ProtoGoType = "float64"
+			field.ProtoType = "double"
 
 		case "float32":
-			field.Type = "float"
-			field.ProtoGoType = "float32"
+			field.ProtoType = "float"
 
 		case "string", "bool", "uint64", "int64", "uint32", "int32":
-			field.Type = t.String()
 
 		default:
 			return fmt.Errorf("unsupported type %s", t.String())

cmd/go2proto/pbtmpl.go

@@ -34,7 +34,7 @@ option {{ $name }} = {{ $value }};
 {{- if eq (typeof $decl) "Message" }}
 message {{ .Name }} {
 {{- range $name, $field := .Fields }}
-  {{ if .Repeated }}repeated {{else if .Optional}}optional {{ end }}{{ .Type }} {{ .Name | toLowerSnake }} = {{ .ID }};
+  {{ if .Repeated }}repeated {{else if .Optional}}optional {{ end }}{{ .ProtoType }} {{ .Name | toLowerSnake }} = {{ .ID }};
 {{- end }}
 }
 {{- else if eq (typeof $decl) "Enum" }}

cmd/go2proto/testdata/model.go

@@ -5,16 +5,16 @@ import (
 )
 
 type Root struct {
-	Int            int      `protobuf:"1"`
-	String         string   `protobuf:"2"`
-	MessagePtr     *Message `protobuf:"4"`
-	Enum           Enum     `protobuf:"5"`
-	SumType        SumType  `protobuf:"6"`
-	OptionalInt    int      `protobuf:"7,optional"`
-	OptionalIntPtr *int     `protobuf:"8,optional"`
-	OptionalMsg    *Message `protobuf:"9,optional"`
-	// RepeatedInt []int     `protobuf:"9"`
-	// RepeatedMsg []Message `protobuf:"10"`
+	Int            int        `protobuf:"1"`
+	String         string     `protobuf:"2"`
+	MessagePtr     *Message   `protobuf:"4"`
+	Enum           Enum       `protobuf:"5"`
+	SumType        SumType    `protobuf:"6"`
+	OptionalInt    int        `protobuf:"7,optional"`
+	OptionalIntPtr *int       `protobuf:"8,optional"`
+	OptionalMsg    *Message   `protobuf:"9,optional"`
+	RepeatedInt    []int      `protobuf:"10"`
+	RepeatedMsg    []*Message `protobuf:"11"`
 }
 
 type Message struct {

cmd/go2proto/testdata/model_test.go

@@ -21,6 +21,8 @@ func TestModel(t *testing.T) {
 		OptionalInt:    2,
 		OptionalIntPtr: &intv,
 		OptionalMsg:    &Message{Time: time.Now()},
+		RepeatedInt:    []int{1, 2, 3},
+		RepeatedMsg:    []*Message{&Message{Time: time.Now()}, &Message{Time: time.Now()}},
 	}
 	pb := model.ToProto()
 	data, err := proto.Marshal(pb)

cmd/go2proto/testdata/testdatapb/model.proto

@@ -28,6 +28,8 @@ message Root {
   optional int64 optional_int = 7;
   optional int64 optional_int_ptr = 8;
   optional Message optional_msg = 9;
+  repeated int64 repeated_int = 10;
+  repeated Message repeated_msg = 11;
 }
 
 

cmd/go2proto/toprototmpl.go

@@ -13,13 +13,13 @@ import (
 
 var _ fmt.Stringer
 
-var go2protoTmpl = template.Must(template.New("go2proto.mapper.go").
+var go2protoTmpl = template.Must(template.New("go2proto.to.go.tmpl").
 	Funcs(template.FuncMap{
 		"typeof": func(t any) string { return reflect.Indirect(reflect.ValueOf(t)).Type().Name() },
 		// Return true if the type is a builtin proto type.
 		"isBuiltin": func(t Field) bool {
-			switch t.Type {
-			case "int32", "int64", "uint32", "uint64", "float", "double", "bool", "string":
+			switch t.OriginType {
+			case "int", "uint", "int32", "int64", "uint32", "uint64", "float32", "float64", "bool", "string":
 				return true
 			}
 			return false
@@ -88,34 +88,34 @@ func (x *{{ .Name }}) ToProto() *destpb.{{ .Name }} {
 {{- if $field.Optional}}
 		{{ $field.EscapedName }}: proto.{{ $field.ProtoGoType | toUpperCamel }}({{ $field.ProtoGoType }}({{if $field.Pointer}}*{{end}}x.{{ $field.Name }})),
 {{- else if .Repeated}}
-		{{ $field.EscapedName }}: protoSlicef(x.{{ $field.Name }}, func(v {{ $field.Type }}) {{ $field.ProtoGoType }} { return {{ $field.ProtoGoType }}(v) }),
+		{{ $field.EscapedName }}: protoSlicef(x.{{ $field.Name }}, func(v {{ $field.OriginType }}) {{ $field.ProtoGoType }} { return {{ $field.ProtoGoType }}(v) }),
 {{- else }}
 		{{ $field.EscapedName }}: {{ $field.ProtoGoType }}(x.{{ $field.Name }}),
 {{- end}}
-{{- else if eq $field.Type "google.protobuf.Timestamp" }}
+{{- else if eq $field.ProtoType "google.protobuf.Timestamp" }}
 		{{ $field.EscapedName }}: timestamppb.New(x.{{ $field.Name }}),
-{{- else if eq $field.Type "google.protobuf.Duration" }}
+{{- else if eq $field.ProtoType "google.protobuf.Duration" }}
 		{{ $field.EscapedName }}: durationpb.New(x.{{ $field.Name }}),
-{{- else if eq (.Type | $.TypeOf) "Message" }}
+{{- else if eq (.OriginType | $.TypeOf) "Message" }}
 {{- if .Repeated }}
-		{{ $field.EscapedName }}: protoSlice[*destpb.{{ .Type }}](x.{{ $field.Name }}),
+		{{ $field.EscapedName }}: protoSlice[*destpb.{{ .ProtoGoType }}](x.{{ $field.Name }}),
 {{- else}}
 		{{ $field.EscapedName }}: x.{{ $field.Name }}.ToProto(),
 {{- end}}
-{{- else if eq (.Type | $.TypeOf) "Enum" }}
+{{- else if eq (.OriginType | $.TypeOf) "Enum" }}
 {{- if .Repeated }}
 		{{ $field.EscapedName }}: protoSlice[destpb.{{ .Type }}](x.{{ $field.Name }}),
 {{- else}}
 		{{ $field.EscapedName }}: x.{{ $field.Name }}.ToProto(),
 {{- end}}
-{{- else if eq (.Type | $.TypeOf) "SumType" }}
+{{- else if eq (.OriginType | $.TypeOf) "SumType" }}
 {{- if .Repeated }}
-		{{ $field.EscapedName }}: protoSlicef(x.{{ $field.Name }}, {{$field.Type}}ToProto),
+		{{ $field.EscapedName }}: protoSlicef(x.{{ $field.Name }}, {{$field.OriginType}}ToProto),
 {{- else}}
-		{{ $field.EscapedName }}: {{ $field.Type }}ToProto(x.{{ $field.Name }}),
+		{{ $field.EscapedName }}: {{ $field.OriginType }}ToProto(x.{{ $field.Name }}),
 {{- end}}
 {{- else }}
-		{{ $field.EscapedName }}: ??, // x.{{ $field.Name }}.ToProto() // Unknown type: {{ $field.Type }}
+		{{ $field.EscapedName }}: ??, // x.{{ $field.Name }}.ToProto() // Unknown type: {{ $field.OriginType }}
 {{- end}}
 {{- end}}
 	}