Use value types to wrap only if a type has at least one method with a value-type receiver (#3)

Somewhere I got the brilliant idea that I could simplify my life by using value-type fields for all wrapped values.  Of course this didn't work- lots of stuff breaks if you clone it off (like database/sql.Rows).  So now I'm only using value types as the inner field if there's at least one method with a value-type receiver.  This should hopefully indicate that it is safe to clone a type off.  Having the code handle both pointer and value type inner fields was less complicated than expected, so cheers to me.

Co-authored-by: Stephen Baynham <[email protected]>

Author: CannibalVox

filegen/file.go

@@ -38,7 +38,11 @@ func NewFile(pkgName string, t *types.TypeInfo, db *types.TypeDB) *FileCreate {
 	//   inner [ElementType]
 	//	 errorTransformer ErrorTransformer
 	// }
-	innerField := jenutils.Type(jen.Id("Inner"), t.TypeId.Type)
+	innerType := t.TypeId.Type
+	if !t.RootType.HasDirectReceiver {
+		innerType = gotypes.NewPointer(innerType)
+	}
+	innerField := jenutils.Type(jen.Id("Inner"), innerType)
 	errTransformerField := jen.Id("ErrorTransformer").Qual("github.com/CannibalVox/errproxy", "ErrorTransformer")
 
 	fileCreate.jen.Type().Id(t.RootType.RootType.WrapperTypeName()).Struct(innerField, errTransformerField)
@@ -100,15 +104,15 @@ func (f *FileCreate) AppendType(t *types.TypeInfo) {
 
 	funcDeclaration.BlockFunc(func(g *jen.Group) {
 		// if inner == nil { return nil }
-		if t.TypeId.PointerDepth > 0 {
+		if t.TypeId.PointerDepth > 0 || t.TypeId.Mode == types.TypeInterface {
 			//If this is a pointer type, we'll need to dereference it soon so check if we can
 			g.If(jen.Id("inner").Op("==").Nil()).Block(jen.Return(jen.Nil()))
 			g.Line()
 		}
 
 		// If we're accepting a pointer, we need to dereference it before assigning the struct field
 		innerAssign := jen.Null()
-		if t.TypeId.PointerDepth > 0 {
+		if t.TypeId.PointerDepth > 0 && t.RootType.HasDirectReceiver {
 			innerAssign = jen.Op("*")
 		}
 
@@ -217,7 +221,7 @@ func (f *FileCreate) wrapMethod(t *types.TypeInfo, methodInfo *gotypes.Selection
 
 				var paramCodes *jen.Statement
 				doWrap, paramTypeInfo := f.requiresWrap(param.Type(), types.WrapStatusHard)
-				if doWrap && paramTypeInfo.TypeId.PointerDepth > 0 {
+				if doWrap && paramTypeInfo.TypeId.PointerDepth > 0 && paramTypeInfo.RootType.HasDirectReceiver {
 					paramCodes = g.Op("&").Id(paramVal).Dot("Inner")
 				} else if doWrap {
 					paramCodes = g.Id(paramVal).Dot("Inner")

types/info.go

@@ -93,6 +93,7 @@ type RootTypeInfo struct {
 	// The value is the type key for the owning type- this is necessary because
 	// we may assign a method to one type initially but allow another method to steal
 	// it later
+	HasDirectReceiver bool // If true, there is a method with a direct non-pointer receiver
 }
 
 func (r *RootTypeInfo) CanUseMethod(t gotypes.Type, method string) bool {

types/walker_walk.go

@@ -43,6 +43,11 @@ func (state *TypeWalker) walkSingleType(walkType *TypeInfo) {
 		return
 	}
 
+	// If this is a direct, non-pointered type (root type == type), then that will change how we render the wrapper
+	if walkType.TypeId.TypeKey == walkType.RootType.RootType.TypeKey {
+		walkType.RootType.HasDirectReceiver = true
+	}
+
 	// Loop through each method
 	for _, wrappedMethod := range walkType.MethodToWrap {
 		sig := wrappedMethod.Type().(*gotypes.Signature)