protoveneer: the protoveneer tool

This tool was written to facilitate writing the Gemini API clients in:

- github.com/googleapis/google-cloud-go/vertexai
- github.com/google/generative-ai-go

Change-Id: Ieb1c3d8abec5f06f2fd10604daa22dcaffa13ca0
Reviewed-on: https://go-review.googlesource.com/c/exp/+/549635
Run-TryBot: Jonathan Amsterdam <[email protected]>
Reviewed-by: Eli Bendersky <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>

Author: jba

protoveneer/README.md

@@ -0,0 +1,5 @@
+# The protoveneer tool
+
+Protoveneer is an experimental tool that generates idiomatic Go types that
+correspond to protocol buffer messages and enums -- a veneer on top of the proto
+layer.

protoveneer/cmd/protoveneer/config.go

@@ -0,0 +1,98 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+// config holds the configuration for a package.
+type config struct {
+	Package         string
+	ProtoImportPath string `yaml:"protoImportPath"`
+	// Import path for the support package needed by the generated code.
+	SupportImportPath string `yaml:"supportImportPath"`
+
+	// The types to process. Only these types and the types they depend
+	// on will be output.
+	// The key is the name of the proto type.
+	Types map[string]*typeConfig
+	// Omit the types in this list, even if they would normally be output.
+	// Elements can be globs.
+	OmitTypes []string `yaml:"omitTypes"`
+	// Converter functions for types not in the proto package.
+	// Each value should be "tofunc, fromfunc"
+	Converters map[string]string
+}
+
+type typeConfig struct {
+	// The name for the veneer type, if different.
+	Name string
+	// The prefix of the proto enum values. It will be removed.
+	ProtoPrefix string `yaml:"protoPrefix"`
+	// The prefix for the veneer enum values, if different from the type name.
+	VeneerPrefix string `yaml:"veneerPrefix"`
+	// Overrides for enum values.
+	ValueNames map[string]string `yaml:"valueNames"`
+	// Overrides for field types. Map key is proto field name.
+	Fields map[string]fieldConfig
+	// Custom conversion functions: "tofunc, fromfunc"
+	ConvertToFrom string `yaml:"convertToFrom"`
+	// Doc string for the type, omitting the initial type name.
+	Doc string
+	// Verb to place after type name in doc. Default: "is".
+	// Ignored if Doc is non-empty.
+	DocVerb string `yaml:"docVerb"`
+}
+
+type fieldConfig struct {
+	Name string // veneer name
+	Type string // veneer type
+	// Omit from output.
+	Omit bool
+}
+
+func (c *config) init() {
+	for protoName, tc := range c.Types {
+		if tc == nil {
+			tc = &typeConfig{Name: protoName}
+			c.Types[protoName] = tc
+		}
+		if tc.Name == "" {
+			tc.Name = protoName
+		}
+		tc.init()
+	}
+}
+
+func (tc *typeConfig) init() {
+	if tc.VeneerPrefix == "" {
+		tc.VeneerPrefix = tc.Name
+	}
+}
+
+func readConfigFile(filename string) (*config, error) {
+	if filename == "" {
+		return nil, errors.New("missing config file")
+	}
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	dec := yaml.NewDecoder(f)
+	dec.KnownFields(true)
+
+	var c config
+	if err := dec.Decode(&c); err != nil {
+		return nil, fmt.Errorf("reading %s: %w", filename, err)
+	}
+	c.init()
+	return &c, nil
+}

protoveneer/cmd/protoveneer/converters.go

@@ -0,0 +1,143 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "fmt"
+
+// A converter generates code to convert between a proto type and a veneer type.
+type converter interface {
+	// genFrom returns code to convert from proto to veneer.
+	genFrom(string) string
+	// genTo returns code to convert to proto from veneer.
+	genTo(string) string
+	// These return the function argument to Transform{Slice,MapValues}, or "" if we don't need it.
+	genTransformFrom() string
+	genTransformTo() string
+}
+
+// An identityConverter does no conversion.
+type identityConverter struct{}
+
+func (identityConverter) genFrom(arg string) string { return arg }
+func (identityConverter) genTo(arg string) string   { return arg }
+func (identityConverter) genTransformFrom() string  { return "" }
+func (identityConverter) genTransformTo() string    { return "" }
+
+// A derefConverter converts between T in the veneer and *T in the proto.
+type derefConverter struct{}
+
+func (derefConverter) genFrom(arg string) string { return fmt.Sprintf("support.DerefOrZero(%s)", arg) }
+func (derefConverter) genTo(arg string) string   { return fmt.Sprintf("support.AddrOrNil(%s)", arg) }
+func (derefConverter) genTransformFrom() string  { panic("can't handle deref slices") }
+func (derefConverter) genTransformTo() string    { panic("can't handle deref slices") }
+
+type enumConverter struct {
+	protoName, veneerName string
+}
+
+func (c enumConverter) genFrom(arg string) string {
+	return fmt.Sprintf("%s(%s)", c.veneerName, arg)
+}
+
+func (c enumConverter) genTransformFrom() string {
+	return fmt.Sprintf("func(p pb.%s) %s { return %s }", c.protoName, c.veneerName, c.genFrom("p"))
+}
+
+func (c enumConverter) genTo(arg string) string {
+	return fmt.Sprintf("pb.%s(%s)", c.protoName, arg)
+}
+
+func (c enumConverter) genTransformTo() string {
+	return fmt.Sprintf("func(v %s) pb.%s { return %s }", c.veneerName, c.protoName, c.genTo("v"))
+}
+
+type protoConverter struct {
+	veneerName string
+}
+
+func (c protoConverter) genFrom(arg string) string {
+	return fmt.Sprintf("(%s{}).fromProto(%s)", c.veneerName, arg)
+}
+
+func (c protoConverter) genTransformFrom() string {
+	return fmt.Sprintf("(%s{}).fromProto", c.veneerName)
+}
+
+func (c protoConverter) genTo(arg string) string {
+	return fmt.Sprintf("%s.toProto()", arg)
+}
+
+func (c protoConverter) genTransformTo() string {
+	return fmt.Sprintf("(*%s).toProto", c.veneerName)
+}
+
+type customConverter struct {
+	toFunc, fromFunc string
+}
+
+func (c customConverter) genFrom(arg string) string {
+	return fmt.Sprintf("%s(%s)", c.fromFunc, arg)
+}
+
+func (c customConverter) genTransformFrom() string { return c.fromFunc }
+
+func (c customConverter) genTo(arg string) string {
+	return fmt.Sprintf("%s(%s)", c.toFunc, arg)
+}
+
+func (c customConverter) genTransformTo() string { return c.toFunc }
+
+type sliceConverter struct {
+	eltConverter converter
+}
+
+func (c sliceConverter) genFrom(arg string) string {
+	if fn := c.eltConverter.genTransformFrom(); fn != "" {
+		return fmt.Sprintf("support.TransformSlice(%s, %s)", arg, fn)
+	}
+	return c.eltConverter.genFrom(arg)
+}
+
+func (c sliceConverter) genTo(arg string) string {
+	if fn := c.eltConverter.genTransformTo(); fn != "" {
+		return fmt.Sprintf("support.TransformSlice(%s, %s)", arg, fn)
+	}
+	return c.eltConverter.genTo(arg)
+}
+
+func (c sliceConverter) genTransformTo() string {
+	panic("sliceConverter.genToSlice called")
+}
+
+func (c sliceConverter) genTransformFrom() string {
+	panic("sliceConverter.genFromSlice called")
+}
+
+// Only the values are converted.
+type mapConverter struct {
+	valueConverter converter
+}
+
+func (c mapConverter) genFrom(arg string) string {
+	if fn := c.valueConverter.genTransformFrom(); fn != "" {
+		return fmt.Sprintf("support.TransformMapValues(%s, %s)", arg, fn)
+	}
+	return c.valueConverter.genFrom(arg)
+}
+
+func (c mapConverter) genTo(arg string) string {
+	if fn := c.valueConverter.genTransformTo(); fn != "" {
+		return fmt.Sprintf("support.TransformMapValues(%s, %s)", arg, fn)
+	}
+	return c.valueConverter.genTo(arg)
+}
+
+func (c mapConverter) genTransformTo() string {
+	panic("mapConverter.genToSlice called")
+}
+
+func (c mapConverter) genTransformFrom() string {
+	panic("mapConverter.genFromSlice called")
+}