Implement type sharing support

Author: t0yv0

pkg/tfbridge/info.go

@@ -323,6 +323,11 @@ func BoolRef(b bool) *bool {
 	return &b
 }
 
+// String returns a reference to the string argument.
+func StringRef(s string) *string {
+	return &s
+}
+
 // StringValue gets a string value from a property map if present, else ""
 func StringValue(vars resource.PropertyMap, prop resource.PropertyKey) string {
 	val, ok := vars[prop]

pkg/tfbridge/info/info.go

@@ -441,9 +441,15 @@ type Schema struct {
 	// a name to override the default when targeting C#; "" uses the default.
 	CSharpName string
 
-	// a type to override the default; "" uses the default.
+	// An optional Pulumi type token to use for the Pulumi type projection of the current property. When unset, the
+	// default behavior is to generate fresh named Pulumi types as needed to represent the schema. To force the use
+	// of a known type and avoid generating unnecessary types, use both [Type] and [OmitType].
 	Type tokens.Type
 
+	// Used together with [Type] to omit generating any Pulumi types whatsoever for the current property, and
+	// instead use the object type identified by the token setup in [Type].
+	OmitType bool
+
 	// alternative types that can be used instead of the override.
 	AltTypes []tokens.Type
 
@@ -502,6 +508,12 @@ type Schema struct {
 
 	// whether or not to treat this property as secret
 	Secret *bool
+
+	// If specified, resets the type name prefix for any types that Pulumi needs to generate to represent the schema
+	// of the current property. Normally the names for helper object types are built from concatenating fragments
+	// representing the path to the type in the schema. The default strategy can lead to unacceptably long type
+	// names, reducing the SDK usability. Using TypePrefixOverride allows the maintainer to get shorter type names.
+	TypePrefixOverride *string
 }
 
 // Config represents a synthetic configuration variable that is Pulumi-only, and not passed to Terraform.

pkg/tfgen/generate.go

@@ -342,6 +342,8 @@ type propertyType struct {
 	nestedType tokens.Type
 	altTypes   []tokens.Type
 	asset      *tfbridge.AssetTranslation
+
+	typePrefixOverride *string
 }
 
 func (g *Generator) Sink() diag.Sink {
@@ -353,6 +355,9 @@ func (g *Generator) makePropertyType(typePath paths.TypePath,
 	entityDocs entityDocs) (*propertyType, error) {
 
 	t := &propertyType{}
+	if info != nil {
+		t.typePrefixOverride = info.TypePrefixOverride
+	}
 
 	var elemInfo *tfbridge.SchemaInfo
 	if info != nil {
@@ -456,10 +461,20 @@ func getDocsFromSchemaMap(key string, schemaMap shim.SchemaMap) string {
 func (g *Generator) makeObjectPropertyType(typePath paths.TypePath,
 	res shim.Resource, info *tfbridge.SchemaInfo,
 	out bool, entityDocs entityDocs) (*propertyType, error) {
+
+	// If the user supplied an explicit Type token override, omit generating types and short-circuit.
+	if info != nil && info.OmitType && info.Type != "" {
+		return &propertyType{typ: info.Type}, nil
+	}
+
 	t := &propertyType{
 		kind: kindObject,
 	}
 
+	if info != nil {
+		t.typePrefixOverride = info.TypePrefixOverride
+	}
+
 	if info != nil {
 		t.typ = info.Type
 		t.nestedType = info.NestedType
@@ -549,6 +564,14 @@ func (t *propertyType) equals(other *propertyType) bool {
 	if len(t.properties) != len(other.properties) {
 		return false
 	}
+	switch {
+	case t.typePrefixOverride != nil && other.typePrefixOverride == nil:
+		return false
+	case t.typePrefixOverride == nil && other.typePrefixOverride != nil:
+		return false
+	case t.typePrefixOverride != nil && other.typePrefixOverride != nil && *t.typePrefixOverride != *other.typePrefixOverride:
+		return false
+	}
 	for i, p := range t.properties {
 		o := other.properties[i]
 		if p.name != o.name {

pkg/tfgen/generate_schema.go

@@ -119,6 +119,10 @@ type declarer interface {
 func (nt *schemaNestedTypes) declareType(typePath paths.TypePath, declarer declarer, namePrefix, name string,
 	typ *propertyType, isInput bool) string {
 
+	if typ.typePrefixOverride != nil {
+		namePrefix = *typ.typePrefixOverride
+	}
+
 	// Generate a name for this nested type.
 	typeName := namePrefix + cases.Title(language.Und, cases.NoLower).String(name)
 

pkg/tfgen/generate_schema_test.go

@@ -19,6 +19,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"os"
+	"sort"
 	"testing"
 	"text/template"
 
@@ -33,9 +35,12 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	bridgetesting "github.com/pulumi/pulumi-terraform-bridge/v3/internal/testing"
 	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfbridge"
+	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfbridge/info"
 	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfgen/internal/testprovider"
+	sdkv2 "github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfshim/sdk-v2"
 	"github.com/pulumi/pulumi-terraform-bridge/v3/unstable/metadata"
 	"github.com/pulumi/pulumi-terraform-bridge/x/muxer"
 )
@@ -116,6 +121,159 @@ func TestCSharpMiniRandom(t *testing.T) {
 	bridgetesting.AssertEqualsJSONFile(t, "test_data/minirandom-schema-csharp.json", schema)
 }
 
+// Test the ability to force type sharing. Some of the upstream providers generate very large concrete schemata by in
+// Go, with TF not being materially affected. The example is inspired by QuickSight types in AWS. In Pulumi the default
+// projection is going to generate named types for every instance of the shared schema. This may lead to SDK bloat. Test
+// the ability of the provider author to curb the bloat and force an explit sharing.
+func TestTypeSharing(t *testing.T) {
+	tmpdir := t.TempDir()
+	barCharVisualSchema := func() *schema.Schema {
+		return &schema.Schema{
+			Type:     schema.TypeList,
+			Optional: true,
+			MinItems: 1,
+			MaxItems: 1,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"nest": {
+						Type:     schema.TypeList,
+						MaxItems: 1,
+						Optional: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"nested_prop": {
+									Type:     schema.TypeBool,
+									Optional: true,
+								},
+							},
+						},
+					},
+				},
+			},
+		}
+	}
+	visualsSchema := func() *schema.Schema {
+		return &schema.Schema{
+			Type:     schema.TypeList,
+			MinItems: 1,
+			MaxItems: 50,
+			Optional: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"bar_chart_visual": barCharVisualSchema(),
+					"box_plot_visual":  barCharVisualSchema(),
+				},
+			},
+		}
+	}
+	provider := info.Provider{
+		Name: "testprov",
+		P: sdkv2.NewProvider(&schema.Provider{
+			ResourcesMap: map[string]*schema.Resource{
+				"testprov_r1": {
+					Schema: map[string]*schema.Schema{
+						"sheets": {
+							Type:     schema.TypeList,
+							MinItems: 1,
+							MaxItems: 20,
+							Optional: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"visuals": visualsSchema(),
+								},
+							},
+						},
+					},
+				},
+				"testprov_r2": {
+					Schema: map[string]*schema.Schema{
+						"x": {
+							Type:     schema.TypeInt,
+							Optional: true,
+						},
+						"sheets": {
+							Type:     schema.TypeList,
+							MinItems: 1,
+							MaxItems: 20,
+							Optional: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"y": {
+										Type:     schema.TypeBool,
+										Optional: true,
+									},
+									"visuals": visualsSchema(),
+								},
+							},
+						},
+					},
+				},
+			},
+		}),
+		UpstreamRepoPath: tmpdir,
+		Resources: map[string]*info.Resource{
+			"testprov_r1": {
+				Tok: "testprov:index:R1",
+				Fields: map[string]*info.Schema{
+					"sheets": {
+						Elem: &info.Schema{
+							Fields: map[string]*info.Schema{
+								"visuals": {
+									Elem: &info.Schema{
+										TypePrefixOverride: tfbridge.StringRef(""),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			"testprov_r2": {
+				Tok: "testprov:index:R2",
+				Fields: map[string]*info.Schema{
+					"sheets": {
+						Elem: &info.Schema{
+							Fields: map[string]*info.Schema{
+								"visuals": {
+									Elem: &info.Schema{
+										Type:     "testprov:index/Visual:Visual",
+										OmitType: true,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	schema, err := GenerateSchema(provider, diag.DefaultSink(os.Stdout, os.Stdout, diag.FormatOptions{
+		Color: colors.Never,
+	}))
+	require.NoError(t, err)
+
+	keys := []string{}
+	for k := range schema.Types {
+		keys = append(keys, string(k))
+	}
+	sort.Strings(keys)
+
+	// Note that there is only one set of helper types, and they are not prefixed by any of the resource names.
+	autogold.Expect([]string{
+		"testprov:index/R1Sheet:R1Sheet", "testprov:index/R2Sheet:R2Sheet",
+		"testprov:index/Visual:Visual",
+		"testprov:index/VisualBarChartVisual:VisualBarChartVisual",
+		"testprov:index/VisualBarChartVisualNest:VisualBarChartVisualNest",
+		"testprov:index/VisualBoxPlotVisual:VisualBoxPlotVisual",
+		"testprov:index/VisualBoxPlotVisualNest:VisualBoxPlotVisualNest",
+	}).Equal(t, keys)
+
+	bytes, err := json.MarshalIndent(schema, "", "  ")
+	require.NoError(t, err)
+
+	autogold.ExpectFile(t, autogold.Raw(string(bytes)))
+}
+
 // TestPropertyDocumentationEdits tests that documentation edits are applied to
 // individual properties. This includes both the property description and
 // deprecation message. This tests the following workflow