Change configuration to use $resourceType instead of $armReference (#…

…4591)

* Change PropertyConfiguration to use ReferenceType

* Change ObjectModelConfiguration to use ReferenceType

* Update other tests to use ReferenceTyep

* Update cross reference checks

* Migrate azure-arm.yaml

* Update azure-arm.yaml after merge

* Rename "other" to "simple"

v2/tools/generator/internal/codegen/pipeline/apply_cross_resource_references_from_config.go

@@ -43,20 +43,21 @@ func ApplyCrossResourceReferencesFromConfig(
 
 			isCrossResourceReference := func(typeName astmodel.InternalTypeName, prop *astmodel.PropertyDefinition) ARMIDPropertyClassification {
 				// First check if we know that this property is an ARMID already
-				isReference, ok := configuration.ObjectModelConfiguration.ARMReference.Lookup(typeName, prop.PropertyName())
+				referenceType, ok := configuration.ObjectModelConfiguration.ReferenceType.Lookup(typeName, prop.PropertyName())
 				isSwaggerARMID := isTypeARMID(prop.PropertyType())
 
 				// If we've got a Swagger ARM ID entry AND an entry in our config, that might be a problem
 				if ok && isSwaggerARMID {
-					if !isReference {
-						// We allow overriding the ARM ID status of a property to false in our config
+					switch referenceType {
+					case config.ReferenceTypeSimple:
+						// We allow overriding the reference type of a property to "other" in our config
 						return ARMIDPropertyClassificationUnset
-					} else {
+					case config.ReferenceTypeARM:
 						// Swagger has marked this field as a reference, and we also have it marked in our
 						// config. Record an error saying that the config entry is no longer needed
 						crossResourceReferenceErrs = append(
 							crossResourceReferenceErrs,
-							eris.Errorf("%s.%s marked as ARM reference, but value is not needed because Swagger already says it is an ARM reference",
+							eris.Errorf("%s.%s marked with reference type ARM, but value is not needed because Swagger already says it is an ARM reference",
 								typeName.String(),
 								prop.PropertyName().String()),
 						)
@@ -76,11 +77,14 @@ func ApplyCrossResourceReferencesFromConfig(
 					)
 				}
 
-				if isReference {
+				switch referenceType {
+				case config.ReferenceTypeARM:
 					return ARMIDPropertyClassificationSet
+				case config.ReferenceTypeSimple:
+					return ARMIDPropertyClassificationUnspecified
+				default:
+					return ARMIDPropertyClassificationUnspecified
 				}
-
-				return ARMIDPropertyClassificationUnspecified
 			}
 
 			visitor := MakeARMIDPropertyTypeVisitor(isCrossResourceReference, log)
@@ -108,7 +112,7 @@ func ApplyCrossResourceReferencesFromConfig(
 				return nil, err
 			}
 
-			err = configuration.ObjectModelConfiguration.ARMReference.VerifyConsumed()
+			err = configuration.ObjectModelConfiguration.ReferenceType.VerifyConsumed()
 			if err != nil {
 				return nil, eris.Wrap(
 					err,

v2/tools/generator/internal/codegen/pipeline/create_arm_types_test.go

@@ -93,7 +93,7 @@ func TestCreateFlattenedARMTypeWithResourceRef_CreatesExpectedConversions(t *tes
 			specProperties.Name(),
 			test.FamilyNameProperty.PropertyName(),
 			func(propertyConfiguration *config.PropertyConfiguration) error {
-				propertyConfiguration.ARMReference.Set(true)
+				propertyConfiguration.ReferenceType.Set(config.ReferenceTypeARM)
 				return nil
 			})).To(Succeed())
 

v2/tools/generator/internal/config/object_model_configuration.go

@@ -49,11 +49,11 @@ type ObjectModelConfiguration struct {
 	TypeNameInNextVersion    typeAccess[string]
 
 	// Property access fields here (alphabetical, please)
-	ARMReference                   propertyAccess[bool]
 	Description                    propertyAccess[string]
 	ImportConfigMapMode            propertyAccess[ImportConfigMapMode]
 	IsSecret                       propertyAccess[bool]
 	PropertyNameInNextVersion      propertyAccess[string]
+	ReferenceType                  propertyAccess[ReferenceType]
 	RenamePropertyTo               propertyAccess[string]
 	ResourceLifecycleOwnedByParent propertyAccess[string]
 }
@@ -109,8 +109,6 @@ func NewObjectModelConfiguration() *ObjectModelConfiguration {
 		result, func(c *TypeConfiguration) *configurable[string] { return &c.NameInNextVersion })
 
 	// Initialize property access fields here (alphabetical, please)
-	result.ARMReference = makePropertyAccess[bool](
-		result, func(c *PropertyConfiguration) *configurable[bool] { return &c.ARMReference })
 	result.Description = makePropertyAccess[string](
 		result, func(c *PropertyConfiguration) *configurable[string] { return &c.Description })
 	result.ImportConfigMapMode = makePropertyAccess[ImportConfigMapMode](
@@ -119,6 +117,8 @@ func NewObjectModelConfiguration() *ObjectModelConfiguration {
 		result, func(c *PropertyConfiguration) *configurable[bool] { return &c.IsSecret })
 	result.PropertyNameInNextVersion = makePropertyAccess[string](
 		result, func(c *PropertyConfiguration) *configurable[string] { return &c.NameInNextVersion })
+	result.ReferenceType = makePropertyAccess[ReferenceType](
+		result, func(c *PropertyConfiguration) *configurable[ReferenceType] { return &c.ReferenceType })
 	result.RenamePropertyTo = makePropertyAccess[string](
 		result, func(c *PropertyConfiguration) *configurable[string] { return &c.RenameTo })
 	result.ResourceLifecycleOwnedByParent = makePropertyAccess[string](

v2/tools/generator/internal/config/object_model_configuration_test.go

@@ -142,14 +142,14 @@ func TestObjectModelConfiguration_ARMReference_WhenSpousePropertyFound_ReturnsEx
 			typeName,
 			"Spouse",
 			func(pc *PropertyConfiguration) error {
-				pc.ARMReference.Set(true)
+				pc.ReferenceType.Set(ReferenceTypeARM)
 				return nil
 			})).
 		To(Succeed())
 
-	isReference, ok := omc.ARMReference.Lookup(typeName, "Spouse")
+	referenceType, ok := omc.ReferenceType.Lookup(typeName, "Spouse")
 	g.Expect(ok).To(BeTrue())
-	g.Expect(isReference).To(BeTrue())
+	g.Expect(referenceType).To(Equal(ReferenceTypeARM))
 }
 
 func TestObjectModelConfiguration_ARMReference_WhenFullNamePropertyFound_ReturnsExpectedResult(t *testing.T) {
@@ -163,14 +163,14 @@ func TestObjectModelConfiguration_ARMReference_WhenFullNamePropertyFound_Returns
 			typeName,
 			"FullName",
 			func(pc *PropertyConfiguration) error {
-				pc.ARMReference.Set(false)
+				pc.ReferenceType.Set(ReferenceTypeSimple)
 				return nil
 			})).
 		To(Succeed())
 
-	isReference, ok := omc.ARMReference.Lookup(typeName, "FullName")
+	referenceType, ok := omc.ReferenceType.Lookup(typeName, "FullName")
 	g.Expect(ok).To(BeTrue())
-	g.Expect(isReference).To(BeFalse())
+	g.Expect(referenceType).To(Equal(ReferenceTypeSimple))
 }
 
 func TestObjectModelConfiguration_ARMReference_WhenPropertyNotFound_ReturnsExpectedResult(t *testing.T) {
@@ -184,12 +184,12 @@ func TestObjectModelConfiguration_ARMReference_WhenPropertyNotFound_ReturnsExpec
 			typeName,
 			"Spouse",
 			func(pc *PropertyConfiguration) error {
-				pc.ARMReference.Set(true)
+				pc.ReferenceType.Set(ReferenceTypeARM)
 				return nil
 			})).
 		To(Succeed())
 
-	_, ok := omc.ARMReference.Lookup(typeName, "KnownAs")
+	_, ok := omc.ReferenceType.Lookup(typeName, "KnownAs")
 	g.Expect(ok).To(BeFalse())
 }
 
@@ -204,15 +204,15 @@ func TestObjectModelConfiguration_VerifyARMReferencesConsumed_WhenReferenceUsed_
 			typeName,
 			"Spouse",
 			func(pc *PropertyConfiguration) error {
-				pc.ARMReference.Set(true)
+				pc.ReferenceType.Set(ReferenceTypeARM)
 				return nil
 			})).
 		To(Succeed())
 
-	ref, ok := omc.ARMReference.Lookup(typeName, "Spouse")
+	referenceType, ok := omc.ReferenceType.Lookup(typeName, "Spouse")
 	g.Expect(ok).To(BeTrue())
-	g.Expect(ref).To(BeTrue())
-	g.Expect(omc.ARMReference.VerifyConsumed()).To(Succeed())
+	g.Expect(referenceType).To(Equal(ReferenceTypeARM))
+	g.Expect(omc.ReferenceType.VerifyConsumed()).To(Succeed())
 }
 
 func TestObjectModelConfiguration_VerifyARMReferencesConsumed_WhenReferenceNotUsed_ReturnsExpectedError(t *testing.T) {
@@ -226,13 +226,13 @@ func TestObjectModelConfiguration_VerifyARMReferencesConsumed_WhenReferenceNotUs
 			typeName,
 			"Spouse",
 			func(pc *PropertyConfiguration) error {
-				pc.ARMReference.Set(true)
+				pc.ReferenceType.Set(ReferenceTypeARM)
 				return nil
 			})).
 		To(Succeed())
 
 	g.Expect(
-		omc.ARMReference.VerifyConsumed()).NotTo(Succeed())
+		omc.ReferenceType.VerifyConsumed()).NotTo(Succeed())
 }
 
 /*

v2/tools/generator/internal/config/property_configuration.go

@@ -23,12 +23,12 @@ import (
 type PropertyConfiguration struct {
 	name string
 	// Configurable properties here (alphabetical, please)
-	ARMReference                   configurable[bool]                // Specify whether this property is an ARM reference
 	Description                    configurable[string]              // Specify a description override for this property
 	ImportConfigMapMode            configurable[ImportConfigMapMode] // The config map mode
 	IsSecret                       configurable[bool]                // Specify whether this property is a secret
 	NameInNextVersion              configurable[string]              // Name this property has in the next version
 	PayloadType                    configurable[PayloadType]         // Specify how this property should be serialized for ARM
+	ReferenceType                  configurable[ReferenceType]       // Specify whether this property is an ARM reference or some other kind
 	RenameTo                       configurable[string]              // Name this property should be renamed to
 	ResourceLifecycleOwnedByParent configurable[string]              // Name of the parent resource which owns the lifecycle of the sub-resource.
 }
@@ -40,13 +40,20 @@ const (
 	ImportConfigMapModeRequired = "required"
 )
 
+type ReferenceType string
+
+const (
+	ReferenceTypeARM    = ReferenceType("arm")    // An ARM reference
+	ReferenceTypeSimple = ReferenceType("simple") // A simple reference requiring no special handling
+)
+
 // Tags used in yaml files to specify configurable properties. Alphabetical please.
 const (
-	armReferenceTag                   = "$armReference"                   // Bool specifying whether a property is an ARM reference
 	descriptionTag                    = "$description"                    // String overriding the properties default description
 	exportAsConfigMapPropertyNameTag  = "$exportAsConfigMapPropertyName"  // String specifying the name of the property set to export this property as a config map.
 	importConfigMapModeTag            = "$importConfigMapMode"            // string specifying the ImportConfigMapMode mode
 	isSecretTag                       = "$isSecret"                       // Bool specifying whether a property contains a secret
+	referenceTypeTag                  = "$referenceType"                  // String specifying what kind of reference we have
 	renamePropertyToTag               = "$renameTo"                       // String specifying the name this property should be renamed to
 	resourceLifecycleOwnedByParentTag = "$resourceLifecycleOwnedByParent" // String specifying whether a property represents a subresource whose lifecycle is owned by the parent resource (and what that parent resource is)
 )
@@ -57,11 +64,11 @@ func NewPropertyConfiguration(name string) *PropertyConfiguration {
 	return &PropertyConfiguration{
 		name: name,
 		// Initialize configurable properties here (alphabetical, please)
-		ARMReference:                   makeConfigurable[bool](armReferenceTag, scope),
 		Description:                    makeConfigurable[string](descriptionTag, scope),
 		ImportConfigMapMode:            makeConfigurable[ImportConfigMapMode](importConfigMapModeTag, scope),
 		IsSecret:                       makeConfigurable[bool](isSecretTag, scope),
 		NameInNextVersion:              makeConfigurable[string](nameInNextVersionTag, scope),
+		ReferenceType:                  makeConfigurable[ReferenceType](referenceTypeTag, scope),
 		RenameTo:                       makeConfigurable[string](renamePropertyToTag, scope),
 		ResourceLifecycleOwnedByParent: makeConfigurable[string](resourceLifecycleOwnedByParentTag, scope),
 	}
@@ -112,15 +119,17 @@ func (pc *PropertyConfiguration) UnmarshalYAML(value *yaml.Node) error {
 			continue
 		}
 
-		// $armReference: <bool>
-		if strings.EqualFold(lastId, armReferenceTag) && c.Kind == yaml.ScalarNode {
-			var isARMRef bool
-			err := c.Decode(&isARMRef)
-			if err != nil {
-				return eris.Wrapf(err, "decoding %s", armReferenceTag)
+		// $referenceType: <string>
+		if strings.EqualFold(lastId, referenceTypeTag) && c.Kind == yaml.ScalarNode {
+			switch strings.ToLower(c.Value) {
+			case string(ReferenceTypeARM):
+				pc.ReferenceType.Set(ReferenceTypeARM)
+			case string(ReferenceTypeSimple):
+				pc.ReferenceType.Set(ReferenceTypeSimple)
+			default:
+				return eris.Errorf("unknown %s value: %s.", referenceTypeTag, c.Value)
 			}
 
-			pc.ARMReference.Set(isARMRef)
 			continue
 		}
 

v2/tools/generator/internal/config/property_configuration_test.go

@@ -23,7 +23,7 @@ func TestPropertyConfiguration_WhenYAMLWellFormed_ReturnsExpectedResult(t *testi
 	err := yaml.Unmarshal(yamlBytes, &property)
 	g.Expect(err).To(Succeed())
 	g.Expect(*property.NameInNextVersion.value).To(Equal("DemoProperty"))
-	g.Expect(*property.ARMReference.value).To(BeTrue())
+	g.Expect(*property.ReferenceType.value).To(Equal(ReferenceTypeARM))
 }
 
 func TestPropertyConfiguration_WhenYAMLBadlyFormed_ReturnsError(t *testing.T) {
@@ -42,11 +42,11 @@ func TestPropertyConfiguration_ARMReference_WhenSpecified_ReturnsExpectedResult(
 	g := NewGomegaWithT(t)
 
 	property := NewPropertyConfiguration("Property")
-	property.ARMReference.Set(true)
+	property.ReferenceType.Set(ReferenceTypeARM)
 
-	isReference, ok := property.ARMReference.Lookup()
+	referenceType, ok := property.ReferenceType.Lookup()
 	g.Expect(ok).To(BeTrue())
-	g.Expect(isReference).To(BeTrue())
+	g.Expect(referenceType).To(Equal(ReferenceTypeARM))
 }
 
 func TestPropertyConfiguration_ARMReference_WhenNotSpecified_ReturnsExpectedResult(t *testing.T) {
@@ -55,7 +55,7 @@ func TestPropertyConfiguration_ARMReference_WhenNotSpecified_ReturnsExpectedResu
 
 	property := NewPropertyConfiguration("Property")
 
-	_, ok := property.ARMReference.Lookup()
+	_, ok := property.ReferenceType.Lookup()
 	g.Expect(ok).To(BeFalse())
 }
 
@@ -64,31 +64,31 @@ func TestPropertyConfiguration_VerifyARMReferenceConsumed_WhenNotConfigured_Retu
 	g := NewGomegaWithT(t)
 
 	property := NewPropertyConfiguration("Property")
-	_, _ = property.ARMReference.Lookup()
+	_, _ = property.ReferenceType.Lookup()
 
-	g.Expect(property.ARMReference.VerifyConsumed()).To(Succeed())
+	g.Expect(property.ReferenceType.VerifyConsumed()).To(Succeed())
 }
 
 func TestPropertyConfiguration_VerifyARMReferenceConsumed_WhenReferenceUsed_ReturnsNil(t *testing.T) {
 	t.Parallel()
 	g := NewGomegaWithT(t)
 
 	property := NewPropertyConfiguration("Property")
-	property.ARMReference.Set(true)
+	property.ReferenceType.Set(ReferenceTypeARM)
 
-	_, _ = property.ARMReference.Lookup()
+	_, _ = property.ReferenceType.Lookup()
 
-	g.Expect(property.ARMReference.VerifyConsumed()).To(Succeed())
+	g.Expect(property.ReferenceType.VerifyConsumed()).To(Succeed())
 }
 
 func TestPropertyConfiguration_VerifyARMReferenceConsumed_WhenReferenceNotUsed_ReturnsExpectedError(t *testing.T) {
 	t.Parallel()
 	g := NewGomegaWithT(t)
 
 	property := NewPropertyConfiguration("Property")
-	property.ARMReference.Set(true)
+	property.ReferenceType.Set(ReferenceTypeARM)
 
-	err := property.ARMReference.VerifyConsumed()
+	err := property.ReferenceType.VerifyConsumed()
 	g.Expect(err).NotTo(BeNil())
 	g.Expect(err.Error()).To(ContainSubstring(property.name))
 }

v2/tools/generator/internal/config/testdata/TestPropertyConfiguration/WhenYAMLWellFormed_ReturnsExpectedResult.yaml

@@ -1,4 +1,4 @@
 ---
 $NameInNextVersion: DemoProperty
-$ARMReference: true
+$referenceType: arm
 ---