bugfix: cast to alias in generated defaults in pointer

also unconditionally cast when using references since we dont know their source type

otherwise if you have a `string` field, and provide a `type Value string`-valued default, you get an error trying to assign an alias to a string

Author: alexzielenski

examples/defaulter-gen/_output_tests/marker/zz_generated.go

@@ -442,16 +442,16 @@ func newCallTreeForType(existingDefaulters, newDefaulters defaulterFuncMap) *cal
 	}
 }
 
-func resolveTypeAndDepth(t *types.Type) (*types.Type, int) {
+func resolveTypeAndDepth(t *types.Type) (*types.Type, []*types.Type) {
 	var prev *types.Type
-	depth := 0
+	var depth []*types.Type
 	for prev != t {
 		prev = t
 		if t.Kind == types.Alias {
 			t = t.Underlying
 		} else if t.Kind == types.Pointer {
 			t = t.Elem
-			depth += 1
+			depth = append(depth, t)
 		}
 	}
 	return t, depth
@@ -526,15 +526,16 @@ func populateDefaultValue(node *callNode, t *types.Type, tags string, commentLin
 	var defaultString string
 	if len(defaultMap) == 1 {
 		defaultString = defaultMap[0]
+	} else if len(defaultMap) > 1 {
+		klog.Fatalf("Found more than one default tag for %v", t.Kind)
 	}
 
-	t, depth := resolveTypeAndDepth(t)
-	if depth > 0 && defaultString == "" {
+	baseT, depth := resolveTypeAndDepth(t)
+	if len(depth) > 0 && defaultString == "" {
 		defaultString = getNestedDefault(t)
 	}
-	if len(defaultMap) > 1 {
-		klog.Fatalf("Found more than one default tag for %v", t.Kind)
-	} else if len(defaultMap) == 0 {
+
+	if len(defaultString) == 0 {
 		return node
 	}
 	var symbolReference types.Name
@@ -547,7 +548,7 @@ func populateDefaultValue(node *callNode, t *types.Type, tags string, commentLin
 	}
 
 	omitEmpty := strings.Contains(reflect.StructTag(tags).Get("json"), "omitempty")
-	if enforced, err := mustEnforceDefault(t, depth, omitEmpty); err != nil {
+	if enforced, err := mustEnforceDefault(baseT, len(depth), omitEmpty); err != nil {
 		klog.Fatal(err)
 	} else if enforced != nil {
 		if defaultValue != nil {
@@ -568,8 +569,9 @@ func populateDefaultValue(node *callNode, t *types.Type, tags string, commentLin
 		node.markerOnly = true
 	}
 
-	node.defaultIsPrimitive = t.IsPrimitive()
-	node.defaultType = t.String()
+	node.defaultIsPrimitive = baseT.IsPrimitive()
+	node.defaultType = baseT.String()
+	node.defaultTopLevelType = t
 	node.defaultValue.InlineConstant = defaultString
 	node.defaultValue.SymbolReference = symbolReference
 	node.defaultDepth = depth
@@ -893,11 +895,15 @@ type callNode struct {
 	//       +default="foo"
 	//       Field *string
 	//     }
-	defaultDepth int
+	defaultDepth []*types.Type
 
 	// defaultType is the type of the default value.
 	// Only populated if defaultIsPrimitive is true
 	defaultType string
+
+	// defaultTopLevelType is the final type the value should resolve to
+	// This is in constrast with default type, which resolves aliases and pointers.
+	defaultTopLevelType *types.Type
 }
 
 type defaultValue struct {
@@ -996,8 +1002,9 @@ func (n *callNode) writeDefaulter(varName string, index string, isVarPointer boo
 		"defaultValue": n.defaultValue.Resolved(),
 		"varName":      varName,
 		"index":        index,
-		"varDepth":     n.defaultDepth,
+		"varDepth":     len(n.defaultDepth),
 		"varType":      n.defaultType,
+		"varTopType":   n.defaultTopLevelType,
 	}
 
 	variablePlaceholder := ""
@@ -1021,15 +1028,54 @@ func (n *callNode) writeDefaulter(varName string, index string, isVarPointer boo
 	if n.defaultIsPrimitive {
 		// If the default value is a primitive when the assigned type is a pointer
 		// keep using the address-of operator on the primitive value until the types match
-		if n.defaultDepth > 0 {
-			sw.Do(fmt.Sprintf("if %s == nil {\n", variablePlaceholder), args)
-			sw.Do("var ptrVar$.varDepth$ $.varType$ = $.defaultValue$\n", args)
-			// We iterate until a depth of 1 instead of 0 because the following line
-			// `if $.varName$ == &ptrVar1` accounts for 1 level already
-			for i := n.defaultDepth; i > 1; i-- {
-				sw.Do("ptrVar$.ptri$ := &ptrVar$.i$\n", generator.Args{"i": fmt.Sprintf("%d", i), "ptri": fmt.Sprintf("%d", (i - 1))})
+		if len(n.defaultDepth) > 0 {
+			// If the destination is a pointer, the last element in
+			// defaultDepth is the element type of the bottommost pointer:
+			// the base type of our default value.
+			destElemType := n.defaultDepth[len(n.defaultDepth)-1]
+			pointerArgs := args.With("baseElemType", destElemType)
+
+			sw.Do(fmt.Sprintf("if %s == nil {\n", variablePlaceholder), pointerArgs)
+			if len(n.defaultValue.InlineConstant) > 0 {
+				// If default value is a literal then it can be assigned via var stmt
+				sw.Do("var ptrVar$.varDepth$ $.baseElemType|raw$ = $.defaultValue$\n", pointerArgs)
+			} else {
+				// If default value is not a literal then it may need to be casted
+				// to the base type of the destination pointer
+				sw.Do("ptrVar$.varDepth$ := $.baseElemType|raw$($.defaultValue$)\n", pointerArgs)
+			}
+
+			for i := len(n.defaultDepth); i >= 1; i-- {
+				dest := fmt.Sprintf("ptrVar%d", i-1)
+				assignment := ":="
+				if i == 1 {
+					// Last assignment is into the storage destination
+					dest = variablePlaceholder
+					assignment = "="
+				}
+
+				sourceType := "*" + destElemType.String()
+				if i == len(n.defaultDepth) {
+					// Initial value is not a pointer
+					sourceType = destElemType.String()
+				}
+				destElemType = n.defaultDepth[i-1]
+
+				// Cannot include `dest` into args since its value may be
+				// `variablePlaceholder` which is a template, not a value
+				elementArgs := pointerArgs.WithArgs(generator.Args{
+					"assignment":   assignment,
+					"source":       fmt.Sprintf("ptrVar%d", i),
+					"destElemType": destElemType,
+				})
+
+				// Skip cast if type is exact match
+				if destElemType.String() == sourceType {
+					sw.Do(fmt.Sprintf("%v $.assignment$ &$.source$\n", dest), elementArgs)
+				} else {
+					sw.Do(fmt.Sprintf("%v $.assignment$ (*$.destElemType|raw$)(&$.source$)\n", dest), elementArgs)
+				}
 			}
-			sw.Do(fmt.Sprintf("%s = &ptrVar1", variablePlaceholder), args)
 		} else {
 			// For primitive types, nil checks cannot be used and the zero value must be determined
 			defaultZero, err := getTypeZeroValue(n.defaultType)
@@ -1039,7 +1085,12 @@ func (n *callNode) writeDefaulter(varName string, index string, isVarPointer boo
 			args["defaultZero"] = defaultZero
 
 			sw.Do(fmt.Sprintf("if %s == $.defaultZero$ {\n", variablePlaceholder), args)
-			sw.Do(fmt.Sprintf("%s = $.defaultValue$", variablePlaceholder), args)
+
+			if len(n.defaultValue.InlineConstant) > 0 {
+				sw.Do(fmt.Sprintf("%s = $.defaultValue$", variablePlaceholder), args)
+			} else {
+				sw.Do(fmt.Sprintf("%s = $.varTopType|raw$($.defaultValue$)", variablePlaceholder), args)
+			}
 		}
 	} else {
 		sw.Do(fmt.Sprintf("if %s == nil {\n", variablePlaceholder), args)