WIP on type-qualified Fluent APIs in model snapshot

Author: roji

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

@@ -1000,6 +1000,44 @@ public virtual string Fragment(MethodCallCodeFragment fragment)
             return builder.ToString();
         }
 
+        /// <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 string TypeQualifiedMethodCall(MethodCallCodeFragment fragment, string instanceIdentifier)
+        {
+            // TODO: Strings
+            if (fragment.MethodInfo is null)
+            {
+                throw new ArgumentException("Cannot generate fully-qualified method calls for fragments without a MethodInfo", nameof(fragment));
+            }
+            if (fragment.ChainedCall is not null)
+            {
+                throw new ArgumentException("Cannot generate fully-qualified method calls for chained fragments", nameof(fragment));
+            }
+
+            var builder = new StringBuilder();
+
+            builder
+                .Append(fragment.DeclaringType)
+                .Append('.')
+                .Append(fragment.Method)
+                .Append('(')
+                .Append(instanceIdentifier);
+
+            for (var i = 0; i < fragment.Arguments.Count; i++)
+            {
+                builder.Append(", ");
+                builder.Append(UnknownLiteral(fragment.Arguments[i]));
+            }
+
+            builder.Append(')');
+
+            return builder.ToString();
+        }
+
         private string Fragment(NestedClosureCodeFragment fragment)
         {
             if (fragment.MethodCalls.Count == 1)

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

@@ -40,6 +40,27 @@ public CSharpSnapshotGenerator(CSharpSnapshotGeneratorDependencies dependencies)
         private ICSharpHelper Code
             => Dependencies.CSharpHelper;
 
+        static (IReadOnlyList<T>, IReadOnlyList<T>) Split<T>(IReadOnlyList<T> source, Func<T, bool> predicate)
+        {
+            List<T>? result1 = null, result2 = null;
+
+            foreach (var item in source)
+            {
+                if (predicate(item))
+                {
+                    result1 ??= new();
+                    result1.Add(item);
+                }
+                else
+                {
+                    result2 ??= new();
+                    result2.Add(item);
+                }
+            }
+
+            return (result1 ?? (IReadOnlyList<T>)Array.Empty<T>(), result2 ?? (IReadOnlyList<T>)Array.Empty<T>());
+        }
+
         /// <summary>
         ///     Generates code for creating an <see cref="IModel" />.
         /// </summary>
@@ -58,41 +79,55 @@ public virtual void Generate(string builderName, IModel model, IndentedStringBui
 
             var productVersion = model.GetProductVersion();
 
-            if (annotations.Count > 0 || productVersion != null)
+            var fluentApiCalls = Dependencies.AnnotationCodeGenerator.GenerateFluentApiCalls(model, annotations);
+
+            var (fullyQualifiedFluentApiCalls, nonFullyQualifiedFluentApiCalls)
+                = Split(fluentApiCalls, c => c.MethodInfo is not null && c.MethodInfo.IsStatic);
+
+            // First generate all chained (non-fully-qualified) calls
+            if (nonFullyQualifiedFluentApiCalls.Count > 0 || annotations.Count > 0 || productVersion is not null)
             {
                 stringBuilder.Append(builderName);
 
                 using (stringBuilder.Indent())
                 {
-                    // Temporary patch: specifically exclude some annotations which are known to produce identical Fluent API calls across different
-                    // providers, generating them as raw annotations instead.
-                    var ambiguousAnnotations = RemoveAmbiguousFluentApiAnnotations(
-                        annotations,
-                        name => name.EndsWith(":ValueGenerationStrategy", StringComparison.Ordinal)
-                            || name.EndsWith(":IdentityIncrement", StringComparison.Ordinal)
-                            || name.EndsWith(":IdentitySeed", StringComparison.Ordinal)
-                            || name.EndsWith(":HiLoSequenceName", StringComparison.Ordinal)
-                            || name.EndsWith(":HiLoSequenceSchema", StringComparison.Ordinal));
-
-                    foreach (var methodCallCodeFragment in
-                        Dependencies.AnnotationCodeGenerator.GenerateFluentApiCalls(model, annotations))
+                    if (nonFullyQualifiedFluentApiCalls.Count > 0)
                     {
-                        stringBuilder
-                            .AppendLine()
-                            .Append(Code.Fragment(methodCallCodeFragment));
+                        foreach (var call in nonFullyQualifiedFluentApiCalls)
+                        {
+                            stringBuilder
+                                .AppendLine()
+                                .Append(Code.Fragment(call));
+                        }
                     }
 
-                    IEnumerable<IAnnotation> remainingAnnotations = annotations.Values;
-                    if (productVersion != null)
+                    if (annotations.Count > 0 || productVersion is not null)
                     {
-                        remainingAnnotations = remainingAnnotations.Append(
-                            new Annotation(CoreAnnotationNames.ProductVersion, productVersion));
-                    }
+                        IEnumerable<IAnnotation> remainingAnnotations = annotations.Values;
+                        if (productVersion != null)
+                        {
+                            remainingAnnotations = remainingAnnotations.Append(
+                                new Annotation(CoreAnnotationNames.ProductVersion, productVersion));
+                        }
 
-                    GenerateAnnotations(remainingAnnotations.Concat(ambiguousAnnotations), stringBuilder);
+                        GenerateAnnotations(remainingAnnotations, stringBuilder);
+                    }
                 }
 
                 stringBuilder.AppendLine(";");
+
+                if (fullyQualifiedFluentApiCalls.Count > 0)
+                {
+                    stringBuilder.AppendLine();
+                }
+            }
+
+            // Then generate fully-qualified calls
+            foreach (var call in fullyQualifiedFluentApiCalls)
+            {
+                stringBuilder
+                    .Append(Code.TypeQualifiedMethodCall(call, builderName))
+                    .AppendLine(";");
             }
 
             foreach (var sequence in model.GetSequences())
@@ -1632,6 +1667,7 @@ private void GenerateFluentApiForDefaultValue(
                 .Append(")");
         }
 
+        // TODO: Remove
         private static IReadOnlyList<IAnnotation> RemoveAmbiguousFluentApiAnnotations(
             Dictionary<string, IAnnotation> annotations,
             Func<string, bool> annotationNameMatcher)

src/EFCore.SqlServer/Design/Internal/SqlServerAnnotationCodeGenerator.cs

@@ -32,6 +32,18 @@ private static readonly MethodInfo _modelUseHiLoMethodInfo
             = typeof(SqlServerModelBuilderExtensions).GetRequiredRuntimeMethod(
                 nameof(SqlServerModelBuilderExtensions.UseHiLo), typeof(ModelBuilder), typeof(string), typeof(string));
 
+        private static readonly MethodInfo _modelHasDatabaseMaxSizeMethodInfo
+            = typeof(SqlServerModelBuilderExtensions).GetRequiredRuntimeMethod(
+                nameof(SqlServerModelBuilderExtensions.HasDatabaseMaxSize), typeof(ModelBuilder), typeof(string));
+
+        private static readonly MethodInfo _modelHasServiceTierSqlMethodInfo
+            = typeof(SqlServerModelBuilderExtensions).GetRequiredRuntimeMethod(
+                nameof(SqlServerModelBuilderExtensions.HasServiceTierSql), typeof(ModelBuilder), typeof(string));
+
+        private static readonly MethodInfo _modelHasPerformanceLevelSqlMethodInfo
+            = typeof(SqlServerModelBuilderExtensions).GetRequiredRuntimeMethod(
+                nameof(SqlServerModelBuilderExtensions.HasPerformanceLevelSql), typeof(ModelBuilder), typeof(string));
+
         private static readonly MethodInfo _modelHasAnnotationMethodInfo
             = typeof(ModelBuilder).GetRequiredRuntimeMethod(
                 nameof(ModelBuilder.HasAnnotation), typeof(string), typeof(object));
@@ -118,6 +130,21 @@ public override IReadOnlyList<MethodCallCodeFragment> GenerateFluentApiCalls(
                 fragments.Add(valueGenerationStrategy);
             }
 
+            GenerateSimpleFluentApiCall(
+                annotations,
+                SqlServerAnnotationNames.MaxDatabaseSize, _modelHasDatabaseMaxSizeMethodInfo,
+                fragments);
+
+            GenerateSimpleFluentApiCall(
+                annotations,
+                SqlServerAnnotationNames.ServiceTierSql, _modelHasServiceTierSqlMethodInfo,
+                fragments);
+
+            GenerateSimpleFluentApiCall(
+                annotations,
+                SqlServerAnnotationNames.PerformanceLevelSql, _modelHasPerformanceLevelSqlMethodInfo,
+                fragments);
+
             return fragments;
         }
 
@@ -338,5 +365,22 @@ protected override bool IsHandledByConvention(IModel model, IAnnotation annotati
 
             return default;
         }
+
+        private static void GenerateSimpleFluentApiCall(
+            IDictionary<string, IAnnotation> annotations,
+            string annotationName,
+            MethodInfo methodInfo,
+            List<MethodCallCodeFragment> methodCallCodeFragments)
+        {
+            if (annotations.TryGetValue(annotationName, out var annotation))
+            {
+                annotations.Remove(annotationName);
+                if (annotation.Value is object annotationValue)
+                {
+                    methodCallCodeFragments.Add(
+                        new MethodCallCodeFragment(methodInfo, annotationValue));
+                }
+            }
+        }
     }
 }

src/EFCore/Design/ICSharpHelper.cs

@@ -20,6 +20,17 @@ public interface ICSharpHelper
         /// <returns> The fragment. </returns>
         string Fragment(MethodCallCodeFragment fragment);
 
+        /// <summary>
+        ///     Generates a type-qualified method call code fragment.
+        /// </summary>
+        /// <param name="fragment"> The method call. </param>
+        /// <param name="instanceIdentifier">
+        ///     An identifier to be prepended to the argument list of the <paramref name="fragment"/>, used for generating
+        ///     fully-qualified extension method calls.
+        /// </param>
+        /// <returns> The fragment. </returns>
+        string TypeQualifiedMethodCall(MethodCallCodeFragment fragment, string instanceIdentifier);
+
         /// <summary>
         ///     Generates a valid C# identifier from the specified string unique to the scope.
         /// </summary>