add support for symbol references in defaults

refactor openapi test to return import lines

add symbol reference test

Author: alexzielenski

pkg/generators/openapi.go

@@ -26,6 +26,7 @@ import (
 	"sort"
 	"strings"
 
+	defaultergen "k8s.io/gengo/examples/defaulter-gen/generators"
 	"k8s.io/gengo/generator"
 	"k8s.io/gengo/namer"
 	"k8s.io/gengo/types"
@@ -120,7 +121,7 @@ func newOpenAPIGen(sanitizedName string, targetPackage string) generator.Generat
 		DefaultGen: generator.DefaultGen{
 			OptionalName: sanitizedName,
 		},
-		imports:       generator.NewImportTracker(),
+		imports:       generator.NewImportTrackerForPackage(targetPackage),
 		targetPackage: targetPackage,
 	}
 }
@@ -173,7 +174,7 @@ func (g *openAPIGen) Init(c *generator.Context, w io.Writer) error {
 	sw.Do("return map[string]$.OpenAPIDefinition|raw${\n", argsFromType(nil))
 
 	for _, t := range c.Order {
-		err := newOpenAPITypeWriter(sw, c).generateCall(t)
+		err := newOpenAPITypeWriter(sw, c, g.imports).generateCall(t)
 		if err != nil {
 			return err
 		}
@@ -188,7 +189,8 @@ func (g *openAPIGen) Init(c *generator.Context, w io.Writer) error {
 func (g *openAPIGen) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
 	klog.V(5).Infof("generating for type %v", t)
 	sw := generator.NewSnippetWriter(w, c, "$", "$")
-	err := newOpenAPITypeWriter(sw, c).generate(t)
+
+	err := newOpenAPITypeWriter(sw, c, g.imports).generate(t)
 	if err != nil {
 		return err
 	}
@@ -226,11 +228,13 @@ type openAPITypeWriter struct {
 	context                *generator.Context
 	refTypes               map[string]*types.Type
 	enumContext            *enumContext
+	imports                namer.ImportTracker
 	GetDefinitionInterface *types.Type
 }
 
-func newOpenAPITypeWriter(sw *generator.SnippetWriter, c *generator.Context) openAPITypeWriter {
+func newOpenAPITypeWriter(sw *generator.SnippetWriter, c *generator.Context, imports namer.ImportTracker) openAPITypeWriter {
 	return openAPITypeWriter{
+		imports:       imports,
 		SnippetWriter: sw,
 		context:       c,
 		refTypes:      map[string]*types.Type{},
@@ -553,19 +557,26 @@ func (g openAPITypeWriter) validatePatchTags(m *types.Member, parent *types.Type
 	return nil
 }
 
-func defaultFromComments(comments []string) (interface{}, error) {
+func defaultFromComments(comments []string, commentPath string) (interface{}, *types.Name, error) {
 	tag, err := getSingleTagsValue(comments, tagDefault)
 	if tag == "" {
-		return nil, err
+		return nil, nil, err
 	}
 	var i interface{}
-	if err := json.Unmarshal([]byte(tag), &i); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal default: %v", err)
+	if id, ok := defaultergen.ParseSymbolReference(tag, commentPath); ok {
+		return nil, &id, nil
+	} else if err := json.Unmarshal([]byte(tag), &i); err != nil {
+		return nil, nil, fmt.Errorf("failed to unmarshal default: %v", err)
 	}
-	return i, nil
+	return i, nil, nil
 }
 
 func mustEnforceDefault(t *types.Type, omitEmpty bool) (interface{}, error) {
+	// If t implements custom JSON marshalling, all of this logic is likely wrong
+	if _, isUnmarshaller := t.Methods["UnmarshalJSON"]; isUnmarshaller {
+		return nil, nil
+	}
+
 	switch t.Kind {
 	case types.Pointer, types.Map, types.Slice, types.Array, types.Interface:
 		return nil, nil
@@ -585,9 +596,10 @@ func mustEnforceDefault(t *types.Type, omitEmpty bool) (interface{}, error) {
 	}
 }
 
-func (g openAPITypeWriter) generateDefault(comments []string, t *types.Type, omitEmpty bool) error {
+func (g openAPITypeWriter) generateDefault(comments []string, t *types.Type, omitEmpty bool, commentOwningType *types.Type) error {
 	t = resolveAliasAndEmbeddedType(t)
-	def, err := defaultFromComments(comments)
+
+	def, ref, err := defaultFromComments(comments, commentOwningType.Name.Package)
 	if err != nil {
 		return err
 	}
@@ -603,6 +615,10 @@ func (g openAPITypeWriter) generateDefault(comments []string, t *types.Type, omi
 	}
 	if def != nil {
 		g.Do("Default: $.$,\n", fmt.Sprintf("%#v", def))
+	} else if ref != nil {
+		g.imports.AddSymbol(*ref)
+		ref.Package = g.imports.LocalNameOf(ref.Package)
+		g.Do("Default: $.$,\n", ref.String())
 	}
 	return nil
 }
@@ -676,7 +692,7 @@ func (g openAPITypeWriter) generateProperty(m *types.Member, parent *types.Type)
 		return nil
 	}
 	omitEmpty := strings.Contains(reflect.StructTag(m.Tags).Get("json"), "omitempty")
-	if err := g.generateDefault(m.CommentLines, m.Type, omitEmpty); err != nil {
+	if err := g.generateDefault(m.CommentLines, m.Type, omitEmpty, parent); err != nil {
 		return fmt.Errorf("failed to generate default in %v: %v: %v", parent, m.Name, err)
 	}
 	t := resolveAliasAndPtrType(m.Type)
@@ -762,7 +778,7 @@ func (g openAPITypeWriter) generateMapProperty(t *types.Type) error {
 
 	g.Do("Type: []string{\"object\"},\n", nil)
 	g.Do("AdditionalProperties: &spec.SchemaOrBool{\nAllows: true,\nSchema: &spec.Schema{\nSchemaProps: spec.SchemaProps{\n", nil)
-	if err := g.generateDefault(t.Elem.CommentLines, t.Elem, false); err != nil {
+	if err := g.generateDefault(t.Elem.CommentLines, t.Elem, false, t.Elem); err != nil {
 		return err
 	}
 	typeString, format := openapi.OpenAPITypeFormat(elemType.String())
@@ -795,7 +811,7 @@ func (g openAPITypeWriter) generateSliceProperty(t *types.Type) error {
 	elemType := resolveAliasAndPtrType(t.Elem)
 	g.Do("Type: []string{\"array\"},\n", nil)
 	g.Do("Items: &spec.SchemaOrArray{\nSchema: &spec.Schema{\nSchemaProps: spec.SchemaProps{\n", nil)
-	if err := g.generateDefault(t.Elem.CommentLines, t.Elem, false); err != nil {
+	if err := g.generateDefault(t.Elem.CommentLines, t.Elem, false, t.Elem); err != nil {
 		return err
 	}
 	typeString, format := openapi.OpenAPITypeFormat(elemType.String())