cmd/viewer,types/views,various: avoid allocations in pointer field getters whenever possible

In this PR, we add a generic views.ValuePointer type that can be used as a view for pointers
to basic types and struct types that do not require deep cloning and do not have corresponding
view types. Its Get/GetOk methods return stack-allocated shallow copies of the underlying value.

We then update the cmd/viewer codegen to produce getters that return either concrete views
when available or ValuePointer views when not, for pointer fields in generated view types.
This allows us to avoid unnecessary allocations compared to returning pointers to newly
allocated shallow copies.

Updates #14570

Signed-off-by: Nick Khyl <nickk@tailscale.com>

cmd/viewer/viewer.go

@@ -79,13 +79,7 @@ func (v *{{.ViewName}}{{.TypeParamNames}}) UnmarshalJSON(b []byte) error {
 {{end}}
 {{define "makeViewField"}}func (v {{.ViewName}}{{.TypeParamNames}}) {{.FieldName}}() {{.FieldViewName}} { return {{.MakeViewFnName}}(&v.ж.{{.FieldName}}) }
 {{end}}
-{{define "valuePointerField"}}func (v {{.ViewName}}{{.TypeParamNames}}) {{.FieldName}}() {{.FieldType}} {
-	if v.ж.{{.FieldName}} == nil {
-		return nil
-	}
-	x := *v.ж.{{.FieldName}}
-	return &x
-}
+{{define "valuePointerField"}}func (v {{.ViewName}}{{.TypeParamNames}}) {{.FieldName}}() views.ValuePointer[{{.FieldType}}] { return views.ValuePointerOf(v.ж.{{.FieldName}}) }
 
 {{end}}
 {{define "mapField"}}
@@ -126,7 +120,7 @@ func requiresCloning(t types.Type) (shallow, deep bool, base types.Type) {
 	return p, p, t
 }
 
-func genView(buf *bytes.Buffer, it *codegen.ImportTracker, typ *types.Named, thisPkg *types.Package) {
+func genView(buf *bytes.Buffer, it *codegen.ImportTracker, typ *types.Named, _ *types.Package) {
 	t, ok := typ.Underlying().(*types.Struct)
 	if !ok || codegen.IsViewType(t) {
 		return
@@ -354,10 +348,32 @@ func genView(buf *bytes.Buffer, it *codegen.ImportTracker, typ *types.Named, thi
 				} else {
 					writeTemplate("unsupportedField")
 				}
-			} else {
-				args.FieldType = it.QualifiedName(ptr)
-				writeTemplate("valuePointerField")
+				continue
 			}
+
+			// If a view type is already defined for the base type, use it as the field's view type.
+			if viewType := viewTypeForValueType(base); viewType != nil {
+				args.FieldType = it.QualifiedName(base)
+				args.FieldViewName = it.QualifiedName(viewType)
+				writeTemplate("viewField")
+				continue
+			}
+
+			// Otherwise, if the unaliased base type is a named type whose view type will be generated by this viewer invocation,
+			// append the "View" suffix to the unaliased base type name and use it as the field's view type.
+			if base, ok := types.Unalias(base).(*types.Named); ok && slices.Contains(typeNames, it.QualifiedName(base)) {
+				baseTypeName := it.QualifiedName(base)
+				args.FieldType = baseTypeName
+				args.FieldViewName = appendNameSuffix(args.FieldType, "View")
+				writeTemplate("viewField")
+				continue
+			}
+
+			// Otherwise, if the base type does not require deep cloning, has no existing view type,
+			// and will not have a generated view type, use views.ValuePointer[T] as the field's view type.
+			// Its Get/GetOk methods return stack-allocated shallow copies of the field's value.
+			args.FieldType = it.QualifiedName(base)
+			writeTemplate("valuePointerField")
 			continue
 		case *types.Interface:
 			// If fieldType is an interface with a "View() {ViewType}" method, it can be used to clone the field.
@@ -405,6 +421,33 @@ func appendNameSuffix(name, suffix string) string {
 	return name + suffix
 }
 
+func typeNameOf(typ types.Type) (name *types.TypeName, ok bool) {
+	switch t := typ.(type) {
+	case *types.Alias:
+		return t.Obj(), true
+	case *types.Named:
+		return t.Obj(), true
+	default:
+		return nil, false
+	}
+}
+
+func lookupViewType(typ types.Type) types.Type {
+	for {
+		if typeName, ok := typeNameOf(typ); ok && typeName.Pkg() != nil {
+			if viewTypeObj := typeName.Pkg().Scope().Lookup(typeName.Name() + "View"); viewTypeObj != nil {
+				return viewTypeObj.Type()
+			}
+		}
+		switch alias := typ.(type) {
+		case *types.Alias:
+			typ = alias.Rhs()
+		default:
+			return nil
+		}
+	}
+}
+
 func viewTypeForValueType(typ types.Type) types.Type {
 	if ptr, ok := typ.(*types.Pointer); ok {
 		return viewTypeForValueType(ptr.Elem())
@@ -417,7 +460,12 @@ func viewTypeForValueType(typ types.Type) types.Type {
 	if !ok || sig.Results().Len() != 1 {
 		return nil
 	}
-	return sig.Results().At(0).Type()
+	viewType := sig.Results().At(0).Type()
+	// Check if the typ's package defines an alias for the view type, and use it if so.
+	if viewTypeAlias, ok := lookupViewType(typ).(*types.Alias); ok && types.AssignableTo(viewType, viewTypeAlias) {
+		viewType = viewTypeAlias
+	}
+	return viewType
 }
 
 func viewTypeForContainerType(typ types.Type) (*types.Named, *types.Func) {