Add support for complex type discriminator.

Breaking change: IDiscriminatorPropertySetConvention.ProcessDiscriminatorPropertySet signature changed

Part of #31376

Author: AndriySvyryd

Diff for: src/EFCore.Cosmos/Metadata/Conventions/CosmosDiscriminatorConvention.cs

@@ -97,14 +97,15 @@ private static void ProcessEntityType(IConventionEntityTypeBuilder entityTypeBui
 
     /// <inheritdoc />
     public override void ProcessDiscriminatorPropertySet(
-        IConventionEntityTypeBuilder entityTypeBuilder,
+        IConventionTypeBaseBuilder structuralTypeBuilder,
         string? name,
         IConventionContext<string> context)
     {
-        var entityType = entityTypeBuilder.Metadata;
-        if (entityType.IsDocumentRoot())
+        var entityType = structuralTypeBuilder.Metadata as IConventionEntityType;
+        if (entityType != null
+            && entityType.IsDocumentRoot())
         {
-            base.ProcessDiscriminatorPropertySet(entityTypeBuilder, name, context);
+            base.ProcessDiscriminatorPropertySet(structuralTypeBuilder, name, context);
         }
     }
 

Diff for: src/EFCore.Cosmos/Metadata/Conventions/CosmosJsonIdConvention.cs

@@ -174,16 +174,10 @@ private void ProcessEntityType(IConventionEntityType entityType, IConventionCont
         }
 
         // Don't chain, because each of these could return null if the property has been explicitly configured with some other value.
-        computedIdPropertyBuilder = computedIdPropertyBuilder.ToJsonProperty(IdPropertyJsonName)
-            ?? computedIdPropertyBuilder;
-
-        computedIdPropertyBuilder = computedIdPropertyBuilder.IsRequired(true)
-            ?? computedIdPropertyBuilder;
-
-        computedIdPropertyBuilder = computedIdPropertyBuilder.HasValueGeneratorFactory(typeof(IdValueGeneratorFactory))
-            ?? computedIdPropertyBuilder;
-
+        computedIdPropertyBuilder.ToJsonProperty(IdPropertyJsonName);
+        computedIdPropertyBuilder.HasValueGeneratorFactory(typeof(IdValueGeneratorFactory));
         computedIdPropertyBuilder.AfterSave(PropertySaveBehavior.Throw);
+        computedIdPropertyBuilder.IsRequired(true);
     }
 
     /// <inheritdoc />
@@ -327,8 +321,13 @@ public virtual void ProcessModelAnnotationChanged(
 
     /// <inheritdoc />
     public virtual void ProcessDiscriminatorPropertySet(
-        IConventionEntityTypeBuilder entityTypeBuilder,
+        IConventionTypeBaseBuilder structuralTypeBuilder,
         string? name,
         IConventionContext<string?> context)
-        => ProcessEntityType(entityTypeBuilder.Metadata, context);
+    {
+        if (structuralTypeBuilder is IConventionEntityTypeBuilder entityTypeBuilder)
+        {
+            ProcessEntityType(entityTypeBuilder.Metadata, context);
+        }
+    }
 }

Diff for: src/EFCore.Design/Scaffolding/Internal/CSharpRuntimeModelCodeGenerator.cs

@@ -925,14 +925,6 @@ private void Create(IEntityType entityType, CSharpRuntimeAnnotationCodeGenerator
                 .Append(_code.Literal(entityType.HasSharedClrType));
         }
 
-        var discriminatorProperty = entityType.GetDiscriminatorPropertyName();
-        if (discriminatorProperty != null)
-        {
-            mainBuilder.AppendLine(",")
-                .Append("discriminatorProperty: ")
-                .Append(_code.Literal(discriminatorProperty));
-        }
-
         var changeTrackingStrategy = entityType.GetChangeTrackingStrategy();
         if (changeTrackingStrategy != ChangeTrackingStrategy.Snapshot)
         {
@@ -959,6 +951,14 @@ private void Create(IEntityType entityType, CSharpRuntimeAnnotationCodeGenerator
                 .Append(_code.Literal(true));
         }
 
+        var discriminatorProperty = entityType.GetDiscriminatorPropertyName();
+        if (discriminatorProperty != null)
+        {
+            mainBuilder.AppendLine(",")
+                .Append("discriminatorProperty: ")
+                .Append(_code.Literal(discriminatorProperty));
+        }
+
         var discriminatorValue = entityType.GetDiscriminatorValue();
         if (discriminatorValue != null)
         {
@@ -2182,6 +2182,24 @@ private void CreateComplexProperty(
                         .Append(_code.Literal(true));
                 }
 
+                var discriminatorPropertyName = complexType.GetDiscriminatorPropertyName();
+                if (discriminatorPropertyName != null)
+                {
+                    mainBuilder.AppendLine(",")
+                        .Append("discriminatorProperty: ")
+                        .Append(_code.Literal(discriminatorPropertyName));
+                }
+
+                var discriminatorValue = complexType.GetDiscriminatorValue();
+                if (discriminatorValue != null)
+                {
+                    AddNamespace(discriminatorValue.GetType(), parameters.Namespaces);
+
+                    mainBuilder.AppendLine(",")
+                        .Append("discriminatorValue: ")
+                        .Append(_code.UnknownLiteral(discriminatorValue));
+                }
+
                 mainBuilder.AppendLine(",")
                     .Append("propertyCount: ")
                     .Append(_code.Literal(complexType.GetDeclaredProperties().Count()));

Diff for: src/EFCore/Infrastructure/ModelValidator.cs

@@ -640,12 +640,16 @@ protected virtual void ValidateInheritanceMapping(
     /// <param name="rootEntityType">The entity type to validate.</param>
     protected virtual void ValidateDiscriminatorValues(IEntityType rootEntityType)
     {
-        var derivedTypes = rootEntityType.GetDerivedTypesInclusive().ToList();
+        var derivedTypes = rootEntityType.GetDerivedTypesInclusive();
         var discriminatorProperty = rootEntityType.FindDiscriminatorProperty();
         if (discriminatorProperty == null)
         {
-            if (derivedTypes.Count == 1)
+            if (!derivedTypes.Skip(1).Any())
             {
+                foreach (var complexProperty in rootEntityType.GetDeclaredComplexProperties())
+                {
+                    ValidateDiscriminatorValues(complexProperty.ComplexType);
+                }
                 return;
             }
 
@@ -655,6 +659,69 @@ protected virtual void ValidateDiscriminatorValues(IEntityType rootEntityType)
 
         var discriminatorValues = new Dictionary<object, IEntityType>(discriminatorProperty.GetKeyValueComparer());
 
+        foreach (var derivedType in derivedTypes)
+        {
+            foreach (var complexProperty in derivedType.GetDeclaredComplexProperties())
+            {
+                ValidateDiscriminatorValues(complexProperty.ComplexType);
+            }
+
+            if (!derivedType.ClrType.IsInstantiable())
+            {
+                continue;
+            }
+
+            var discriminatorValue = derivedType[CoreAnnotationNames.DiscriminatorValue];
+            if (discriminatorValue == null)
+            {
+                throw new InvalidOperationException(
+                    CoreStrings.NoDiscriminatorValue(derivedType.DisplayName()));
+            }
+
+            if (!discriminatorProperty.ClrType.IsInstanceOfType(discriminatorValue))
+            {
+                throw new InvalidOperationException(
+                    CoreStrings.DiscriminatorValueIncompatible(
+                        discriminatorValue, derivedType.DisplayName(), discriminatorProperty.ClrType.DisplayName()));
+            }
+
+            if (discriminatorValues.TryGetValue(discriminatorValue, out var duplicateEntityType))
+            {
+                throw new InvalidOperationException(
+                    CoreStrings.DuplicateDiscriminatorValue(
+                        derivedType.DisplayName(), discriminatorValue, duplicateEntityType.DisplayName()));
+            }
+
+            discriminatorValues[discriminatorValue] = derivedType;
+        }
+    }
+
+    /// <summary>
+    ///     Validates the discriminator and values for the given complex type and nested ones.
+    /// </summary>
+    /// <param name="complexType">The entity type to validate.</param>
+    protected virtual void ValidateDiscriminatorValues(IComplexType complexType)
+    {
+        foreach (var complexProperty in complexType.GetComplexProperties())
+        {
+            ValidateDiscriminatorValues(complexProperty.ComplexType);
+        }
+
+        var derivedTypes = complexType.GetDerivedTypesInclusive();
+        var discriminatorProperty = complexType.FindDiscriminatorProperty();
+        if (discriminatorProperty == null)
+        {
+            if (!derivedTypes.Skip(1).Any())
+            {
+                return;
+            }
+
+            throw new InvalidOperationException(
+                CoreStrings.NoDiscriminatorProperty(complexType.DisplayName()));
+        }
+
+        var discriminatorValues = new Dictionary<object, IComplexType>(discriminatorProperty.GetKeyValueComparer());
+
         foreach (var derivedType in derivedTypes)
         {
             if (!derivedType.ClrType.IsInstantiable())

Diff for: src/EFCore/Metadata/Builders/ComplexPropertyBuilder.cs

@@ -168,11 +168,11 @@ public virtual ComplexTypePropertyBuilder Property(string propertyName)
     ///     If no property with the given name exists, then a new property will be added.
     /// </summary>
     /// <remarks>
-    ///     When adding a new property, if a property with the same name exists in the entity class
-    ///     then it will be added to the model. If no property exists in the entity class, then
+    ///     When adding a new property, if a property with the same name exists in the complex class
+    ///     then it will be added to the model. If no property exists in the complex class, then
     ///     a new shadow state property will be added. A shadow state property is one that does not have a
-    ///     corresponding property in the entity class. The current value for the property is stored in
-    ///     the <see cref="ChangeTracker" /> rather than being stored in instances of the entity class.
+    ///     corresponding property in the complex class. The current value for the property is stored in
+    ///     the <see cref="ChangeTracker" /> rather than being stored in instances of the complex class.
     /// </remarks>
     /// <typeparam name="TProperty">The type of the property to be configured.</typeparam>
     /// <param name="propertyName">The name of the property to be configured.</param>
@@ -188,11 +188,11 @@ public virtual ComplexTypePropertyBuilder<TProperty> Property<TProperty>(string
     ///     If no property with the given name exists, then a new property will be added.
     /// </summary>
     /// <remarks>
-    ///     When adding a new property, if a property with the same name exists in the entity class
-    ///     then it will be added to the model. If no property exists in the entity class, then
+    ///     When adding a new property, if a property with the same name exists in the complex class
+    ///     then it will be added to the model. If no property exists in the complex class, then
     ///     a new shadow state property will be added. A shadow state property is one that does not have a
-    ///     corresponding property in the entity class. The current value for the property is stored in
-    ///     the <see cref="ChangeTracker" /> rather than being stored in instances of the entity class.
+    ///     corresponding property in the complex class. The current value for the property is stored in
+    ///     the <see cref="ChangeTracker" /> rather than being stored in instances of the complex class.
     /// </remarks>
     /// <param name="propertyType">The type of the property to be configured.</param>
     /// <param name="propertyName">The name of the property to be configured.</param>
@@ -225,11 +225,11 @@ public virtual ComplexTypePrimitiveCollectionBuilder PrimitiveCollection(string
     ///     If no property with the given name exists, then a new property will be added.
     /// </summary>
     /// <remarks>
-    ///     When adding a new property, if a property with the same name exists in the entity class
-    ///     then it will be added to the model. If no property exists in the entity class, then
+    ///     When adding a new property, if a property with the same name exists in the complex class
+    ///     then it will be added to the model. If no property exists in the complex class, then
     ///     a new shadow state property will be added. A shadow state property is one that does not have a
-    ///     corresponding property in the entity class. The current value for the property is stored in
-    ///     the <see cref="ChangeTracker" /> rather than being stored in instances of the entity class.
+    ///     corresponding property in the complex class. The current value for the property is stored in
+    ///     the <see cref="ChangeTracker" /> rather than being stored in instances of the complex class.
     /// </remarks>
     /// <typeparam name="TProperty">The type of the property to be configured.</typeparam>
     /// <param name="propertyName">The name of the property to be configured.</param>
@@ -245,11 +245,11 @@ public virtual ComplexTypePrimitiveCollectionBuilder<TProperty> PrimitiveCollect
     ///     If no property with the given name exists, then a new property will be added.
     /// </summary>
     /// <remarks>
-    ///     When adding a new property, if a property with the same name exists in the entity class
-    ///     then it will be added to the model. If no property exists in the entity class, then
+    ///     When adding a new property, if a property with the same name exists in the complex class
+    ///     then it will be added to the model. If no property exists in the complex class, then
     ///     a new shadow state property will be added. A shadow state property is one that does not have a
-    ///     corresponding property in the entity class. The current value for the property is stored in
-    ///     the <see cref="ChangeTracker" /> rather than being stored in instances of the entity class.
+    ///     corresponding property in the complex class. The current value for the property is stored in
+    ///     the <see cref="ChangeTracker" /> rather than being stored in instances of the complex class.
     /// </remarks>
     /// <param name="propertyType">The type of the property to be configured.</param>
     /// <param name="propertyName">The name of the property to be configured.</param>
@@ -265,7 +265,7 @@ public virtual ComplexTypePrimitiveCollectionBuilder PrimitiveCollection(Type pr
     ///     If no property with the given name exists, then a new property will be added.
     /// </summary>
     /// <remarks>
-    ///     Indexer properties are stored in the entity using
+    ///     Indexer properties are stored in the complex type using
     ///     <see href="https://docs.microsoft.com/dotnet/csharp/programming-guide/indexers/">an indexer</see>
     ///     supplying the provided property name.
     /// </remarks>
@@ -284,7 +284,7 @@ public virtual ComplexTypePropertyBuilder<TProperty> IndexerProperty
     ///     If no property with the given name exists, then a new property will be added.
     /// </summary>
     /// <remarks>
-    ///     Indexer properties are stored in the entity using
+    ///     Indexer properties are stored in the complex type using
     ///     <see href="https://docs.microsoft.com/dotnet/csharp/programming-guide/indexers/">an indexer</see>
     ///     supplying the provided property name.
     /// </remarks>
@@ -563,8 +563,8 @@ public virtual ComplexPropertyBuilder Ignore(string propertyName)
     }
 
     /// <summary>
-    ///     Configures the <see cref="ChangeTrackingStrategy" /> to be used for this entity type.
-    ///     This strategy indicates how the context detects changes to properties for an instance of the entity type.
+    ///     Configures the <see cref="ChangeTrackingStrategy" /> to be used for this complex type.
+    ///     This strategy indicates how the context detects changes to properties for an instance of the complex type.
     /// </summary>
     /// <param name="changeTrackingStrategy">The change tracking strategy to be used.</param>
     /// <returns>The same builder instance so that multiple configuration calls can be chained.</returns>
@@ -623,6 +623,53 @@ public virtual ComplexPropertyBuilder UseDefaultPropertyAccessMode(PropertyAcces
         return this;
     }
 
+    /// <summary>
+    ///     Configures the discriminator property used to identify the complex type in the store.
+    /// </summary>
+    /// <returns>A builder that allows the discriminator property to be configured.</returns>
+    public virtual ComplexTypeDiscriminatorBuilder HasDiscriminator()
+        => TypeBuilder.HasDiscriminator(ConfigurationSource.Explicit)!;
+
+    /// <summary>
+    ///     Configures the discriminator property used to identify the complex type in the store.
+    /// </summary>
+    /// <param name="name">The name of the discriminator property.</param>
+    /// <param name="type">The type of values stored in the discriminator property.</param>
+    /// <returns>A builder that allows the discriminator property to be configured.</returns>
+    public virtual ComplexTypeDiscriminatorBuilder HasDiscriminator(
+        string name,
+        Type type)
+    {
+        Check.NotEmpty(name, nameof(name));
+        Check.NotNull(type, nameof(type));
+
+        return TypeBuilder.HasDiscriminator(name, type, ConfigurationSource.Explicit)!;
+    }
+
+    /// <summary>
+    ///     Configures the discriminator property used to identify the complex type in the store.
+    /// </summary>
+    /// <typeparam name="TDiscriminator">The type of values stored in the discriminator property.</typeparam>
+    /// <param name="name">The name of the discriminator property.</param>
+    /// <returns>A builder that allows the discriminator property to be configured.</returns>
+    public virtual ComplexTypeDiscriminatorBuilder<TDiscriminator> HasDiscriminator<TDiscriminator>(string name)
+    {
+        Check.NotEmpty(name, nameof(name));
+
+        return new ComplexTypeDiscriminatorBuilder<TDiscriminator>(
+            TypeBuilder.HasDiscriminator(name, typeof(TDiscriminator), ConfigurationSource.Explicit)!);
+    }
+
+    /// <summary>
+    ///     Configures the complex type as having no discriminator property.
+    /// </summary>
+    /// <returns>The same builder instance so that multiple configuration calls can be chained.</returns>
+    public virtual ComplexPropertyBuilder HasNoDiscriminator()
+    {
+        TypeBuilder.HasNoDiscriminator(ConfigurationSource.Explicit);
+        return this;
+    }
+
     #region Hidden System.Object members
 
     /// <summary>