PR comments

pkg/codegen/dotnet/gen.go

@@ -27,6 +27,7 @@ import (
 	"path"
 	"path/filepath"
 	"reflect"
+	"sort"
 	"strconv"
 	"strings"
 	"unicode"
@@ -1532,10 +1533,13 @@ func (mod *modContext) gen(fs fs) error {
 		mod.getImports(r, imports)
 
 		buffer := &bytes.Buffer{}
-		importStrings := pulumiImports
+		var additionalImports []string
 		for _, i := range imports {
-			importStrings = append(importStrings, i.SortedValues()...)
+			additionalImports = append(additionalImports, i.SortedValues()...)
 		}
+		sort.Strings(additionalImports)
+		importStrings := pulumiImports
+		importStrings = append(importStrings, additionalImports...)
 		mod.genHeader(buffer, importStrings)
 
 		if err := mod.genResource(buffer, r); err != nil {

pkg/codegen/go/gen.go

@@ -173,6 +173,11 @@ func (pkg *pkgContext) tokenToResource(tok string) string {
 		panic(fmt.Errorf("pkg.pkg is nil. token %s", tok))
 	}
 
+	// Is it a provider resource?
+	if components[0] == "pulumi" && components[1] == "providers" {
+		return fmt.Sprintf("%s.Provider", components[2])
+	}
+
 	mod, name := pkg.tokenToPackage(tok), components[2]
 
 	name = Title(name)
@@ -206,12 +211,28 @@ func (pkg *pkgContext) plainType(t schema.Type, optional bool) string {
 		return pkg.plainType(t.ElementType, optional)
 	case *schema.ArrayType:
 		return "[]" + pkg.plainType(t.ElementType, false)
+		//if schema.IsPrimitiveType(t.ElementType) {
+		//	return "[]" + pkg.plainType(t.ElementType, false)
+		//}
+		//elementType := pkg.plainType(t.ElementType, false)
+		//if strings.HasPrefix(elementType, "*") {
+		//	return "[]" + elementType
+		//}
+		//return "[]*" + elementType
 	case *schema.MapType:
 		return "map[string]" + pkg.plainType(t.ElementType, false)
+		//if schema.IsPrimitiveType(t.ElementType) {
+		//	return "map[string]" + pkg.plainType(t.ElementType, false)
+		//}
+		//elementType := pkg.plainType(t.ElementType, false)
+		//if strings.HasPrefix(elementType, "*") {
+		//	return "map[string]" + elementType
+		//}
+		//return "map[string]*" + elementType
 	case *schema.ObjectType:
-		typ = pkg.tokenToType(t.Token)
+		typ = pkg.resolveObjectType(t)
 	case *schema.ResourceType:
-		typ = pkg.tokenToResource(t.Token)
+		typ = pkg.resolveResourceType(t)
 	case *schema.TokenType:
 		// Use the underlying type for now.
 		if t.UnderlyingType != nil {
@@ -272,10 +293,9 @@ func (pkg *pkgContext) inputType(t schema.Type, optional bool) string {
 		en := pkg.inputType(t.ElementType, false)
 		return strings.TrimSuffix(en, "Input") + "MapInput"
 	case *schema.ObjectType:
-		typ = pkg.tokenToType(t.Token)
+		typ = pkg.resolveObjectType(t)
 	case *schema.ResourceType:
-		typ = pkg.tokenToResource(t.Token)
-		return typ + "Input"
+		return pkg.resolveResourceType(t) + "Input"
 	case *schema.TokenType:
 		// Use the underlying type for now.
 		if t.UnderlyingType != nil {
@@ -319,6 +339,58 @@ func (pkg *pkgContext) inputType(t schema.Type, optional bool) string {
 	return typ + "Input"
 }
 
+// resolveResourceType resolves resource references in properties while
+// taking into account potential external resources. Returned type is
+// always marked as required. Caller should check if the property is
+// optional and convert the type to a pointer if necessary.
+func (pkg *pkgContext) resolveResourceType(t *schema.ResourceType) string {
+	if t.Resource == nil || pkg.pkg == nil || t.Resource.Package == pkg.pkg {
+		return pkg.tokenToResource(t.Token)
+	}
+	extPkg := t.Resource.Package
+	var goInfo GoPackageInfo
+
+	contract.AssertNoError(extPkg.ImportLanguages(map[string]schema.Language{"go": Importer}))
+	if info, ok := extPkg.Language["go"].(GoPackageInfo); ok {
+		goInfo = info
+	}
+	extPkgCtx := &pkgContext{
+		pkg:              extPkg,
+		importBasePath:   goInfo.ImportBasePath,
+		pkgImportAliases: goInfo.PackageImportAliases,
+		modToPkg:         goInfo.ModuleToPackage,
+	}
+	resType := extPkgCtx.tokenToResource(t.Token)
+	if !strings.Contains(resType, ".") {
+		resType = fmt.Sprintf("%s.%s", extPkg.Name, resType)
+	}
+	return resType
+}
+
+// resolveObjectType resolves resource references in properties while
+// taking into account potential external resources. Returned type is
+// always marked as required. Caller should check if the property is
+// optional and convert the type to a pointer if necessary.
+func (pkg *pkgContext) resolveObjectType(t *schema.ObjectType) string {
+	if t.Package == nil || pkg.pkg == nil || t.Package == pkg.pkg {
+		return pkg.tokenToType(t.Token)
+	}
+	extPkg := t.Package
+	var goInfo GoPackageInfo
+
+	contract.AssertNoError(extPkg.ImportLanguages(map[string]schema.Language{"go": Importer}))
+	if info, ok := extPkg.Language["go"].(GoPackageInfo); ok {
+		goInfo = info
+	}
+	extPkgCtx := &pkgContext{
+		pkg:              extPkg,
+		importBasePath:   goInfo.ImportBasePath,
+		pkgImportAliases: goInfo.PackageImportAliases,
+		modToPkg:         goInfo.ModuleToPackage,
+	}
+	return extPkgCtx.plainType(t, false)
+}
+
 func (pkg *pkgContext) outputType(t schema.Type, optional bool) string {
 	var typ string
 	switch t := t.(type) {
@@ -337,10 +409,9 @@ func (pkg *pkgContext) outputType(t schema.Type, optional bool) string {
 		}
 		return en + "MapOutput"
 	case *schema.ObjectType:
-		typ = pkg.tokenToType(t.Token)
+		typ = pkg.resolveObjectType(t)
 	case *schema.ResourceType:
-		typ = pkg.tokenToResource(t.Token)
-		return typ + "Output"
+		return pkg.resolveResourceType(t) + "Output"
 	case *schema.TokenType:
 		// Use the underlying type for now.
 		if t.UnderlyingType != nil {
@@ -471,6 +542,27 @@ func getInputUsage(name string) string {
 	}, "\n")
 }
 
+// genResourceContainerInput handles generating container (slice/map) wrappers around
+// resources to facilitate external references.
+func genResourceContainerInput(w io.Writer, name, receiverType, elementType string) {
+	fmt.Fprintf(w, "func (%s) ElementType() reflect.Type {\n", receiverType)
+	fmt.Fprintf(w, "\treturn reflect.TypeOf((%s)(nil))\n", elementType)
+	fmt.Fprintf(w, "}\n\n")
+
+	fmt.Fprintf(w, "func (i %s) To%sOutput() %sOutput {\n", receiverType, Title(name), name)
+	fmt.Fprintf(w, "\treturn i.To%sOutputWithContext(context.Background())\n", Title(name))
+	fmt.Fprintf(w, "}\n\n")
+
+	fmt.Fprintf(w, "func (i %s) To%sOutputWithContext(ctx context.Context) %sOutput {\n", receiverType, Title(name), name)
+	if strings.HasSuffix(name, "Ptr") {
+		base := name[:len(name)-3]
+		fmt.Fprintf(w, "\treturn pulumi.ToOutputWithContext(ctx, i).(%sOutput).To%sOutput()\n", base, Title(name))
+	} else {
+		fmt.Fprintf(w, "\treturn pulumi.ToOutputWithContext(ctx, i).(%sOutput)\n", name)
+	}
+	fmt.Fprintf(w, "}\n\n")
+}
+
 func genInputMethods(w io.Writer, name, receiverType, elementType string, ptrMethods, resourceType bool) {
 	fmt.Fprintf(w, "func (%s) ElementType() reflect.Type {\n", receiverType)
 	if resourceType {
@@ -494,7 +586,11 @@ func genInputMethods(w io.Writer, name, receiverType, elementType string, ptrMet
 		fmt.Fprintf(w, "}\n\n")
 
 		fmt.Fprintf(w, "func (i %s) To%sPtrOutputWithContext(ctx context.Context) %sPtrOutput {\n", receiverType, Title(name), name)
-		fmt.Fprintf(w, "\treturn pulumi.ToOutputWithContext(ctx, i).(%[1]sOutput).To%[1]sPtrOutputWithContext(ctx)\n", name)
+		if strings.HasSuffix(receiverType, "Args") {
+			fmt.Fprintf(w, "\treturn pulumi.ToOutputWithContext(ctx, i).(%[1]sOutput).To%[1]sPtrOutputWithContext(ctx)\n", name)
+		} else {
+			fmt.Fprintf(w, "\treturn pulumi.ToOutputWithContext(ctx, i).(%sPtrOutput)\n", name)
+		}
 		fmt.Fprintf(w, "}\n\n")
 	}
 }
@@ -1031,7 +1127,29 @@ func (pkg *pkgContext) genResource(w io.Writer, r *schema.Resource) error {
 	fmt.Fprintf(w, "\tTo%[1]sOutput() %[1]sOutput\n", name)
 	fmt.Fprintf(w, "\tTo%[1]sOutputWithContext(ctx context.Context) %[1]sOutput\n", name)
 	fmt.Fprintf(w, "}\n\n")
-	genInputMethods(w, name, "*"+name, name, false, true)
+	genInputMethods(w, name, "*"+name, name, true, true)
+
+	// Emit the resource pointer input type.
+	fmt.Fprintf(w, "type %sPtrInput interface {\n", name)
+	fmt.Fprintf(w, "\tpulumi.Input\n\n")
+	fmt.Fprintf(w, "\tTo%[1]sPtrOutput() %[1]sPtrOutput\n", name)
+	fmt.Fprintf(w, "\tTo%[1]sPtrOutputWithContext(ctx context.Context) %[1]sPtrOutput\n", name)
+	fmt.Fprintf(w, "}\n\n")
+	ptrTypeName := camel(name) + "PtrType"
+	fmt.Fprintf(w, "type %s %sArgs\n\n", ptrTypeName, name)
+	genInputMethods(w, name+"Ptr", "*"+ptrTypeName, "*"+name, false, true)
+
+	if !r.IsProvider {
+		// Generate the resource array input.
+		genInputInterface(w, name+"Array")
+		fmt.Fprintf(w, "type %[1]sArray []%[1]sInput\n\n", name)
+		genResourceContainerInput(w, name+"Array", name+"Array", "[]*"+name)
+
+		// Generate the resource map input.
+		genInputInterface(w, name+"Map")
+		fmt.Fprintf(w, "type %[1]sMap map[string]%[1]sInput\n\n", name)
+		genResourceContainerInput(w, name+"Map", name+"Map", "map[string]*"+name)
+	}
 
 	// Emit the resource output type.
 	fmt.Fprintf(w, "type %sOutput struct {\n", name)
@@ -1039,8 +1157,50 @@ func (pkg *pkgContext) genResource(w io.Writer, r *schema.Resource) error {
 	fmt.Fprintf(w, "}\n\n")
 	genOutputMethods(w, name, name, true)
 	fmt.Fprintf(w, "\n")
+	fmt.Fprintf(w, "func (o %[1]sOutput) To%[2]sPtrOutput() %[1]sPtrOutput {\n", name, Title(name))
+	fmt.Fprintf(w, "\treturn o.To%sPtrOutputWithContext(context.Background())\n", Title(name))
+	fmt.Fprintf(w, "}\n\n")
+
+	fmt.Fprintf(w, "func (o %[1]sOutput) To%[2]sPtrOutputWithContext(ctx context.Context) %[1]sPtrOutput {\n", name, Title(name))
+	fmt.Fprintf(w, "\treturn o.ApplyT(func(v %[1]s) *%[1]s {\n", name)
+	fmt.Fprintf(w, "\t\treturn &v\n")
+	fmt.Fprintf(w, "\t}).(%sPtrOutput)\n", name)
+	fmt.Fprintf(w, "}\n")
+	fmt.Fprintf(w, "\n")
+
+	// Emit the resource pointer output type.
+	fmt.Fprintf(w, "type %sOutput struct {\n", name+"Ptr")
+	fmt.Fprintf(w, "\t*pulumi.OutputState\n")
+	fmt.Fprintf(w, "}\n\n")
+	genOutputMethods(w, name+"Ptr", "*"+name, true)
+
+	if !r.IsProvider {
+		// Emit the array output type
+		fmt.Fprintf(w, "type %sArrayOutput struct { *pulumi.OutputState }\n\n", name)
+		genOutputMethods(w, name+"Array", "[]"+name, true)
+		fmt.Fprintf(w, "func (o %[1]sArrayOutput) Index(i pulumi.IntInput) %[1]sOutput {\n", name)
+		fmt.Fprintf(w, "\treturn pulumi.All(o, i).ApplyT(func (vs []interface{}) %s {\n", name)
+		fmt.Fprintf(w, "\t\treturn vs[0].([]%s)[vs[1].(int)]\n", name)
+		fmt.Fprintf(w, "\t}).(%sOutput)\n", name)
+		fmt.Fprintf(w, "}\n\n")
+		// Emit the map output type
+		fmt.Fprintf(w, "type %sMapOutput struct { *pulumi.OutputState }\n\n", name)
+		genOutputMethods(w, name+"Map", "map[string]"+name, true)
+		fmt.Fprintf(w, "func (o %[1]sMapOutput) MapIndex(k pulumi.StringInput) %[1]sOutput {\n", name)
+		fmt.Fprintf(w, "\treturn pulumi.All(o, k).ApplyT(func (vs []interface{}) %s {\n", name)
+		fmt.Fprintf(w, "\t\treturn vs[0].(map[string]%s)[vs[1].(string)]\n", name)
+		fmt.Fprintf(w, "\t}).(%sOutput)\n", name)
+		fmt.Fprintf(w, "}\n\n")
+	}
+
+	// Register all output types
 	fmt.Fprintf(w, "func init() {\n")
 	fmt.Fprintf(w, "\tpulumi.RegisterOutputType(%sOutput{})\n", name)
+	fmt.Fprintf(w, "\tpulumi.RegisterOutputType(%sPtrOutput{})\n", name)
+	if !r.IsProvider {
+		fmt.Fprintf(w, "\tpulumi.RegisterOutputType(%sArrayOutput{})\n", name)
+		fmt.Fprintf(w, "\tpulumi.RegisterOutputType(%sMapOutput{})\n", name)
+	}
 	fmt.Fprintf(w, "}\n\n")
 
 	return nil
@@ -1157,77 +1317,132 @@ func (pkg *pkgContext) genTypeRegistrations(w io.Writer, types []*schema.ObjectT
 	fmt.Fprintf(w, "}\n")
 }
 
-func (pkg *pkgContext) getTypeImports(t schema.Type, recurse bool, imports codegen.StringSet, seen map[schema.Type]struct{}) {
+func (pkg *pkgContext) getTypeImports(t schema.Type, recurse bool, importsAndAliases map[string]string, seen map[schema.Type]struct{}) {
 	if _, ok := seen[t]; ok {
 		return
 	}
 	seen[t] = struct{}{}
 	switch t := t.(type) {
 	case *schema.ArrayType:
-		pkg.getTypeImports(t.ElementType, recurse, imports, seen)
+		pkg.getTypeImports(t.ElementType, recurse, importsAndAliases, seen)
 	case *schema.MapType:
-		pkg.getTypeImports(t.ElementType, recurse, imports, seen)
+		pkg.getTypeImports(t.ElementType, recurse, importsAndAliases, seen)
 	case *schema.ObjectType:
+		if t.Package != nil && pkg.pkg != nil && t.Package != pkg.pkg {
+			extPkg := t.Package
+			var goInfo GoPackageInfo
+
+			contract.AssertNoError(extPkg.ImportLanguages(map[string]schema.Language{"go": Importer}))
+			if info, ok := extPkg.Language["go"].(GoPackageInfo); ok {
+				goInfo = info
+			} else {
+				// tests don't include ImportBasePath
+				goInfo.ImportBasePath = extractImportBasePath(extPkg)
+			}
+			extPkgCtx := &pkgContext{
+				pkg:              extPkg,
+				importBasePath:   goInfo.ImportBasePath,
+				pkgImportAliases: goInfo.PackageImportAliases,
+				modToPkg:         goInfo.ModuleToPackage,
+			}
+			mod := extPkgCtx.tokenToPackage(t.Token)
+			imp := path.Join(goInfo.ImportBasePath, mod)
+			importsAndAliases[imp] = goInfo.PackageImportAliases[imp]
+			break
+		}
 		mod := pkg.tokenToPackage(t.Token)
 		if mod != pkg.mod {
-			imports.Add(path.Join(pkg.importBasePath, mod))
+			p := path.Join(pkg.importBasePath, mod)
+			importsAndAliases[path.Join(pkg.importBasePath, mod)] = pkg.pkgImportAliases[p]
 		}
 
-		for _, p := range t.Properties {
-			if recurse {
-				pkg.getTypeImports(p.Type, recurse, imports, seen)
+		if recurse {
+			for _, p := range t.Properties {
+				pkg.getTypeImports(p.Type, recurse, importsAndAliases, seen)
 			}
 		}
 	case *schema.ResourceType:
+		if t.Resource != nil && pkg.pkg != nil && t.Resource.Package != pkg.pkg {
+			extPkg := t.Resource.Package
+			var goInfo GoPackageInfo
+
+			contract.AssertNoError(extPkg.ImportLanguages(map[string]schema.Language{"go": Importer}))
+			if info, ok := extPkg.Language["go"].(GoPackageInfo); ok {
+				goInfo = info
+			} else {
+				// tests don't include ImportBasePath
+				goInfo.ImportBasePath = extractImportBasePath(extPkg)
+			}
+			extPkgCtx := &pkgContext{
+				pkg:              extPkg,
+				importBasePath:   goInfo.ImportBasePath,
+				pkgImportAliases: goInfo.PackageImportAliases,
+				modToPkg:         goInfo.ModuleToPackage,
+			}
+			mod := extPkgCtx.tokenToPackage(t.Token)
+			imp := path.Join(goInfo.ImportBasePath, mod)
+			importsAndAliases[imp] = goInfo.PackageImportAliases[imp]
+			break
+		}
 		mod := pkg.tokenToPackage(t.Token)
 		if mod != pkg.mod {
-			imports.Add(path.Join(pkg.importBasePath, mod))
+			p := path.Join(pkg.importBasePath, mod)
+			importsAndAliases[path.Join(pkg.importBasePath, mod)] = pkg.pkgImportAliases[p]
 		}
 	case *schema.UnionType:
 		for _, e := range t.ElementTypes {
-			pkg.getTypeImports(e, recurse, imports, seen)
+			pkg.getTypeImports(e, recurse, importsAndAliases, seen)
 		}
 	}
 }
 
-func (pkg *pkgContext) getImports(member interface{}, imports codegen.StringSet) {
+func extractImportBasePath(extPkg *schema.Package) string {
+	version := extPkg.Version.Major
+	var vPath string
+	if version > 1 {
+		vPath = fmt.Sprintf("/v%d", version)
+	}
+	return fmt.Sprintf("github.com/pulumi/pulumi-%s/sdk%s/go/%s", extPkg.Name, vPath, extPkg.Name)
+}
+
+func (pkg *pkgContext) getImports(member interface{}, importsAndAliases map[string]string) {
 	seen := map[schema.Type]struct{}{}
 	switch member := member.(type) {
 	case *schema.ObjectType:
-		pkg.getTypeImports(member, true, imports, seen)
+		pkg.getTypeImports(member, true, importsAndAliases, seen)
 	case *schema.ResourceType:
-		pkg.getTypeImports(member, true, imports, seen)
+		pkg.getTypeImports(member, true, importsAndAliases, seen)
 	case *schema.Resource:
 		for _, p := range member.Properties {
-			pkg.getTypeImports(p.Type, false, imports, seen)
+			pkg.getTypeImports(p.Type, false, importsAndAliases, seen)
 		}
 		for _, p := range member.InputProperties {
-			pkg.getTypeImports(p.Type, false, imports, seen)
+			pkg.getTypeImports(p.Type, false, importsAndAliases, seen)
 
 			if p.IsRequired {
-				imports.Add("github.com/pkg/errors")
+				importsAndAliases["github.com/pkg/errors"] = ""
 			}
 		}
 	case *schema.Function:
 		if member.Inputs != nil {
-			pkg.getTypeImports(member.Inputs, false, imports, seen)
+			pkg.getTypeImports(member.Inputs, true, importsAndAliases, seen)
 		}
 		if member.Outputs != nil {
-			pkg.getTypeImports(member.Outputs, false, imports, seen)
+			pkg.getTypeImports(member.Outputs, true, importsAndAliases, seen)
 		}
 	case []*schema.Property:
 		for _, p := range member {
-			pkg.getTypeImports(p.Type, false, imports, seen)
+			pkg.getTypeImports(p.Type, false, importsAndAliases, seen)
 		}
 	case *schema.EnumType: // Just need pulumi sdk, see below
 	default:
 		return
 	}
 
-	imports.Add("github.com/pulumi/pulumi/sdk/v2/go/pulumi")
+	importsAndAliases["github.com/pulumi/pulumi/sdk/v2/go/pulumi"] = ""
 }
 
-func (pkg *pkgContext) genHeader(w io.Writer, goImports []string, importedPackages codegen.StringSet) {
+func (pkg *pkgContext) genHeader(w io.Writer, goImports []string, importsAndAliases map[string]string) {
 	fmt.Fprintf(w, "// *** WARNING: this file was generated by %v. ***\n", pkg.tool)
 	fmt.Fprintf(w, "// *** Do not edit by hand unless you're certain you know what you are doing! ***\n\n")
 
@@ -1241,14 +1456,14 @@ func (pkg *pkgContext) genHeader(w io.Writer, goImports []string, importedPackag
 	fmt.Fprintf(w, "package %s\n\n", pkgName)
 
 	var imports []string
-	if len(importedPackages) > 0 {
-		for k := range importedPackages {
+	if len(importsAndAliases) > 0 {
+		for k := range importsAndAliases {
 			imports = append(imports, k)
 		}
 		sort.Strings(imports)
 
 		for i, k := range imports {
-			if alias, ok := pkg.pkgImportAliases[k]; ok {
+			if alias := importsAndAliases[k]; alias != "" {
 				imports[i] = fmt.Sprintf(`%s "%s"`, alias, k)
 			}
 		}
@@ -1278,10 +1493,10 @@ func (pkg *pkgContext) genHeader(w io.Writer, goImports []string, importedPackag
 }
 
 func (pkg *pkgContext) genConfig(w io.Writer, variables []*schema.Property) error {
-	imports := codegen.NewStringSet("github.com/pulumi/pulumi/sdk/v2/go/pulumi/config")
-	pkg.getImports(variables, imports)
+	importsAndAliases := map[string]string{"github.com/pulumi/pulumi/sdk/v2/go/pulumi/config": ""}
+	pkg.getImports(variables, importsAndAliases)
 
-	pkg.genHeader(w, nil, imports)
+	pkg.genHeader(w, nil, importsAndAliases)
 
 	for _, p := range variables {
 		getfunc := "Get"
@@ -1573,11 +1788,11 @@ func GeneratePackage(tool string, pkg *schema.Package) (map[string][]byte, error
 
 		// Resources
 		for _, r := range pkg.resources {
-			imports := codegen.NewStringSet()
-			pkg.getImports(r, imports)
+			importsAndAliases := map[string]string{}
+			pkg.getImports(r, importsAndAliases)
 
 			buffer := &bytes.Buffer{}
-			pkg.genHeader(buffer, []string{"context", "reflect"}, imports)
+			pkg.genHeader(buffer, []string{"context", "reflect"}, importsAndAliases)
 
 			if err := pkg.genResource(buffer, r); err != nil {
 				return nil, err
@@ -1588,11 +1803,11 @@ func GeneratePackage(tool string, pkg *schema.Package) (map[string][]byte, error
 
 		// Functions
 		for _, f := range pkg.functions {
-			imports := codegen.NewStringSet()
-			pkg.getImports(f, imports)
+			importsAndAliases := map[string]string{}
+			pkg.getImports(f, importsAndAliases)
 
 			buffer := &bytes.Buffer{}
-			pkg.genHeader(buffer, nil, imports)
+			pkg.genHeader(buffer, nil, importsAndAliases)
 
 			pkg.genFunction(buffer, f)
 
@@ -1601,13 +1816,13 @@ func GeneratePackage(tool string, pkg *schema.Package) (map[string][]byte, error
 
 		// Types
 		if len(pkg.types) > 0 {
-			imports := codegen.NewStringSet()
+			importsAndAliases := map[string]string{}
 			for _, t := range pkg.types {
-				pkg.getImports(t, imports)
+				pkg.getImports(t, importsAndAliases)
 			}
 
 			buffer := &bytes.Buffer{}
-			pkg.genHeader(buffer, []string{"context", "reflect"}, imports)
+			pkg.genHeader(buffer, []string{"context", "reflect"}, importsAndAliases)
 
 			for _, t := range pkg.types {
 				pkg.genType(buffer, t)
@@ -1620,7 +1835,7 @@ func GeneratePackage(tool string, pkg *schema.Package) (map[string][]byte, error
 
 		// Enums
 		if len(pkg.enums) > 0 {
-			imports := codegen.NewStringSet()
+			imports := map[string]string{}
 			for _, e := range pkg.enums {
 				pkg.getImports(e, imports)
 			}
@@ -1639,13 +1854,16 @@ func GeneratePackage(tool string, pkg *schema.Package) (map[string][]byte, error
 		// Utilities
 		if pkg.needsUtils || len(mod) == 0 {
 			buffer := &bytes.Buffer{}
-			imports := codegen.NewStringSet(
-				"github.com/blang/semver",
-				"github.com/pulumi/pulumi/sdk/v2/go/pulumi",
-			)
-			pkg.genHeader(buffer, []string{"os", "reflect", "strconv", "strings"}, imports)
+			importsAndAliases := map[string]string{
+				"github.com/blang/semver":                   "",
+				"github.com/pulumi/pulumi/sdk/v2/go/pulumi": "",
+			}
+			pkg.genHeader(buffer, []string{"fmt", "os", "reflect", "regexp", "strconv", "strings"}, importsAndAliases)
 
-			fmt.Fprintf(buffer, utilitiesFile, pkg.pkg.Name)
+			_, err := fmt.Fprintf(buffer, utilitiesFile, pkg.pkg.Name)
+			if err != nil {
+				return nil, err
+			}
 
 			setFile(path.Join(mod, "pulumiUtilities.go"), buffer.String())
 		}

pkg/codegen/go/gen_crd2pulumi.go

@@ -2,7 +2,6 @@ package gen
 
 import (
 	"bytes"
-	"github.com/pulumi/pulumi/pkg/v2/codegen"
 
 	"github.com/pkg/errors"
 	"github.com/pulumi/pulumi/pkg/v2/codegen/schema"
@@ -33,9 +32,9 @@ func CRDTypes(tool string, pkg *schema.Package) (map[string]*bytes.Buffer, error
 		buffer := &bytes.Buffer{}
 
 		for _, r := range pkg.resources {
-			imports := codegen.NewStringSet()
-			pkg.getImports(r, imports)
-			pkg.genHeader(buffer, []string{"context", "reflect"}, imports)
+			importsAndAliases := map[string]string{}
+			pkg.getImports(r, importsAndAliases)
+			pkg.genHeader(buffer, []string{"context", "reflect"}, importsAndAliases)
 
 			if err := pkg.genResource(buffer, r); err != nil {
 				return nil, errors.Wrapf(err, "generating resource %s", mod)

pkg/codegen/go/gen_test.go

@@ -62,23 +62,43 @@ func TestGeneratePackage(t *testing.T) {
 			"Simple schema with local resource properties",
 			"simple-resource-schema",
 			[]string{
-				"example/argFunction.go",
-				"example/otherResource.go",
-				"example/provider.go",
-				"example/resource.go",
+				filepath.Join("example", "resource.go"),
+				filepath.Join("example", "otherResource.go"),
+				filepath.Join("example", "argFunction.go"),
+				filepath.Join("example", "pulumiTypes.go"),
+				filepath.Join("example", "pulumiUtilities.go"),
+				filepath.Join("example", "doc.go"),
+				filepath.Join("example", "provider.go"),
 			},
 		},
 		{
 			"Simple schema with enum types",
 			"simple-enum-schema",
 			[]string{
+				filepath.Join("plant", "doc.go"),
 				filepath.Join("plant", "provider.go"),
 				filepath.Join("plant", "pulumiTypes.go"),
+				filepath.Join("plant", "pulumiUtilities.go"),
 				filepath.Join("plant", "pulumiEnums.go"),
+				filepath.Join("plant", "provider.go"),
 				filepath.Join("plant", "tree", "v1", "rubberTree.go"),
 				filepath.Join("plant", "tree", "v1", "pulumiEnums.go"),
 			},
 		},
+		{
+			"External resource schema",
+			"external-resource-schema",
+			[]string{
+				filepath.Join("example", "component.go"),
+				filepath.Join("example", "pulumiTypes.go"),
+				filepath.Join("example", "pulumiUtilities.go"),
+				filepath.Join("example", "argFunction.go"),
+				filepath.Join("example", "cat.go"),
+				filepath.Join("example", "doc.go"),
+				filepath.Join("example", "provider.go"),
+				filepath.Join("example", "workload.go"),
+			},
+		},
 	}
 	testDir := filepath.Join("..", "internal", "test", "testdata")
 	for _, tt := range tests {
@@ -93,6 +113,7 @@ func TestGeneratePackage(t *testing.T) {
 			expectedFiles, err := test.LoadFiles(filepath.Join(testDir, tt.schemaDir), "go", tt.expectedFiles)
 			assert.NoError(t, err)
 			test.ValidateFileEquality(t, files, expectedFiles)
+			test.CheckAllFilesGenerated(t, files, expectedFiles)
 		})
 	}
 }
@@ -117,7 +138,7 @@ func TestEnumUsage(t *testing.T) {
 	t.Run("Success", func(t *testing.T) {
 		require.NoError(t, pulumi.RunErr(func(ctx *pulumi.Context) error {
 			tree, err := tree.NewRubberTree(ctx, "blah", &tree.RubberTreeArgs{
-				Container: plant.ContainerArgs{
+				Container: &plant.ContainerArgs{
 					Color:    plant.ContainerColorRed,
 					Material: pulumi.String("ceramic"),
 					Size:     plant.ContainerSizeFourInch,

pkg/codegen/internal/test/helpers.go

@@ -71,3 +71,22 @@ func ValidateFileEquality(t *testing.T, actual, expected map[string][]byte) {
 		assert.Equal(t, string(file), string(actual[name]), name)
 	}
 }
+
+// CheckAllFilesGenerated ensures that the set of expected and actual files generated
+// are exactly equivalent.
+func CheckAllFilesGenerated(t *testing.T, actual, expected map[string][]byte) {
+	seen := map[string]bool{}
+	for x := range expected {
+		seen[x] = true
+	}
+	for a := range actual {
+		assert.Contains(t, seen, a, "Unexpected file generated: %s", a)
+		if seen[a] {
+			delete(seen, a)
+		}
+	}
+
+	for s := range seen {
+		assert.Fail(t, "No content generated for expected file %s", s)
+	}
+}

pkg/codegen/internal/test/testdata/external-resource-schema/dotnet/Component.cs

@@ -6,6 +6,8 @@ using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading.Tasks;
 using Pulumi.Serialization;
+using SecurityGroup;
+using StorageClass;
 
 namespace Pulumi.Example
 {
@@ -15,6 +17,12 @@ namespace Pulumi.Example
         [Output("provider")]
         public Output<Pulumi.Kubernetes.Provider?> Provider { get; private set; } = null!;
 
+        [Output("securityGroup")]
+        public Output<Pulumi.Aws.Ec2/securityGroup.SecurityGroup?> SecurityGroup { get; private set; } = null!;
+
+        [Output("storageClasses")]
+        public Output<ImmutableDictionary<string, Pulumi.Kubernetes.Storage.k8s.io/v1.StorageClass>?> StorageClasses { get; private set; } = null!;
+
 
         /// <summary>
         /// Create a Component resource with the given unique name, arguments, and options.
@@ -60,6 +68,9 @@ namespace Pulumi.Example
 
     public sealed class ComponentArgs : Pulumi.ResourceArgs
     {
+        [Input("metadata")]
+        public Input<Pulumi.Kubernetes.Types.Inputs.Meta.V1.ObjectMetaArgs>? Metadata { get; set; }
+
         public ComponentArgs()
         {
         }

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/argFunction.go

@@ -0,0 +1,26 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"github.com/pulumi/pulumi-random/sdk/v2/go/random"
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+func ArgFunction(ctx *pulumi.Context, args *ArgFunctionArgs, opts ...pulumi.InvokeOption) (*ArgFunctionResult, error) {
+	var rv ArgFunctionResult
+	err := ctx.Invoke("example::argFunction", args, &rv, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &rv, nil
+}
+
+type ArgFunctionArgs struct {
+	Name *random.RandomPet `pulumi:"name"`
+}
+
+type ArgFunctionResult struct {
+	Age *int `pulumi:"age"`
+}

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/cat.go

@@ -0,0 +1,259 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type Cat struct {
+	pulumi.CustomResourceState
+
+	Name pulumi.StringPtrOutput `pulumi:"name"`
+}
+
+// NewCat registers a new resource with the given unique name, arguments, and options.
+func NewCat(ctx *pulumi.Context,
+	name string, args *CatArgs, opts ...pulumi.ResourceOption) (*Cat, error) {
+	if args == nil {
+		args = &CatArgs{}
+	}
+
+	var resource Cat
+	err := ctx.RegisterResource("example::Cat", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetCat gets an existing Cat resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetCat(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *CatState, opts ...pulumi.ResourceOption) (*Cat, error) {
+	var resource Cat
+	err := ctx.ReadResource("example::Cat", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering Cat resources.
+type catState struct {
+	Name *string `pulumi:"name"`
+}
+
+type CatState struct {
+	Name pulumi.StringPtrInput
+}
+
+func (CatState) ElementType() reflect.Type {
+	return reflect.TypeOf((*catState)(nil)).Elem()
+}
+
+type catArgs struct {
+	Age *int `pulumi:"age"`
+	Pet *Pet `pulumi:"pet"`
+}
+
+// The set of arguments for constructing a Cat resource.
+type CatArgs struct {
+	Age pulumi.IntPtrInput
+	Pet PetPtrInput
+}
+
+func (CatArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*catArgs)(nil)).Elem()
+}
+
+type CatInput interface {
+	pulumi.Input
+
+	ToCatOutput() CatOutput
+	ToCatOutputWithContext(ctx context.Context) CatOutput
+}
+
+func (*Cat) ElementType() reflect.Type {
+	return reflect.TypeOf((*Cat)(nil))
+}
+
+func (i *Cat) ToCatOutput() CatOutput {
+	return i.ToCatOutputWithContext(context.Background())
+}
+
+func (i *Cat) ToCatOutputWithContext(ctx context.Context) CatOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(CatOutput)
+}
+
+func (i *Cat) ToCatPtrOutput() CatPtrOutput {
+	return i.ToCatPtrOutputWithContext(context.Background())
+}
+
+func (i *Cat) ToCatPtrOutputWithContext(ctx context.Context) CatPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(CatPtrOutput)
+}
+
+type CatPtrInput interface {
+	pulumi.Input
+
+	ToCatPtrOutput() CatPtrOutput
+	ToCatPtrOutputWithContext(ctx context.Context) CatPtrOutput
+}
+
+type catPtrType CatArgs
+
+func (*catPtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**Cat)(nil))
+}
+
+func (i *catPtrType) ToCatPtrOutput() CatPtrOutput {
+	return i.ToCatPtrOutputWithContext(context.Background())
+}
+
+func (i *catPtrType) ToCatPtrOutputWithContext(ctx context.Context) CatPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(CatPtrOutput)
+}
+
+// CatArrayInput is an input type that accepts CatArray and CatArrayOutput values.
+// You can construct a concrete instance of `CatArrayInput` via:
+//
+//          CatArray{ CatArgs{...} }
+type CatArrayInput interface {
+	pulumi.Input
+
+	ToCatArrayOutput() CatArrayOutput
+	ToCatArrayOutputWithContext(context.Context) CatArrayOutput
+}
+
+type CatArray []CatInput
+
+func (CatArray) ElementType() reflect.Type {
+	return reflect.TypeOf(([]*Cat)(nil))
+}
+
+func (i CatArray) ToCatArrayOutput() CatArrayOutput {
+	return i.ToCatArrayOutputWithContext(context.Background())
+}
+
+func (i CatArray) ToCatArrayOutputWithContext(ctx context.Context) CatArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(CatArrayOutput)
+}
+
+// CatMapInput is an input type that accepts CatMap and CatMapOutput values.
+// You can construct a concrete instance of `CatMapInput` via:
+//
+//          CatMap{ "key": CatArgs{...} }
+type CatMapInput interface {
+	pulumi.Input
+
+	ToCatMapOutput() CatMapOutput
+	ToCatMapOutputWithContext(context.Context) CatMapOutput
+}
+
+type CatMap map[string]CatInput
+
+func (CatMap) ElementType() reflect.Type {
+	return reflect.TypeOf((map[string]*Cat)(nil))
+}
+
+func (i CatMap) ToCatMapOutput() CatMapOutput {
+	return i.ToCatMapOutputWithContext(context.Background())
+}
+
+func (i CatMap) ToCatMapOutputWithContext(ctx context.Context) CatMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(CatMapOutput)
+}
+
+type CatOutput struct {
+	*pulumi.OutputState
+}
+
+func (CatOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*Cat)(nil))
+}
+
+func (o CatOutput) ToCatOutput() CatOutput {
+	return o
+}
+
+func (o CatOutput) ToCatOutputWithContext(ctx context.Context) CatOutput {
+	return o
+}
+
+func (o CatOutput) ToCatPtrOutput() CatPtrOutput {
+	return o.ToCatPtrOutputWithContext(context.Background())
+}
+
+func (o CatOutput) ToCatPtrOutputWithContext(ctx context.Context) CatPtrOutput {
+	return o.ApplyT(func(v Cat) *Cat {
+		return &v
+	}).(CatPtrOutput)
+}
+
+type CatPtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (CatPtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Cat)(nil))
+}
+
+func (o CatPtrOutput) ToCatPtrOutput() CatPtrOutput {
+	return o
+}
+
+func (o CatPtrOutput) ToCatPtrOutputWithContext(ctx context.Context) CatPtrOutput {
+	return o
+}
+
+type CatArrayOutput struct{ *pulumi.OutputState }
+
+func (CatArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]Cat)(nil))
+}
+
+func (o CatArrayOutput) ToCatArrayOutput() CatArrayOutput {
+	return o
+}
+
+func (o CatArrayOutput) ToCatArrayOutputWithContext(ctx context.Context) CatArrayOutput {
+	return o
+}
+
+func (o CatArrayOutput) Index(i pulumi.IntInput) CatOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Cat {
+		return vs[0].([]Cat)[vs[1].(int)]
+	}).(CatOutput)
+}
+
+type CatMapOutput struct{ *pulumi.OutputState }
+
+func (CatMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]Cat)(nil))
+}
+
+func (o CatMapOutput) ToCatMapOutput() CatMapOutput {
+	return o
+}
+
+func (o CatMapOutput) ToCatMapOutputWithContext(ctx context.Context) CatMapOutput {
+	return o
+}
+
+func (o CatMapOutput) MapIndex(k pulumi.StringInput) CatOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) Cat {
+		return vs[0].(map[string]Cat)[vs[1].(string)]
+	}).(CatOutput)
+}
+
+func init() {
+	pulumi.RegisterOutputType(CatOutput{})
+	pulumi.RegisterOutputType(CatPtrOutput{})
+	pulumi.RegisterOutputType(CatArrayOutput{})
+	pulumi.RegisterOutputType(CatMapOutput{})
+}

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/component.go

@@ -0,0 +1,267 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/ec2"
+	"github.com/pulumi/pulumi-kubernetes/sdk/v2/go/kubernetes"
+	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v2/go/kubernetes/meta/v1"
+	storagev1 "github.com/pulumi/pulumi-kubernetes/sdk/v2/go/kubernetes/storage/v1"
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type Component struct {
+	pulumi.CustomResourceState
+
+	Provider       kubernetes.ProviderOutput       `pulumi:"provider"`
+	SecurityGroup  ec2.SecurityGroupOutput         `pulumi:"securityGroup"`
+	StorageClasses storagev1.StorageClassMapOutput `pulumi:"storageClasses"`
+}
+
+// NewComponent registers a new resource with the given unique name, arguments, and options.
+func NewComponent(ctx *pulumi.Context,
+	name string, args *ComponentArgs, opts ...pulumi.ResourceOption) (*Component, error) {
+	if args == nil {
+		args = &ComponentArgs{}
+	}
+
+	var resource Component
+	err := ctx.RegisterResource("example::Component", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetComponent gets an existing Component resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetComponent(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *ComponentState, opts ...pulumi.ResourceOption) (*Component, error) {
+	var resource Component
+	err := ctx.ReadResource("example::Component", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering Component resources.
+type componentState struct {
+	Provider       *kubernetes.Provider              `pulumi:"provider"`
+	SecurityGroup  *ec2.SecurityGroup                `pulumi:"securityGroup"`
+	StorageClasses map[string]storagev1.StorageClass `pulumi:"storageClasses"`
+}
+
+type ComponentState struct {
+	Provider       kubernetes.ProviderInput
+	SecurityGroup  ec2.SecurityGroupInput
+	StorageClasses storagev1.StorageClassMapInput
+}
+
+func (ComponentState) ElementType() reflect.Type {
+	return reflect.TypeOf((*componentState)(nil)).Elem()
+}
+
+type componentArgs struct {
+	Metadata *metav1.ObjectMeta `pulumi:"metadata"`
+}
+
+// The set of arguments for constructing a Component resource.
+type ComponentArgs struct {
+	Metadata metav1.ObjectMetaPtrInput
+}
+
+func (ComponentArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*componentArgs)(nil)).Elem()
+}
+
+type ComponentInput interface {
+	pulumi.Input
+
+	ToComponentOutput() ComponentOutput
+	ToComponentOutputWithContext(ctx context.Context) ComponentOutput
+}
+
+func (*Component) ElementType() reflect.Type {
+	return reflect.TypeOf((*Component)(nil))
+}
+
+func (i *Component) ToComponentOutput() ComponentOutput {
+	return i.ToComponentOutputWithContext(context.Background())
+}
+
+func (i *Component) ToComponentOutputWithContext(ctx context.Context) ComponentOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ComponentOutput)
+}
+
+func (i *Component) ToComponentPtrOutput() ComponentPtrOutput {
+	return i.ToComponentPtrOutputWithContext(context.Background())
+}
+
+func (i *Component) ToComponentPtrOutputWithContext(ctx context.Context) ComponentPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ComponentPtrOutput)
+}
+
+type ComponentPtrInput interface {
+	pulumi.Input
+
+	ToComponentPtrOutput() ComponentPtrOutput
+	ToComponentPtrOutputWithContext(ctx context.Context) ComponentPtrOutput
+}
+
+type componentPtrType ComponentArgs
+
+func (*componentPtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**Component)(nil))
+}
+
+func (i *componentPtrType) ToComponentPtrOutput() ComponentPtrOutput {
+	return i.ToComponentPtrOutputWithContext(context.Background())
+}
+
+func (i *componentPtrType) ToComponentPtrOutputWithContext(ctx context.Context) ComponentPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ComponentPtrOutput)
+}
+
+// ComponentArrayInput is an input type that accepts ComponentArray and ComponentArrayOutput values.
+// You can construct a concrete instance of `ComponentArrayInput` via:
+//
+//          ComponentArray{ ComponentArgs{...} }
+type ComponentArrayInput interface {
+	pulumi.Input
+
+	ToComponentArrayOutput() ComponentArrayOutput
+	ToComponentArrayOutputWithContext(context.Context) ComponentArrayOutput
+}
+
+type ComponentArray []ComponentInput
+
+func (ComponentArray) ElementType() reflect.Type {
+	return reflect.TypeOf(([]*Component)(nil))
+}
+
+func (i ComponentArray) ToComponentArrayOutput() ComponentArrayOutput {
+	return i.ToComponentArrayOutputWithContext(context.Background())
+}
+
+func (i ComponentArray) ToComponentArrayOutputWithContext(ctx context.Context) ComponentArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ComponentArrayOutput)
+}
+
+// ComponentMapInput is an input type that accepts ComponentMap and ComponentMapOutput values.
+// You can construct a concrete instance of `ComponentMapInput` via:
+//
+//          ComponentMap{ "key": ComponentArgs{...} }
+type ComponentMapInput interface {
+	pulumi.Input
+
+	ToComponentMapOutput() ComponentMapOutput
+	ToComponentMapOutputWithContext(context.Context) ComponentMapOutput
+}
+
+type ComponentMap map[string]ComponentInput
+
+func (ComponentMap) ElementType() reflect.Type {
+	return reflect.TypeOf((map[string]*Component)(nil))
+}
+
+func (i ComponentMap) ToComponentMapOutput() ComponentMapOutput {
+	return i.ToComponentMapOutputWithContext(context.Background())
+}
+
+func (i ComponentMap) ToComponentMapOutputWithContext(ctx context.Context) ComponentMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ComponentMapOutput)
+}
+
+type ComponentOutput struct {
+	*pulumi.OutputState
+}
+
+func (ComponentOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*Component)(nil))
+}
+
+func (o ComponentOutput) ToComponentOutput() ComponentOutput {
+	return o
+}
+
+func (o ComponentOutput) ToComponentOutputWithContext(ctx context.Context) ComponentOutput {
+	return o
+}
+
+func (o ComponentOutput) ToComponentPtrOutput() ComponentPtrOutput {
+	return o.ToComponentPtrOutputWithContext(context.Background())
+}
+
+func (o ComponentOutput) ToComponentPtrOutputWithContext(ctx context.Context) ComponentPtrOutput {
+	return o.ApplyT(func(v Component) *Component {
+		return &v
+	}).(ComponentPtrOutput)
+}
+
+type ComponentPtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (ComponentPtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Component)(nil))
+}
+
+func (o ComponentPtrOutput) ToComponentPtrOutput() ComponentPtrOutput {
+	return o
+}
+
+func (o ComponentPtrOutput) ToComponentPtrOutputWithContext(ctx context.Context) ComponentPtrOutput {
+	return o
+}
+
+type ComponentArrayOutput struct{ *pulumi.OutputState }
+
+func (ComponentArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]Component)(nil))
+}
+
+func (o ComponentArrayOutput) ToComponentArrayOutput() ComponentArrayOutput {
+	return o
+}
+
+func (o ComponentArrayOutput) ToComponentArrayOutputWithContext(ctx context.Context) ComponentArrayOutput {
+	return o
+}
+
+func (o ComponentArrayOutput) Index(i pulumi.IntInput) ComponentOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Component {
+		return vs[0].([]Component)[vs[1].(int)]
+	}).(ComponentOutput)
+}
+
+type ComponentMapOutput struct{ *pulumi.OutputState }
+
+func (ComponentMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]Component)(nil))
+}
+
+func (o ComponentMapOutput) ToComponentMapOutput() ComponentMapOutput {
+	return o
+}
+
+func (o ComponentMapOutput) ToComponentMapOutputWithContext(ctx context.Context) ComponentMapOutput {
+	return o
+}
+
+func (o ComponentMapOutput) MapIndex(k pulumi.StringInput) ComponentOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) Component {
+		return vs[0].(map[string]Component)[vs[1].(string)]
+	}).(ComponentOutput)
+}
+
+func init() {
+	pulumi.RegisterOutputType(ComponentOutput{})
+	pulumi.RegisterOutputType(ComponentPtrOutput{})
+	pulumi.RegisterOutputType(ComponentArrayOutput{})
+	pulumi.RegisterOutputType(ComponentMapOutput{})
+}

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/doc.go

@@ -0,0 +1,3 @@
+// Package example exports types, functions, subpackages for provisioning example resources.
+//
+package example

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/provider.go

@@ -0,0 +1,136 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type Provider struct {
+	pulumi.ProviderResourceState
+}
+
+// NewProvider registers a new resource with the given unique name, arguments, and options.
+func NewProvider(ctx *pulumi.Context,
+	name string, args *ProviderArgs, opts ...pulumi.ResourceOption) (*Provider, error) {
+	if args == nil {
+		args = &ProviderArgs{}
+	}
+
+	var resource Provider
+	err := ctx.RegisterResource("pulumi:providers:example", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+type providerArgs struct {
+}
+
+// The set of arguments for constructing a Provider resource.
+type ProviderArgs struct {
+}
+
+func (ProviderArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*providerArgs)(nil)).Elem()
+}
+
+type ProviderInput interface {
+	pulumi.Input
+
+	ToProviderOutput() ProviderOutput
+	ToProviderOutputWithContext(ctx context.Context) ProviderOutput
+}
+
+func (*Provider) ElementType() reflect.Type {
+	return reflect.TypeOf((*Provider)(nil))
+}
+
+func (i *Provider) ToProviderOutput() ProviderOutput {
+	return i.ToProviderOutputWithContext(context.Background())
+}
+
+func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ProviderOutput)
+}
+
+func (i *Provider) ToProviderPtrOutput() ProviderPtrOutput {
+	return i.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (i *Provider) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ProviderPtrOutput)
+}
+
+type ProviderPtrInput interface {
+	pulumi.Input
+
+	ToProviderPtrOutput() ProviderPtrOutput
+	ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput
+}
+
+type providerPtrType ProviderArgs
+
+func (*providerPtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**Provider)(nil))
+}
+
+func (i *providerPtrType) ToProviderPtrOutput() ProviderPtrOutput {
+	return i.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (i *providerPtrType) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ProviderPtrOutput)
+}
+
+type ProviderOutput struct {
+	*pulumi.OutputState
+}
+
+func (ProviderOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*Provider)(nil))
+}
+
+func (o ProviderOutput) ToProviderOutput() ProviderOutput {
+	return o
+}
+
+func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) ProviderOutput {
+	return o
+}
+
+func (o ProviderOutput) ToProviderPtrOutput() ProviderPtrOutput {
+	return o.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (o ProviderOutput) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return o.ApplyT(func(v Provider) *Provider {
+		return &v
+	}).(ProviderPtrOutput)
+}
+
+type ProviderPtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (ProviderPtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Provider)(nil))
+}
+
+func (o ProviderPtrOutput) ToProviderPtrOutput() ProviderPtrOutput {
+	return o
+}
+
+func (o ProviderPtrOutput) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return o
+}
+
+func init() {
+	pulumi.RegisterOutputType(ProviderOutput{})
+	pulumi.RegisterOutputType(ProviderPtrOutput{})
+}

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/pulumiTypes.go

@@ -0,0 +1,158 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/pulumi/pulumi-random/sdk/v2/go/random"
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type Pet struct {
+	Age  *int              `pulumi:"age"`
+	Name *random.RandomPet `pulumi:"name"`
+}
+
+// PetInput is an input type that accepts PetArgs and PetOutput values.
+// You can construct a concrete instance of `PetInput` via:
+//
+//          PetArgs{...}
+type PetInput interface {
+	pulumi.Input
+
+	ToPetOutput() PetOutput
+	ToPetOutputWithContext(context.Context) PetOutput
+}
+
+type PetArgs struct {
+	Age  pulumi.IntPtrInput    `pulumi:"age"`
+	Name random.RandomPetInput `pulumi:"name"`
+}
+
+func (PetArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*Pet)(nil)).Elem()
+}
+
+func (i PetArgs) ToPetOutput() PetOutput {
+	return i.ToPetOutputWithContext(context.Background())
+}
+
+func (i PetArgs) ToPetOutputWithContext(ctx context.Context) PetOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(PetOutput)
+}
+
+func (i PetArgs) ToPetPtrOutput() PetPtrOutput {
+	return i.ToPetPtrOutputWithContext(context.Background())
+}
+
+func (i PetArgs) ToPetPtrOutputWithContext(ctx context.Context) PetPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(PetOutput).ToPetPtrOutputWithContext(ctx)
+}
+
+// PetPtrInput is an input type that accepts PetArgs, PetPtr and PetPtrOutput values.
+// You can construct a concrete instance of `PetPtrInput` via:
+//
+//          PetArgs{...}
+//
+//  or:
+//
+//          nil
+type PetPtrInput interface {
+	pulumi.Input
+
+	ToPetPtrOutput() PetPtrOutput
+	ToPetPtrOutputWithContext(context.Context) PetPtrOutput
+}
+
+type petPtrType PetArgs
+
+func PetPtr(v *PetArgs) PetPtrInput {
+	return (*petPtrType)(v)
+}
+
+func (*petPtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**Pet)(nil)).Elem()
+}
+
+func (i *petPtrType) ToPetPtrOutput() PetPtrOutput {
+	return i.ToPetPtrOutputWithContext(context.Background())
+}
+
+func (i *petPtrType) ToPetPtrOutputWithContext(ctx context.Context) PetPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(PetPtrOutput)
+}
+
+type PetOutput struct{ *pulumi.OutputState }
+
+func (PetOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*Pet)(nil)).Elem()
+}
+
+func (o PetOutput) ToPetOutput() PetOutput {
+	return o
+}
+
+func (o PetOutput) ToPetOutputWithContext(ctx context.Context) PetOutput {
+	return o
+}
+
+func (o PetOutput) ToPetPtrOutput() PetPtrOutput {
+	return o.ToPetPtrOutputWithContext(context.Background())
+}
+
+func (o PetOutput) ToPetPtrOutputWithContext(ctx context.Context) PetPtrOutput {
+	return o.ApplyT(func(v Pet) *Pet {
+		return &v
+	}).(PetPtrOutput)
+}
+func (o PetOutput) Age() pulumi.IntPtrOutput {
+	return o.ApplyT(func(v Pet) *int { return v.Age }).(pulumi.IntPtrOutput)
+}
+
+func (o PetOutput) Name() random.RandomPetOutput {
+	return o.ApplyT(func(v Pet) *random.RandomPet { return v.Name }).(random.RandomPetOutput)
+}
+
+type PetPtrOutput struct{ *pulumi.OutputState }
+
+func (PetPtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Pet)(nil)).Elem()
+}
+
+func (o PetPtrOutput) ToPetPtrOutput() PetPtrOutput {
+	return o
+}
+
+func (o PetPtrOutput) ToPetPtrOutputWithContext(ctx context.Context) PetPtrOutput {
+	return o
+}
+
+func (o PetPtrOutput) Elem() PetOutput {
+	return o.ApplyT(func(v *Pet) Pet { return *v }).(PetOutput)
+}
+
+func (o PetPtrOutput) Age() pulumi.IntPtrOutput {
+	return o.ApplyT(func(v *Pet) *int {
+		if v == nil {
+			return nil
+		}
+		return v.Age
+	}).(pulumi.IntPtrOutput)
+}
+
+func (o PetPtrOutput) Name() random.RandomPetOutput {
+	return o.ApplyT(func(v *Pet) *random.RandomPet {
+		if v == nil {
+			return nil
+		}
+		return v.Name
+	}).(random.RandomPetOutput)
+}
+
+func init() {
+	pulumi.RegisterOutputType(PetOutput{})
+	pulumi.RegisterOutputType(PetPtrOutput{})
+}

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/pulumiUtilities.go

@@ -0,0 +1,77 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/blang/semver"
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type envParser func(v string) interface{}
+
+func parseEnvBool(v string) interface{} {
+	b, err := strconv.ParseBool(v)
+	if err != nil {
+		return nil
+	}
+	return b
+}
+
+func parseEnvInt(v string) interface{} {
+	i, err := strconv.ParseInt(v, 0, 0)
+	if err != nil {
+		return nil
+	}
+	return int(i)
+}
+
+func parseEnvFloat(v string) interface{} {
+	f, err := strconv.ParseFloat(v, 64)
+	if err != nil {
+		return nil
+	}
+	return f
+}
+
+func parseEnvStringArray(v string) interface{} {
+	var result pulumi.StringArray
+	for _, item := range strings.Split(v, ";") {
+		result = append(result, pulumi.String(item))
+	}
+	return result
+}
+
+func getEnvOrDefault(def interface{}, parser envParser, vars ...string) interface{} {
+	for _, v := range vars {
+		if value := os.Getenv(v); value != "" {
+			if parser != nil {
+				return parser(value)
+			}
+			return value
+		}
+	}
+	return def
+}
+
+// PkgVersion uses reflection to determine the version of the current package.
+func PkgVersion() (semver.Version, error) {
+	type sentinal struct{}
+	pkgPath := reflect.TypeOf(sentinal{}).PkgPath()
+	re := regexp.MustCompile("^.*/pulumi-example/sdk/v(\\d+)*")
+	if match := re.FindStringSubmatch(pkgPath); match != nil {
+		vStr := match[1]
+		if len(vStr) == 0 {
+			return semver.Version{Major: 1}, nil
+		}
+		return semver.MustParse(fmt.Sprintf("%s.0.0", vStr)), nil
+	}
+	return semver.Version{}, fmt.Errorf("not found")
+}

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/workload.go

@@ -0,0 +1,256 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"context"
+	"reflect"
+
+	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v2/go/kubernetes/core/v1"
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type Workload struct {
+	pulumi.CustomResourceState
+
+	Pod corev1.PodPtrOutput `pulumi:"pod"`
+}
+
+// NewWorkload registers a new resource with the given unique name, arguments, and options.
+func NewWorkload(ctx *pulumi.Context,
+	name string, args *WorkloadArgs, opts ...pulumi.ResourceOption) (*Workload, error) {
+	if args == nil {
+		args = &WorkloadArgs{}
+	}
+
+	var resource Workload
+	err := ctx.RegisterResource("example::Workload", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetWorkload gets an existing Workload resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetWorkload(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *WorkloadState, opts ...pulumi.ResourceOption) (*Workload, error) {
+	var resource Workload
+	err := ctx.ReadResource("example::Workload", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering Workload resources.
+type workloadState struct {
+	Pod *corev1.Pod `pulumi:"pod"`
+}
+
+type WorkloadState struct {
+	Pod corev1.PodPtrInput
+}
+
+func (WorkloadState) ElementType() reflect.Type {
+	return reflect.TypeOf((*workloadState)(nil)).Elem()
+}
+
+type workloadArgs struct {
+}
+
+// The set of arguments for constructing a Workload resource.
+type WorkloadArgs struct {
+}
+
+func (WorkloadArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*workloadArgs)(nil)).Elem()
+}
+
+type WorkloadInput interface {
+	pulumi.Input
+
+	ToWorkloadOutput() WorkloadOutput
+	ToWorkloadOutputWithContext(ctx context.Context) WorkloadOutput
+}
+
+func (*Workload) ElementType() reflect.Type {
+	return reflect.TypeOf((*Workload)(nil))
+}
+
+func (i *Workload) ToWorkloadOutput() WorkloadOutput {
+	return i.ToWorkloadOutputWithContext(context.Background())
+}
+
+func (i *Workload) ToWorkloadOutputWithContext(ctx context.Context) WorkloadOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(WorkloadOutput)
+}
+
+func (i *Workload) ToWorkloadPtrOutput() WorkloadPtrOutput {
+	return i.ToWorkloadPtrOutputWithContext(context.Background())
+}
+
+func (i *Workload) ToWorkloadPtrOutputWithContext(ctx context.Context) WorkloadPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(WorkloadPtrOutput)
+}
+
+type WorkloadPtrInput interface {
+	pulumi.Input
+
+	ToWorkloadPtrOutput() WorkloadPtrOutput
+	ToWorkloadPtrOutputWithContext(ctx context.Context) WorkloadPtrOutput
+}
+
+type workloadPtrType WorkloadArgs
+
+func (*workloadPtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**Workload)(nil))
+}
+
+func (i *workloadPtrType) ToWorkloadPtrOutput() WorkloadPtrOutput {
+	return i.ToWorkloadPtrOutputWithContext(context.Background())
+}
+
+func (i *workloadPtrType) ToWorkloadPtrOutputWithContext(ctx context.Context) WorkloadPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(WorkloadPtrOutput)
+}
+
+// WorkloadArrayInput is an input type that accepts WorkloadArray and WorkloadArrayOutput values.
+// You can construct a concrete instance of `WorkloadArrayInput` via:
+//
+//          WorkloadArray{ WorkloadArgs{...} }
+type WorkloadArrayInput interface {
+	pulumi.Input
+
+	ToWorkloadArrayOutput() WorkloadArrayOutput
+	ToWorkloadArrayOutputWithContext(context.Context) WorkloadArrayOutput
+}
+
+type WorkloadArray []WorkloadInput
+
+func (WorkloadArray) ElementType() reflect.Type {
+	return reflect.TypeOf(([]*Workload)(nil))
+}
+
+func (i WorkloadArray) ToWorkloadArrayOutput() WorkloadArrayOutput {
+	return i.ToWorkloadArrayOutputWithContext(context.Background())
+}
+
+func (i WorkloadArray) ToWorkloadArrayOutputWithContext(ctx context.Context) WorkloadArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(WorkloadArrayOutput)
+}
+
+// WorkloadMapInput is an input type that accepts WorkloadMap and WorkloadMapOutput values.
+// You can construct a concrete instance of `WorkloadMapInput` via:
+//
+//          WorkloadMap{ "key": WorkloadArgs{...} }
+type WorkloadMapInput interface {
+	pulumi.Input
+
+	ToWorkloadMapOutput() WorkloadMapOutput
+	ToWorkloadMapOutputWithContext(context.Context) WorkloadMapOutput
+}
+
+type WorkloadMap map[string]WorkloadInput
+
+func (WorkloadMap) ElementType() reflect.Type {
+	return reflect.TypeOf((map[string]*Workload)(nil))
+}
+
+func (i WorkloadMap) ToWorkloadMapOutput() WorkloadMapOutput {
+	return i.ToWorkloadMapOutputWithContext(context.Background())
+}
+
+func (i WorkloadMap) ToWorkloadMapOutputWithContext(ctx context.Context) WorkloadMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(WorkloadMapOutput)
+}
+
+type WorkloadOutput struct {
+	*pulumi.OutputState
+}
+
+func (WorkloadOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*Workload)(nil))
+}
+
+func (o WorkloadOutput) ToWorkloadOutput() WorkloadOutput {
+	return o
+}
+
+func (o WorkloadOutput) ToWorkloadOutputWithContext(ctx context.Context) WorkloadOutput {
+	return o
+}
+
+func (o WorkloadOutput) ToWorkloadPtrOutput() WorkloadPtrOutput {
+	return o.ToWorkloadPtrOutputWithContext(context.Background())
+}
+
+func (o WorkloadOutput) ToWorkloadPtrOutputWithContext(ctx context.Context) WorkloadPtrOutput {
+	return o.ApplyT(func(v Workload) *Workload {
+		return &v
+	}).(WorkloadPtrOutput)
+}
+
+type WorkloadPtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (WorkloadPtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Workload)(nil))
+}
+
+func (o WorkloadPtrOutput) ToWorkloadPtrOutput() WorkloadPtrOutput {
+	return o
+}
+
+func (o WorkloadPtrOutput) ToWorkloadPtrOutputWithContext(ctx context.Context) WorkloadPtrOutput {
+	return o
+}
+
+type WorkloadArrayOutput struct{ *pulumi.OutputState }
+
+func (WorkloadArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]Workload)(nil))
+}
+
+func (o WorkloadArrayOutput) ToWorkloadArrayOutput() WorkloadArrayOutput {
+	return o
+}
+
+func (o WorkloadArrayOutput) ToWorkloadArrayOutputWithContext(ctx context.Context) WorkloadArrayOutput {
+	return o
+}
+
+func (o WorkloadArrayOutput) Index(i pulumi.IntInput) WorkloadOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Workload {
+		return vs[0].([]Workload)[vs[1].(int)]
+	}).(WorkloadOutput)
+}
+
+type WorkloadMapOutput struct{ *pulumi.OutputState }
+
+func (WorkloadMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]Workload)(nil))
+}
+
+func (o WorkloadMapOutput) ToWorkloadMapOutput() WorkloadMapOutput {
+	return o
+}
+
+func (o WorkloadMapOutput) ToWorkloadMapOutputWithContext(ctx context.Context) WorkloadMapOutput {
+	return o
+}
+
+func (o WorkloadMapOutput) MapIndex(k pulumi.StringInput) WorkloadOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) Workload {
+		return vs[0].(map[string]Workload)[vs[1].(string)]
+	}).(WorkloadOutput)
+}
+
+func init() {
+	pulumi.RegisterOutputType(WorkloadOutput{})
+	pulumi.RegisterOutputType(WorkloadPtrOutput{})
+	pulumi.RegisterOutputType(WorkloadArrayOutput{})
+	pulumi.RegisterOutputType(WorkloadMapOutput{})
+}

pkg/codegen/internal/test/testdata/external-resource-schema/go/example/workload_test.go

@@ -0,0 +1,54 @@
+package example
+
+import (
+	"github.com/pulumi/pulumi/sdk/v2/go/common/resource"
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sync"
+	"testing"
+)
+
+type mocks int
+
+func (mocks) NewResource(
+	typeToken string,
+	name string,
+	inputs resource.PropertyMap,
+	provider string,
+	id string,
+) (string, resource.PropertyMap, error) {
+	return name + "_id", inputs, nil
+}
+
+func (mocks) Call(token string, args resource.PropertyMap, provider string) (resource.PropertyMap, error) {
+	return args, nil
+}
+
+func TestResourceCollectionOutputs(t *testing.T) {
+	t.Run("ArrayOutput", func(t *testing.T) {
+		require.NoError(t, pulumi.RunErr(func(ctx *pulumi.Context) error {
+			workload1, err := NewWorkload(ctx, "workload1", nil)
+			require.NoError(t, err)
+			workload2, err := NewWorkload(ctx, "workload2", nil)
+			require.NoError(t, err)
+			workloadArr := WorkloadArray{
+				workload1,
+				workload2,
+			}.ToWorkloadArrayOutput()
+			var wg sync.WaitGroup
+			wg.Add(1)
+			pulumi.All(workloadArr.Index(pulumi.Int(0)), workloadArr.Index(pulumi.Int(1))).
+				ApplyT(func(all []interface{}) error {
+					w1 := all[0].(*Workload)
+					w2 := all[1].(*Workload)
+					assert.Equal(t, w1.URN(), workload1.URN())
+					assert.Equal(t, w2.URN(), workload2.URN())
+					wg.Done()
+					return nil
+				})
+			wg.Wait()
+			return nil
+		}, pulumi.WithMocks("project", "stack", mocks(1))))
+	})
+}

pkg/codegen/internal/test/testdata/external-resource-schema/go/go.mod

@@ -0,0 +1,18 @@
+module github.com/pulumi/pulumi/pkg/v2/codegen/internal/test/testdata/external-resource-schema/go
+
+go 1.14
+
+// TODO need to bump these to latest after XX merges
+require (
+	github.com/pulumi/pulumi-aws/sdk/v3 v3.19.2
+	github.com/pulumi/pulumi-kubernetes/sdk/v2 v2.7.2
+	github.com/pulumi/pulumi-random/sdk/v2 v2.4.1
+	github.com/pulumi/pulumi/sdk/v2 v2.14.0
+	github.com/stretchr/testify v1.5.1
+)
+
+replace (
+	github.com/pulumi/pulumi-aws/sdk/v3 => /Users/vivekl/code/pulumi-aws/sdk
+	github.com/pulumi/pulumi-kubernetes/sdk/v2 => /users/vivekl/code/pulumi-kubernetes/sdk
+	github.com/pulumi/pulumi-random/sdk/v2 => /Users/vivekl/code/pulumi-random/sdk
+)

pkg/codegen/internal/test/testdata/external-resource-schema/go/go.sum

@@ -0,0 +1,335 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7 h1:uSoVVbwJiQipAclBbw+8quDsfcvFjOpI5iCf4p/cqCs=
+github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7/go.mod h1:6zEj6s6u/ghQa61ZWa/C2Aw3RkjiTBOix7dkqa1VLIs=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239 h1:kFOfPq6dUM1hTo4JG6LR5AXSUEsOjtdm0kw0FtQtMJA=
+github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
+github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cheggaaa/pb v1.0.18 h1:G/DgkKaBP0V5lnBg/vx61nVxxAU+VqU5yMzSc0f2PPE=
+github.com/cheggaaa/pb v1.0.18/go.mod h1:pQciLPpbU0oxA0h+VJYYLxO+XeDQb5pZijXscXHm81s=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd h1:qMd81Ts1T2OTKmB4acZcyKaMtRnY5Y44NuXGX2GFJ1w=
+github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
+github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
+github.com/djherbis/times v1.2.0 h1:xANXjsC/iBqbO00vkWlYwPWgBgEVU6m6AFYg0Pic+Mc=
+github.com/djherbis/times v1.2.0/go.mod h1:CGMZlo255K5r4Yw0b9RRfFQpM2y7uOmxg4jm9HsaVf8=
+github.com/emirpasic/gods v1.12.0 h1:QAUIPSaCu4G+POclxeqb3F+WPpdKqFGlw36+yOzGlrg=
+github.com/emirpasic/gods v1.12.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
+github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
+github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BHsljHzVlRcyQhjrss6TZTdY2VfCqZPbv5k3iBFa2ZQ=
+github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gliderlabs/ssh v0.2.2 h1:6zsha5zo/TWhRhwqCD3+EarCAgZ2yN28ipRnGPnwkI0=
+github.com/gliderlabs/ssh v0.2.2/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gofrs/flock v0.7.1 h1:DP+LD/t0njgoPBvT5MJLeliUIVQR03hiKR6vezdwHlc=
+github.com/gofrs/flock v0.7.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
+github.com/gofrs/uuid v3.3.0+incompatible h1:8K4tyRfvU1CYPgJsveYFQMhpFd/wXNM7iK6rR7UHz84=
+github.com/gofrs/uuid v3.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
+github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5 h1:F768QJ1E9tib+q5Sc8MkdJi1RxLTbRcTf8LJV56aRls=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 h1:MJG/KsmcqMwFAkh8mTnAwhyKoB+sTAnY4CACC110tbU=
+github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645/go.mod h1:6iZfnjpejD4L/4DwD7NryNaJyCQdzwWwH2MWhCA90Kw=
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd h1:Coekwdh0v2wtGp9Gmz1Ze3eVRAWJMLokvN3QjdzCHLY=
+github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
+github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
+github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.6 h1:6Su7aK7lXmJ/U79bYtBjLNaha4Fs1Rg9plHpcH+vvnE=
+github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
+github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc=
+github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
+github.com/opentracing/basictracer-go v1.0.0 h1:YyUAhaEfjoWXclZVJ9sGoNct7j4TVk7lZWlQw5UXuoo=
+github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74=
+github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/pelletier/go-buffruneio v0.2.0/go.mod h1:JkE26KsDizTr40EUHkXVtNPvgGtbSNq5BcowyYOWdKo=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/pulumi/pulumi v1.14.1 h1:eLVGwyUzjbibKCE5lggFyE01CB68yt5G6CJFCJDwoVI=
+github.com/pulumi/pulumi v2.14.0+incompatible h1:xbBvjUrrLkAXUaFHJmESXnySayTK5HJk1mo5Zlz8WxY=
+github.com/pulumi/pulumi-aws v1.31.0 h1:m3RXWnrV6jzfHJdGc6iGouoQmCtNo69VxTq9Z3QPm2w=
+github.com/pulumi/pulumi-aws v3.19.2+incompatible h1:dfoOS85nQV7VHz2uAda/CGkKw59mFxl3upZWCp30cMI=
+github.com/pulumi/pulumi-aws/sdk v1.31.0 h1:E6RfPg46zsDJLidyh1vC7Gq9M5zFbjnezJqcG7zKchw=
+github.com/pulumi/pulumi-aws/sdk/v3 v3.19.2 h1:OM+pm6GMKQywZ4AASeh+nJ1Sp9zmb6mDJJQj+JiYeRE=
+github.com/pulumi/pulumi-aws/sdk/v3 v3.19.2/go.mod h1:Tiu0MSxPkufZDbNTXNMb8cKiIRWLt+7spM3DPuzLcBc=
+github.com/pulumi/pulumi-kubernetes v1.6.0 h1:PDo9O8G1JXQgkz22poKg6XjrCID7EH6IUjMQtbK5Dy8=
+github.com/pulumi/pulumi-kubernetes/sdk/v2 v2.7.2 h1:0hbditC197x3uC3wIhedGT0V/rgPZQ8oa05EMuQx8e4=
+github.com/pulumi/pulumi-kubernetes/sdk/v2 v2.7.2/go.mod h1:qa56SGhnpUSz1JQteFmnBKjuP4bxhSjP4jknXuMiZFg=
+github.com/pulumi/pulumi-random v1.7.0 h1:X7Zqdn3/OFhsLEPNmoIBr/DKCwd1JD5ozO+mH5z+lbE=
+github.com/pulumi/pulumi-random v2.4.1+incompatible h1:IHaY3ZfvEt8iaFhRvGLklhX7ppfmxhvXdd/0wLjlya0=
+github.com/pulumi/pulumi-random/sdk v1.7.0 h1:6WL+mI7TlQajNsAwZbmaic8vEAx198x7HFbeeKvOf1I=
+github.com/pulumi/pulumi-random/sdk/v2 v2.4.1 h1:eve9LgPEogNWuzxLIhUlZuJBlowEy+YWl/e6w1s60BI=
+github.com/pulumi/pulumi-random/sdk/v2 v2.4.1/go.mod h1:PPzzdlKYXLuBjcl6T4FvvQgKBntKa9gMbZtgslBlVHc=
+github.com/pulumi/pulumi/sdk v1.14.1 h1:FnUPMgO2AgqvKzSBOy3F2X4nJ8n/SaXCOP2eYSNkAxk=
+github.com/pulumi/pulumi/sdk/v2 v2.0.0/go.mod h1:W7k1UDYerc5o97mHnlHHp5iQZKEby+oQrQefWt+2RF4=
+github.com/pulumi/pulumi/sdk/v2 v2.2.1/go.mod h1:QNbWpL4gvf3X0lUFT7TXA2Jo1ff/Ti2l97AyFGYwvW4=
+github.com/pulumi/pulumi/sdk/v2 v2.10.2-0.20200917182150-ab70dd3d645d/go.mod h1:EED7KCDOohYIewUppsav5KHTFTmfYGqUFib1uRvYdWQ=
+github.com/pulumi/pulumi/sdk/v2 v2.14.0 h1:u6s/gP3k6sdsmi+X/0wmc1ECM4b27pbBYHx0aQ5HevU=
+github.com/pulumi/pulumi/sdk/v2 v2.14.0/go.mod h1:Z9ifPo/Q0+hUpAyguVx2gp5Sx+CBumnWvYQDhrM8l3E=
+github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/sabhiram/go-gitignore v0.0.0-20180611051255-d3107576ba94 h1:G04eS0JkAIVZfaJLjla9dNxkJCPiKIGZlw9AfOhzOD0=
+github.com/sabhiram/go-gitignore v0.0.0-20180611051255-d3107576ba94/go.mod h1:b18R55ulyQ/h3RaWyloPyER7fWQVZvimKKhnI5OfrJQ=
+github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
+github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
+github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.6/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
+github.com/spf13/cobra v1.0.0 h1:6m/oheQuQ13N9ks4hubMG6BnvwOeaJrqSPLahSnczz8=
+github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
+github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
+github.com/src-d/gcfg v1.4.0 h1:xXbNR5AlLSA315x2UO+fTSSAXCDf+Ar38/6oyGbDKQ4=
+github.com/src-d/gcfg v1.4.0/go.mod h1:p/UMsR43ujA89BJY9duynAwIpvqEujIH/jFlfL7jWoI=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/texttheater/golang-levenshtein v0.0.0-20191208221605-eb6844b05fc6 h1:9VTskZOIRf2vKF3UL8TuWElry5pgUpV1tFSe/e/0m/E=
+github.com/texttheater/golang-levenshtein v0.0.0-20191208221605-eb6844b05fc6/go.mod h1:XDKHRm5ThF8YJjx001LtgelzsoaEcvnA7lVWz9EeX3g=
+github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/tweekmonster/luser v0.0.0-20161003172636-3fa38070dbd7 h1:X9dsIWPuuEJlPX//UmRKophhOKCGXc46RVIGuttks68=
+github.com/tweekmonster/luser v0.0.0-20161003172636-3fa38070dbd7/go.mod h1:UxoP3EypF8JfGEjAII8jx1q8rQyDnX8qdTCs/UQBVIE=
+github.com/uber/jaeger-client-go v2.22.1+incompatible h1:NHcubEkVbahf9t3p75TOCR83gdUHXjRJvjoBh1yACsM=
+github.com/uber/jaeger-client-go v2.22.1+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
+github.com/uber/jaeger-lib v2.2.0+incompatible h1:MxZXOiR2JuoANZ3J6DE/U0kSFv/eJ/GfSYVCjK7dyaw=
+github.com/uber/jaeger-lib v2.2.0+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
+github.com/xanzy/ssh-agent v0.2.1 h1:TCbipTQL2JiiCprBWx9frJ2eJlCYT00NmctrHxVAr70=
+github.com/xanzy/ssh-agent v0.2.1/go.mod h1:mLlQY/MoOhWBj+gOGMQkOeiEvkx+8pJSI+0Bx9h2kr4=
+github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/atomic v1.6.0 h1:Ezj3JGmsOnG1MoRWQkPBsKLe9DwWD9QeXzTRzzldNVk=
+go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190219172222-a4c6cb3142f2/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200317142112-1b76d66859c6 h1:TjszyFsQsyZNHwdVdZ5m7bjmreu0znc2kRYsEml9/Ww=
+golang.org/x/crypto v0.0.0-20200317142112-1b76d66859c6/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a h1:GuSPYbZzB5/dcLNCwLQLsg3obCJtX9IJhpXkvY7kzk0=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190221075227-b4e8571b14e0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200317113312-5766fd39f98d h1:62ap6LNOjDU6uGmKXHJbSfciMoV+FeI1sRXx/pLDL44=
+golang.org/x/sys v0.0.0-20200317113312-5766fd39f98d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190729092621-ff9f1409240a/go.mod h1:jcCCGcm9btYwXyDqrUWc6MKQKKGJCWEQ3AfLSRIbEuI=
+golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e h1:aZzprAO9/8oim3qStq3wc1Xuxx4QmAGriC4VU4ojemQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55 h1:gSJIx1SDwno+2ElGhA4+qG2zF97qiUzTM+rQ0klBOcE=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20200318110522-7735f76e9fa5 h1:Bs8aCQBqwnuSvG/tB3ip/W8JLeuQt1+1ppSHYi4n9RM=
+google.golang.org/genproto v0.0.0-20200318110522-7735f76e9fa5/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0 h1:bO/TA4OxCOummhSf10siHuG7vJOiwh7SpRpFZDkOgl4=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/cheggaaa/pb.v1 v1.0.28 h1:n1tBJnnK2r7g9OW2btFH91V92STTUevLXYFb8gy9EMk=
+gopkg.in/cheggaaa/pb.v1 v1.0.28/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
+gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+gopkg.in/src-d/go-billy.v4 v4.3.2 h1:0SQA1pRztfTFx2miS8sA97XvooFeNOmvUenF4o0EcVg=
+gopkg.in/src-d/go-billy.v4 v4.3.2/go.mod h1:nDjArDMp+XMs1aFAESLRjfGSgfvoYN0hDfzEk0GjC98=
+gopkg.in/src-d/go-git-fixtures.v3 v3.5.0 h1:ivZFOIltbce2Mo8IjzUHAFoq/IylO9WHhNOAJK+LsJg=
+gopkg.in/src-d/go-git-fixtures.v3 v3.5.0/go.mod h1:dLBcvytrw/TYZsNTWCnkNF2DSIlzWYqTe3rJR56Ac7g=
+gopkg.in/src-d/go-git.v4 v4.13.1 h1:SRtFyV8Kxc0UP7aCHcijOMQGPxHSmMOPrzulQWolkYE=
+gopkg.in/src-d/go-git.v4 v4.13.1/go.mod h1:nx5NYcxdKxq5fpltdHnPa2Exj4Sx0EclMWZQbYDu2z8=
+gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0 h1:ucqkfpjg9WzSUubAO62csmucvxl4/JeW3F4I4909XkM=
+sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU=

pkg/codegen/internal/test/testdata/external-resource-schema/python/pulumi_example/component.py

@@ -7,6 +7,9 @@ import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union
 from . import _utilities, _tables
+from pulumi_aws import _ec2_securitygroup.SecurityGroup
+from pulumi_kubernetes import _storage_k8s_io_v1.StorageClass
+from pulumi_kubernetes import meta_v1 as _meta_v1
 import pulumi_kubernetes
 
 __all__ = ['Component']
@@ -16,6 +19,7 @@ class Component(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 metadata: Optional[pulumi.Input[pulumi.InputType['_meta_v1.ObjectMetaArgs']]] = None,
                  __props__=None,
                  __name__=None,
                  __opts__=None):
@@ -41,7 +45,10 @@ class Component(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = dict()
 
+            __props__['metadata'] = metadata
             __props__['provider'] = None
+            __props__['security_group'] = None
+            __props__['storage_classes'] = None
         super(Component, __self__).__init__(
             'example::Component',
             resource_name,
@@ -71,6 +78,16 @@ class Component(pulumi.CustomResource):
     def provider(self) -> pulumi.Output[Optional['pulumi_kubernetes.Provider']]:
         return pulumi.get(self, "provider")
 
+    @property
+    @pulumi.getter(name="securityGroup")
+    def security_group(self) -> pulumi.Output[Optional['_ec2_securitygroup.SecurityGroup']]:
+        return pulumi.get(self, "security_group")
+
+    @property
+    @pulumi.getter(name="storageClasses")
+    def storage_classes(self) -> pulumi.Output[Optional[Mapping[str, '_storage_k8s_io_v1.StorageClass']]]:
+        return pulumi.get(self, "storage_classes")
+
     def translate_output_property(self, prop):
         return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
 

pkg/codegen/internal/test/testdata/external-resource-schema/schema.json

@@ -43,6 +43,20 @@
       "properties": {
         "provider": {
           "$ref": "/kubernetes/v2.6.3/schema.json#/provider"
+        },
+        "securityGroup": {
+          "$ref": "/aws/v3.14.0/schema.json#/resources/aws:ec2%2FsecurityGroup:SecurityGroup"
+        },
+        "storageClasses": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "/kubernetes/v2.7.3/schema.json#/resources/kubernetes:storage.k8s.io%2Fv1:StorageClass"
+          }
+        }
+      },
+      "inputProperties": {
+        "metadata": {
+          "$ref": "/kubernetes/v2.6.3/schema.json#/types/kubernetes:meta%2Fv1:ObjectMeta"
         }
       }
     }

pkg/codegen/internal/test/testdata/simple-enum-schema/go/plant/doc.go

@@ -0,0 +1,3 @@
+// Package plant-provider exports types, functions, subpackages for provisioning plant-provider resources.
+//
+package plant

pkg/codegen/internal/test/testdata/simple-enum-schema/go/plant/provider.go

@@ -59,6 +59,35 @@ func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutp
 	return pulumi.ToOutputWithContext(ctx, i).(ProviderOutput)
 }
 
+func (i *Provider) ToProviderPtrOutput() ProviderPtrOutput {
+	return i.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (i *Provider) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ProviderPtrOutput)
+}
+
+type ProviderPtrInput interface {
+	pulumi.Input
+
+	ToProviderPtrOutput() ProviderPtrOutput
+	ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput
+}
+
+type providerPtrType ProviderArgs
+
+func (*providerPtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**Provider)(nil))
+}
+
+func (i *providerPtrType) ToProviderPtrOutput() ProviderPtrOutput {
+	return i.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (i *providerPtrType) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ProviderPtrOutput)
+}
+
 type ProviderOutput struct {
 	*pulumi.OutputState
 }
@@ -75,6 +104,33 @@ func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) Provide
 	return o
 }
 
+func (o ProviderOutput) ToProviderPtrOutput() ProviderPtrOutput {
+	return o.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (o ProviderOutput) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return o.ApplyT(func(v Provider) *Provider {
+		return &v
+	}).(ProviderPtrOutput)
+}
+
+type ProviderPtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (ProviderPtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Provider)(nil))
+}
+
+func (o ProviderPtrOutput) ToProviderPtrOutput() ProviderPtrOutput {
+	return o
+}
+
+func (o ProviderPtrOutput) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return o
+}
+
 func init() {
 	pulumi.RegisterOutputType(ProviderOutput{})
+	pulumi.RegisterOutputType(ProviderPtrOutput{})
 }

pkg/codegen/internal/test/testdata/simple-enum-schema/go/plant/pulumiUtilities.go

@@ -0,0 +1,77 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package plant
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/blang/semver"
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type envParser func(v string) interface{}
+
+func parseEnvBool(v string) interface{} {
+	b, err := strconv.ParseBool(v)
+	if err != nil {
+		return nil
+	}
+	return b
+}
+
+func parseEnvInt(v string) interface{} {
+	i, err := strconv.ParseInt(v, 0, 0)
+	if err != nil {
+		return nil
+	}
+	return int(i)
+}
+
+func parseEnvFloat(v string) interface{} {
+	f, err := strconv.ParseFloat(v, 64)
+	if err != nil {
+		return nil
+	}
+	return f
+}
+
+func parseEnvStringArray(v string) interface{} {
+	var result pulumi.StringArray
+	for _, item := range strings.Split(v, ";") {
+		result = append(result, pulumi.String(item))
+	}
+	return result
+}
+
+func getEnvOrDefault(def interface{}, parser envParser, vars ...string) interface{} {
+	for _, v := range vars {
+		if value := os.Getenv(v); value != "" {
+			if parser != nil {
+				return parser(value)
+			}
+			return value
+		}
+	}
+	return def
+}
+
+// PkgVersion uses reflection to determine the version of the current package.
+func PkgVersion() (semver.Version, error) {
+	type sentinal struct{}
+	pkgPath := reflect.TypeOf(sentinal{}).PkgPath()
+	re := regexp.MustCompile("^.*/pulumi-plant-provider/sdk/v(\\d+)*")
+	if match := re.FindStringSubmatch(pkgPath); match != nil {
+		vStr := match[1]
+		if len(vStr) == 0 {
+			return semver.Version{Major: 1}, nil
+		}
+		return semver.MustParse(fmt.Sprintf("%s.0.0", vStr)), nil
+	}
+	return semver.Version{}, fmt.Errorf("not found")
+}

pkg/codegen/internal/test/testdata/simple-enum-schema/go/plant/tree/v1/rubberTree.go

@@ -103,6 +103,85 @@ func (i *RubberTree) ToRubberTreeOutputWithContext(ctx context.Context) RubberTr
 	return pulumi.ToOutputWithContext(ctx, i).(RubberTreeOutput)
 }
 
+func (i *RubberTree) ToRubberTreePtrOutput() RubberTreePtrOutput {
+	return i.ToRubberTreePtrOutputWithContext(context.Background())
+}
+
+func (i *RubberTree) ToRubberTreePtrOutputWithContext(ctx context.Context) RubberTreePtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(RubberTreePtrOutput)
+}
+
+type RubberTreePtrInput interface {
+	pulumi.Input
+
+	ToRubberTreePtrOutput() RubberTreePtrOutput
+	ToRubberTreePtrOutputWithContext(ctx context.Context) RubberTreePtrOutput
+}
+
+type rubberTreePtrType RubberTreeArgs
+
+func (*rubberTreePtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**RubberTree)(nil))
+}
+
+func (i *rubberTreePtrType) ToRubberTreePtrOutput() RubberTreePtrOutput {
+	return i.ToRubberTreePtrOutputWithContext(context.Background())
+}
+
+func (i *rubberTreePtrType) ToRubberTreePtrOutputWithContext(ctx context.Context) RubberTreePtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(RubberTreePtrOutput)
+}
+
+// RubberTreeArrayInput is an input type that accepts RubberTreeArray and RubberTreeArrayOutput values.
+// You can construct a concrete instance of `RubberTreeArrayInput` via:
+//
+//          RubberTreeArray{ RubberTreeArgs{...} }
+type RubberTreeArrayInput interface {
+	pulumi.Input
+
+	ToRubberTreeArrayOutput() RubberTreeArrayOutput
+	ToRubberTreeArrayOutputWithContext(context.Context) RubberTreeArrayOutput
+}
+
+type RubberTreeArray []RubberTreeInput
+
+func (RubberTreeArray) ElementType() reflect.Type {
+	return reflect.TypeOf(([]*RubberTree)(nil))
+}
+
+func (i RubberTreeArray) ToRubberTreeArrayOutput() RubberTreeArrayOutput {
+	return i.ToRubberTreeArrayOutputWithContext(context.Background())
+}
+
+func (i RubberTreeArray) ToRubberTreeArrayOutputWithContext(ctx context.Context) RubberTreeArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(RubberTreeArrayOutput)
+}
+
+// RubberTreeMapInput is an input type that accepts RubberTreeMap and RubberTreeMapOutput values.
+// You can construct a concrete instance of `RubberTreeMapInput` via:
+//
+//          RubberTreeMap{ "key": RubberTreeArgs{...} }
+type RubberTreeMapInput interface {
+	pulumi.Input
+
+	ToRubberTreeMapOutput() RubberTreeMapOutput
+	ToRubberTreeMapOutputWithContext(context.Context) RubberTreeMapOutput
+}
+
+type RubberTreeMap map[string]RubberTreeInput
+
+func (RubberTreeMap) ElementType() reflect.Type {
+	return reflect.TypeOf((map[string]*RubberTree)(nil))
+}
+
+func (i RubberTreeMap) ToRubberTreeMapOutput() RubberTreeMapOutput {
+	return i.ToRubberTreeMapOutputWithContext(context.Background())
+}
+
+func (i RubberTreeMap) ToRubberTreeMapOutputWithContext(ctx context.Context) RubberTreeMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(RubberTreeMapOutput)
+}
+
 type RubberTreeOutput struct {
 	*pulumi.OutputState
 }
@@ -119,6 +198,75 @@ func (o RubberTreeOutput) ToRubberTreeOutputWithContext(ctx context.Context) Rub
 	return o
 }
 
+func (o RubberTreeOutput) ToRubberTreePtrOutput() RubberTreePtrOutput {
+	return o.ToRubberTreePtrOutputWithContext(context.Background())
+}
+
+func (o RubberTreeOutput) ToRubberTreePtrOutputWithContext(ctx context.Context) RubberTreePtrOutput {
+	return o.ApplyT(func(v RubberTree) *RubberTree {
+		return &v
+	}).(RubberTreePtrOutput)
+}
+
+type RubberTreePtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (RubberTreePtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**RubberTree)(nil))
+}
+
+func (o RubberTreePtrOutput) ToRubberTreePtrOutput() RubberTreePtrOutput {
+	return o
+}
+
+func (o RubberTreePtrOutput) ToRubberTreePtrOutputWithContext(ctx context.Context) RubberTreePtrOutput {
+	return o
+}
+
+type RubberTreeArrayOutput struct{ *pulumi.OutputState }
+
+func (RubberTreeArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]RubberTree)(nil))
+}
+
+func (o RubberTreeArrayOutput) ToRubberTreeArrayOutput() RubberTreeArrayOutput {
+	return o
+}
+
+func (o RubberTreeArrayOutput) ToRubberTreeArrayOutputWithContext(ctx context.Context) RubberTreeArrayOutput {
+	return o
+}
+
+func (o RubberTreeArrayOutput) Index(i pulumi.IntInput) RubberTreeOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RubberTree {
+		return vs[0].([]RubberTree)[vs[1].(int)]
+	}).(RubberTreeOutput)
+}
+
+type RubberTreeMapOutput struct{ *pulumi.OutputState }
+
+func (RubberTreeMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]RubberTree)(nil))
+}
+
+func (o RubberTreeMapOutput) ToRubberTreeMapOutput() RubberTreeMapOutput {
+	return o
+}
+
+func (o RubberTreeMapOutput) ToRubberTreeMapOutputWithContext(ctx context.Context) RubberTreeMapOutput {
+	return o
+}
+
+func (o RubberTreeMapOutput) MapIndex(k pulumi.StringInput) RubberTreeOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) RubberTree {
+		return vs[0].(map[string]RubberTree)[vs[1].(string)]
+	}).(RubberTreeOutput)
+}
+
 func init() {
 	pulumi.RegisterOutputType(RubberTreeOutput{})
+	pulumi.RegisterOutputType(RubberTreePtrOutput{})
+	pulumi.RegisterOutputType(RubberTreeArrayOutput{})
+	pulumi.RegisterOutputType(RubberTreeMapOutput{})
 }

pkg/codegen/internal/test/testdata/simple-resource-schema/go/example/doc.go

@@ -0,0 +1,3 @@
+// Package example exports types, functions, subpackages for provisioning example resources.
+//
+package example

pkg/codegen/internal/test/testdata/simple-resource-schema/go/example/otherResource.go

@@ -63,6 +63,85 @@ func (i *OtherResource) ToOtherResourceOutputWithContext(ctx context.Context) Ot
 	return pulumi.ToOutputWithContext(ctx, i).(OtherResourceOutput)
 }
 
+func (i *OtherResource) ToOtherResourcePtrOutput() OtherResourcePtrOutput {
+	return i.ToOtherResourcePtrOutputWithContext(context.Background())
+}
+
+func (i *OtherResource) ToOtherResourcePtrOutputWithContext(ctx context.Context) OtherResourcePtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(OtherResourcePtrOutput)
+}
+
+type OtherResourcePtrInput interface {
+	pulumi.Input
+
+	ToOtherResourcePtrOutput() OtherResourcePtrOutput
+	ToOtherResourcePtrOutputWithContext(ctx context.Context) OtherResourcePtrOutput
+}
+
+type otherResourcePtrType OtherResourceArgs
+
+func (*otherResourcePtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**OtherResource)(nil))
+}
+
+func (i *otherResourcePtrType) ToOtherResourcePtrOutput() OtherResourcePtrOutput {
+	return i.ToOtherResourcePtrOutputWithContext(context.Background())
+}
+
+func (i *otherResourcePtrType) ToOtherResourcePtrOutputWithContext(ctx context.Context) OtherResourcePtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(OtherResourcePtrOutput)
+}
+
+// OtherResourceArrayInput is an input type that accepts OtherResourceArray and OtherResourceArrayOutput values.
+// You can construct a concrete instance of `OtherResourceArrayInput` via:
+//
+//          OtherResourceArray{ OtherResourceArgs{...} }
+type OtherResourceArrayInput interface {
+	pulumi.Input
+
+	ToOtherResourceArrayOutput() OtherResourceArrayOutput
+	ToOtherResourceArrayOutputWithContext(context.Context) OtherResourceArrayOutput
+}
+
+type OtherResourceArray []OtherResourceInput
+
+func (OtherResourceArray) ElementType() reflect.Type {
+	return reflect.TypeOf(([]*OtherResource)(nil))
+}
+
+func (i OtherResourceArray) ToOtherResourceArrayOutput() OtherResourceArrayOutput {
+	return i.ToOtherResourceArrayOutputWithContext(context.Background())
+}
+
+func (i OtherResourceArray) ToOtherResourceArrayOutputWithContext(ctx context.Context) OtherResourceArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(OtherResourceArrayOutput)
+}
+
+// OtherResourceMapInput is an input type that accepts OtherResourceMap and OtherResourceMapOutput values.
+// You can construct a concrete instance of `OtherResourceMapInput` via:
+//
+//          OtherResourceMap{ "key": OtherResourceArgs{...} }
+type OtherResourceMapInput interface {
+	pulumi.Input
+
+	ToOtherResourceMapOutput() OtherResourceMapOutput
+	ToOtherResourceMapOutputWithContext(context.Context) OtherResourceMapOutput
+}
+
+type OtherResourceMap map[string]OtherResourceInput
+
+func (OtherResourceMap) ElementType() reflect.Type {
+	return reflect.TypeOf((map[string]*OtherResource)(nil))
+}
+
+func (i OtherResourceMap) ToOtherResourceMapOutput() OtherResourceMapOutput {
+	return i.ToOtherResourceMapOutputWithContext(context.Background())
+}
+
+func (i OtherResourceMap) ToOtherResourceMapOutputWithContext(ctx context.Context) OtherResourceMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(OtherResourceMapOutput)
+}
+
 type OtherResourceOutput struct {
 	*pulumi.OutputState
 }
@@ -79,6 +158,75 @@ func (o OtherResourceOutput) ToOtherResourceOutputWithContext(ctx context.Contex
 	return o
 }
 
+func (o OtherResourceOutput) ToOtherResourcePtrOutput() OtherResourcePtrOutput {
+	return o.ToOtherResourcePtrOutputWithContext(context.Background())
+}
+
+func (o OtherResourceOutput) ToOtherResourcePtrOutputWithContext(ctx context.Context) OtherResourcePtrOutput {
+	return o.ApplyT(func(v OtherResource) *OtherResource {
+		return &v
+	}).(OtherResourcePtrOutput)
+}
+
+type OtherResourcePtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (OtherResourcePtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**OtherResource)(nil))
+}
+
+func (o OtherResourcePtrOutput) ToOtherResourcePtrOutput() OtherResourcePtrOutput {
+	return o
+}
+
+func (o OtherResourcePtrOutput) ToOtherResourcePtrOutputWithContext(ctx context.Context) OtherResourcePtrOutput {
+	return o
+}
+
+type OtherResourceArrayOutput struct{ *pulumi.OutputState }
+
+func (OtherResourceArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]OtherResource)(nil))
+}
+
+func (o OtherResourceArrayOutput) ToOtherResourceArrayOutput() OtherResourceArrayOutput {
+	return o
+}
+
+func (o OtherResourceArrayOutput) ToOtherResourceArrayOutputWithContext(ctx context.Context) OtherResourceArrayOutput {
+	return o
+}
+
+func (o OtherResourceArrayOutput) Index(i pulumi.IntInput) OtherResourceOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) OtherResource {
+		return vs[0].([]OtherResource)[vs[1].(int)]
+	}).(OtherResourceOutput)
+}
+
+type OtherResourceMapOutput struct{ *pulumi.OutputState }
+
+func (OtherResourceMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]OtherResource)(nil))
+}
+
+func (o OtherResourceMapOutput) ToOtherResourceMapOutput() OtherResourceMapOutput {
+	return o
+}
+
+func (o OtherResourceMapOutput) ToOtherResourceMapOutputWithContext(ctx context.Context) OtherResourceMapOutput {
+	return o
+}
+
+func (o OtherResourceMapOutput) MapIndex(k pulumi.StringInput) OtherResourceOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) OtherResource {
+		return vs[0].(map[string]OtherResource)[vs[1].(string)]
+	}).(OtherResourceOutput)
+}
+
 func init() {
 	pulumi.RegisterOutputType(OtherResourceOutput{})
+	pulumi.RegisterOutputType(OtherResourcePtrOutput{})
+	pulumi.RegisterOutputType(OtherResourceArrayOutput{})
+	pulumi.RegisterOutputType(OtherResourceMapOutput{})
 }

pkg/codegen/internal/test/testdata/simple-resource-schema/go/example/provider.go

@@ -59,6 +59,35 @@ func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutp
 	return pulumi.ToOutputWithContext(ctx, i).(ProviderOutput)
 }
 
+func (i *Provider) ToProviderPtrOutput() ProviderPtrOutput {
+	return i.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (i *Provider) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ProviderPtrOutput)
+}
+
+type ProviderPtrInput interface {
+	pulumi.Input
+
+	ToProviderPtrOutput() ProviderPtrOutput
+	ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput
+}
+
+type providerPtrType ProviderArgs
+
+func (*providerPtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**Provider)(nil))
+}
+
+func (i *providerPtrType) ToProviderPtrOutput() ProviderPtrOutput {
+	return i.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (i *providerPtrType) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ProviderPtrOutput)
+}
+
 type ProviderOutput struct {
 	*pulumi.OutputState
 }
@@ -75,6 +104,33 @@ func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) Provide
 	return o
 }
 
+func (o ProviderOutput) ToProviderPtrOutput() ProviderPtrOutput {
+	return o.ToProviderPtrOutputWithContext(context.Background())
+}
+
+func (o ProviderOutput) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return o.ApplyT(func(v Provider) *Provider {
+		return &v
+	}).(ProviderPtrOutput)
+}
+
+type ProviderPtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (ProviderPtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Provider)(nil))
+}
+
+func (o ProviderPtrOutput) ToProviderPtrOutput() ProviderPtrOutput {
+	return o
+}
+
+func (o ProviderPtrOutput) ToProviderPtrOutputWithContext(ctx context.Context) ProviderPtrOutput {
+	return o
+}
+
 func init() {
 	pulumi.RegisterOutputType(ProviderOutput{})
+	pulumi.RegisterOutputType(ProviderPtrOutput{})
 }

pkg/codegen/internal/test/testdata/simple-resource-schema/go/example/pulumiTypes.go

@@ -0,0 +1,70 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type Object struct {
+	Bar *string   `pulumi:"bar"`
+	Foo *Resource `pulumi:"foo"`
+}
+
+// ObjectInput is an input type that accepts ObjectArgs and ObjectOutput values.
+// You can construct a concrete instance of `ObjectInput` via:
+//
+//          ObjectArgs{...}
+type ObjectInput interface {
+	pulumi.Input
+
+	ToObjectOutput() ObjectOutput
+	ToObjectOutputWithContext(context.Context) ObjectOutput
+}
+
+type ObjectArgs struct {
+	Bar pulumi.StringPtrInput `pulumi:"bar"`
+	Foo ResourceInput         `pulumi:"foo"`
+}
+
+func (ObjectArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*Object)(nil)).Elem()
+}
+
+func (i ObjectArgs) ToObjectOutput() ObjectOutput {
+	return i.ToObjectOutputWithContext(context.Background())
+}
+
+func (i ObjectArgs) ToObjectOutputWithContext(ctx context.Context) ObjectOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ObjectOutput)
+}
+
+type ObjectOutput struct{ *pulumi.OutputState }
+
+func (ObjectOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*Object)(nil)).Elem()
+}
+
+func (o ObjectOutput) ToObjectOutput() ObjectOutput {
+	return o
+}
+
+func (o ObjectOutput) ToObjectOutputWithContext(ctx context.Context) ObjectOutput {
+	return o
+}
+
+func (o ObjectOutput) Bar() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v Object) *string { return v.Bar }).(pulumi.StringPtrOutput)
+}
+
+func (o ObjectOutput) Foo() ResourceOutput {
+	return o.ApplyT(func(v Object) *Resource { return v.Foo }).(ResourceOutput)
+}
+
+func init() {
+	pulumi.RegisterOutputType(ObjectOutput{})
+}

pkg/codegen/internal/test/testdata/simple-resource-schema/go/example/pulumiUtilities.go

@@ -0,0 +1,77 @@
+// *** WARNING: this file was generated by test. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+package example
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/blang/semver"
+	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
+)
+
+type envParser func(v string) interface{}
+
+func parseEnvBool(v string) interface{} {
+	b, err := strconv.ParseBool(v)
+	if err != nil {
+		return nil
+	}
+	return b
+}
+
+func parseEnvInt(v string) interface{} {
+	i, err := strconv.ParseInt(v, 0, 0)
+	if err != nil {
+		return nil
+	}
+	return int(i)
+}
+
+func parseEnvFloat(v string) interface{} {
+	f, err := strconv.ParseFloat(v, 64)
+	if err != nil {
+		return nil
+	}
+	return f
+}
+
+func parseEnvStringArray(v string) interface{} {
+	var result pulumi.StringArray
+	for _, item := range strings.Split(v, ";") {
+		result = append(result, pulumi.String(item))
+	}
+	return result
+}
+
+func getEnvOrDefault(def interface{}, parser envParser, vars ...string) interface{} {
+	for _, v := range vars {
+		if value := os.Getenv(v); value != "" {
+			if parser != nil {
+				return parser(value)
+			}
+			return value
+		}
+	}
+	return def
+}
+
+// PkgVersion uses reflection to determine the version of the current package.
+func PkgVersion() (semver.Version, error) {
+	type sentinal struct{}
+	pkgPath := reflect.TypeOf(sentinal{}).PkgPath()
+	re := regexp.MustCompile("^.*/pulumi-example/sdk/v(\\d+)*")
+	if match := re.FindStringSubmatch(pkgPath); match != nil {
+		vStr := match[1]
+		if len(vStr) == 0 {
+			return semver.Version{Major: 1}, nil
+		}
+		return semver.MustParse(fmt.Sprintf("%s.0.0", vStr)), nil
+	}
+	return semver.Version{}, fmt.Errorf("not found")
+}

pkg/codegen/internal/test/testdata/simple-resource-schema/go/example/resource.go

@@ -88,6 +88,85 @@ func (i *Resource) ToResourceOutputWithContext(ctx context.Context) ResourceOutp
 	return pulumi.ToOutputWithContext(ctx, i).(ResourceOutput)
 }
 
+func (i *Resource) ToResourcePtrOutput() ResourcePtrOutput {
+	return i.ToResourcePtrOutputWithContext(context.Background())
+}
+
+func (i *Resource) ToResourcePtrOutputWithContext(ctx context.Context) ResourcePtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ResourcePtrOutput)
+}
+
+type ResourcePtrInput interface {
+	pulumi.Input
+
+	ToResourcePtrOutput() ResourcePtrOutput
+	ToResourcePtrOutputWithContext(ctx context.Context) ResourcePtrOutput
+}
+
+type resourcePtrType ResourceArgs
+
+func (*resourcePtrType) ElementType() reflect.Type {
+	return reflect.TypeOf((**Resource)(nil))
+}
+
+func (i *resourcePtrType) ToResourcePtrOutput() ResourcePtrOutput {
+	return i.ToResourcePtrOutputWithContext(context.Background())
+}
+
+func (i *resourcePtrType) ToResourcePtrOutputWithContext(ctx context.Context) ResourcePtrOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ResourcePtrOutput)
+}
+
+// ResourceArrayInput is an input type that accepts ResourceArray and ResourceArrayOutput values.
+// You can construct a concrete instance of `ResourceArrayInput` via:
+//
+//          ResourceArray{ ResourceArgs{...} }
+type ResourceArrayInput interface {
+	pulumi.Input
+
+	ToResourceArrayOutput() ResourceArrayOutput
+	ToResourceArrayOutputWithContext(context.Context) ResourceArrayOutput
+}
+
+type ResourceArray []ResourceInput
+
+func (ResourceArray) ElementType() reflect.Type {
+	return reflect.TypeOf(([]*Resource)(nil))
+}
+
+func (i ResourceArray) ToResourceArrayOutput() ResourceArrayOutput {
+	return i.ToResourceArrayOutputWithContext(context.Background())
+}
+
+func (i ResourceArray) ToResourceArrayOutputWithContext(ctx context.Context) ResourceArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ResourceArrayOutput)
+}
+
+// ResourceMapInput is an input type that accepts ResourceMap and ResourceMapOutput values.
+// You can construct a concrete instance of `ResourceMapInput` via:
+//
+//          ResourceMap{ "key": ResourceArgs{...} }
+type ResourceMapInput interface {
+	pulumi.Input
+
+	ToResourceMapOutput() ResourceMapOutput
+	ToResourceMapOutputWithContext(context.Context) ResourceMapOutput
+}
+
+type ResourceMap map[string]ResourceInput
+
+func (ResourceMap) ElementType() reflect.Type {
+	return reflect.TypeOf((map[string]*Resource)(nil))
+}
+
+func (i ResourceMap) ToResourceMapOutput() ResourceMapOutput {
+	return i.ToResourceMapOutputWithContext(context.Background())
+}
+
+func (i ResourceMap) ToResourceMapOutputWithContext(ctx context.Context) ResourceMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ResourceMapOutput)
+}
+
 type ResourceOutput struct {
 	*pulumi.OutputState
 }
@@ -104,6 +183,75 @@ func (o ResourceOutput) ToResourceOutputWithContext(ctx context.Context) Resourc
 	return o
 }
 
+func (o ResourceOutput) ToResourcePtrOutput() ResourcePtrOutput {
+	return o.ToResourcePtrOutputWithContext(context.Background())
+}
+
+func (o ResourceOutput) ToResourcePtrOutputWithContext(ctx context.Context) ResourcePtrOutput {
+	return o.ApplyT(func(v Resource) *Resource {
+		return &v
+	}).(ResourcePtrOutput)
+}
+
+type ResourcePtrOutput struct {
+	*pulumi.OutputState
+}
+
+func (ResourcePtrOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Resource)(nil))
+}
+
+func (o ResourcePtrOutput) ToResourcePtrOutput() ResourcePtrOutput {
+	return o
+}
+
+func (o ResourcePtrOutput) ToResourcePtrOutputWithContext(ctx context.Context) ResourcePtrOutput {
+	return o
+}
+
+type ResourceArrayOutput struct{ *pulumi.OutputState }
+
+func (ResourceArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]Resource)(nil))
+}
+
+func (o ResourceArrayOutput) ToResourceArrayOutput() ResourceArrayOutput {
+	return o
+}
+
+func (o ResourceArrayOutput) ToResourceArrayOutputWithContext(ctx context.Context) ResourceArrayOutput {
+	return o
+}
+
+func (o ResourceArrayOutput) Index(i pulumi.IntInput) ResourceOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Resource {
+		return vs[0].([]Resource)[vs[1].(int)]
+	}).(ResourceOutput)
+}
+
+type ResourceMapOutput struct{ *pulumi.OutputState }
+
+func (ResourceMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]Resource)(nil))
+}
+
+func (o ResourceMapOutput) ToResourceMapOutput() ResourceMapOutput {
+	return o
+}
+
+func (o ResourceMapOutput) ToResourceMapOutputWithContext(ctx context.Context) ResourceMapOutput {
+	return o
+}
+
+func (o ResourceMapOutput) MapIndex(k pulumi.StringInput) ResourceOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) Resource {
+		return vs[0].(map[string]Resource)[vs[1].(string)]
+	}).(ResourceOutput)
+}
+
 func init() {
 	pulumi.RegisterOutputType(ResourceOutput{})
+	pulumi.RegisterOutputType(ResourcePtrOutput{})
+	pulumi.RegisterOutputType(ResourceArrayOutput{})
+	pulumi.RegisterOutputType(ResourceMapOutput{})
 }

pkg/codegen/internal/test/testdata/simple-resource-schema/schema.json

@@ -63,7 +63,9 @@
   },
   "language": {
     "csharp": {},
-    "go": {},
+    "go": {
+      "importBasePath": "github.com/pulumi/pulumi/pkg/v2/codegen/internal/test/testdata/simple-resource-schema/go/example"
+    },
     "nodejs": {},
     "python": {}
   }

pkg/codegen/schema/schema.go

@@ -1104,7 +1104,7 @@ func (t *types) bindTypeSpecRef(spec TypeSpec) (Type, error) {
 		return nil, err
 	}
 
-	// If this is a reference to an external sch
+	// If this is a reference to an external schema
 	referencesExternalSchema := ref.Package != t.pkg.Name || !versionEquals(ref.Version, t.pkg.Version)
 	if referencesExternalSchema {
 		pkg, err := t.loader.LoadPackage(ref.Package, ref.Version)

pkg/resource/deploy/source_eval.go

@@ -525,7 +525,7 @@ func parseProviderRequest(pkg tokens.Package, version string) (providers.Provide
 func (rm *resmon) SupportsFeature(ctx context.Context,
 	req *pulumirpc.SupportsFeatureRequest) (*pulumirpc.SupportsFeatureResponse, error) {
 
-	hasSupport := false
+	hasSupport := true
 
 	switch req.Id {
 	case "secrets":