Add a pubternal way to namespace-qualify ambiguous types in compiled model.

src/EFCore.Design/Design/Internal/CSharpHelper.cs

@@ -191,16 +191,33 @@ public virtual string Lambda(IReadOnlyList<string> properties, string? lambdaIde
         ///     any release. You should only use it directly in your code with extreme caution and knowing that
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
-        public virtual string Reference(Type type)
-            => Reference(type, useFullName: false);
-
-        private string Reference(Type type, bool useFullName)
+        public virtual string Reference(Type type, bool? fullName = null)
         {
             Check.NotNull(type, nameof(type));
 
-            return type.DisplayName(fullName: useFullName, compilable: true);
+            fullName ??= type.IsNested ? ShouldUseFullName(type.DeclaringType!) : ShouldUseFullName(type);
+
+            return type.DisplayName(fullName.Value, compilable: true);
         }
 
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public virtual bool ShouldUseFullName(Type type)
+            => ShouldUseFullName(type.Name);
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public virtual bool ShouldUseFullName(string shortTypeName)
+            => false;
+
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
         ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -536,8 +553,8 @@ public virtual string Literal(BigInteger value)
         ///     any release. You should only use it directly in your code with extreme caution and knowing that
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
-        public virtual string Literal(Type value)
-            => $"typeof({Reference(value)})";
+        public virtual string Literal(Type value, bool? useFullName = null)
+            => $"typeof({Reference(value, useFullName)})";
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -845,14 +862,14 @@ private bool HandleExpression(Expression expression, StringBuilder builder, bool
                 case ExpressionType.Convert:
                     builder
                         .Append('(')
-                        .Append(Reference(expression.Type, useFullName: true))
+                        .Append(Reference(expression.Type, fullName: true))
                         .Append(')');
 
                     return HandleExpression(((UnaryExpression)expression).Operand, builder);
                 case ExpressionType.New:
                     builder
                         .Append("new ")
-                        .Append(Reference(expression.Type, useFullName: true));
+                        .Append(Reference(expression.Type, fullName: true));
 
                     return HandleArguments(((NewExpression)expression).Arguments, builder);
                 case ExpressionType.Call:
@@ -861,7 +878,7 @@ private bool HandleExpression(Expression expression, StringBuilder builder, bool
                     if (callExpression.Method.IsStatic)
                     {
                         builder
-                            .Append(Reference(callExpression.Method.DeclaringType!, useFullName: true));
+                            .Append(Reference(callExpression.Method.DeclaringType!, fullName: true));
                     }
                     else
                     {
@@ -895,7 +912,7 @@ private bool HandleExpression(Expression expression, StringBuilder builder, bool
                     if (memberExpression.Expression == null)
                     {
                         builder
-                            .Append(Reference(memberExpression.Member.DeclaringType!, useFullName: true));
+                            .Append(Reference(memberExpression.Member.DeclaringType!, fullName: true));
                     }
                     else
                     {

src/EFCore.Design/Migrations/Design/CSharpSnapshotGenerator.cs

@@ -82,7 +82,7 @@ public virtual void Generate(string modelBuilderName, IModel model, IndentedStri
         /// <param name="stringBuilder"> The builder code is added to. </param>
         protected virtual void GenerateEntityTypes(
             string modelBuilderName,
-            IReadOnlyList<IEntityType> entityTypes,
+            IEnumerable<IEntityType> entityTypes,
             IndentedStringBuilder stringBuilder)
         {
             Check.NotEmpty(modelBuilderName, nameof(modelBuilderName));

src/EFCore.Design/Scaffolding/Internal/CSharpRuntimeModelCodeGenerator.cs

@@ -236,8 +236,10 @@ private string CreateModelBuilder(
                     var entityTypes = model.GetEntityTypesInHierarchicalOrder();
                     var variables = new HashSet<string>();
 
+                    var anyEntityTypes = false;
                     foreach (var entityType in entityTypes)
                     {
+                        anyEntityTypes = true;
                         var variableName = _code.Identifier(entityType.ShortName(), variables, capitalize: false);
 
                         var firstChar = variableName[0] == '@' ? variableName[1] : variableName[0];
@@ -265,7 +267,7 @@ private string CreateModelBuilder(
                             .AppendLine(");");
                     }
 
-                    if (entityTypes.Count > 0)
+                    if (anyEntityTypes)
                     {
                         mainBuilder.AppendLine();
                     }
@@ -339,7 +341,7 @@ private string CreateModelBuilder(
                             .AppendLine(");");
                     }
 
-                    if (entityTypes.Count > 0)
+                    if (anyEntityTypes)
                     {
                         mainBuilder.AppendLine();
                     }

src/EFCore/Design/ICSharpHelper.cs

@@ -206,8 +206,9 @@ string Literal<T>(T? value)
         ///     Generates a <see cref="Type"/> literal.
         /// </summary>
         /// <param name="value"> The value. </param>
+        /// <param name="fullName"> Whether the type should be namespace-qualified. </param>
         /// <returns> The literal. </returns>
-        string Literal(Type value);
+        string Literal(Type value, bool? fullName = null);
 
         /// <summary>
         ///     Generates an object array literal.
@@ -228,8 +229,9 @@ string Literal<T>(T? value)
         ///     Generates a C# type reference.
         /// </summary>
         /// <param name="type"> The type to reference. </param>
+        /// <param name="fullName"> Whether the type should be namespace-qualified. </param>
         /// <returns> The reference. </returns>
-        string Reference(Type type);
+        string Reference(Type type, bool? fullName = null);
 
         /// <summary>
         ///     Generates a literal for a type not known at compile time.

src/EFCore/Metadata/Conventions/RuntimeModelConvention.cs

@@ -53,7 +53,7 @@ protected virtual RuntimeModel Create(IModel model)
             ((IModel)runtimeModel).ModelDependencies = model.ModelDependencies!;
 
             var entityTypes = model.GetEntityTypesInHierarchicalOrder();
-            var entityTypePairs = new List<(IEntityType Source, RuntimeEntityType Target)>(entityTypes.Count);
+            var entityTypePairs = new List<(IEntityType Source, RuntimeEntityType Target)>();
 
             foreach (var entityType in entityTypes)
             {

src/EFCore/Metadata/Internal/ModelExtensions.cs

@@ -40,10 +40,10 @@ public static IEnumerable<IEntityType> GetRootEntityTypes(this IModel model)
         ///     any release. You should only use it directly in your code with extreme caution and knowing that
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
-        public static IReadOnlyList<IEntityType> GetEntityTypesInHierarchicalOrder(this IModel model)
+        public static IEnumerable<IEntityType> GetEntityTypesInHierarchicalOrder(this IModel model)
             => Sort(model.GetEntityTypes());
 
-        private static IReadOnlyList<IEntityType> Sort(IEnumerable<IEntityType> entityTypes)
+        private static IEnumerable<IEntityType> Sort(IEnumerable<IEntityType> entityTypes)
         {
             var entityTypeGraph = new Multigraph<IEntityType, int>();
             entityTypeGraph.AddVertices(entityTypes);
@@ -52,7 +52,7 @@ private static IReadOnlyList<IEntityType> Sort(IEnumerable<IEntityType> entityTy
                 entityTypeGraph.AddEdge(entityType.BaseType!, entityType, 0);
             }
 
-            return entityTypeGraph.TopologicalSort();
+            return entityTypeGraph.BatchingTopologicalSort().SelectMany(b => b.OrderBy(et => et.Name));
         }
 
         /// <summary>

src/Shared/SharedTypeExtensions.cs

@@ -420,8 +420,10 @@ public static IEnumerable<MemberInfo> GetMembersInHierarchy(this Type type, stri
 #pragma warning disable IDE0034 // Simplify 'default' expression - default causes default(object)
             { typeof(int), default(int) },
             { typeof(Guid), default(Guid) },
+            { typeof(DateOnly), default(DateOnly) },
             { typeof(DateTime), default(DateTime) },
             { typeof(DateTimeOffset), default(DateTimeOffset) },
+            { typeof(TimeOnly), default(TimeOnly) },
             { typeof(long), default(long) },
             { typeof(bool), default(bool) },
             { typeof(double), default(double) },