Auto-generate compiled models for all contexts in the given assembly unless a single one is specified

Fixes #33558

Author: AndriySvyryd

src/EFCore.Design/Design/Internal/DbContextOperations.cs

@@ -14,6 +14,7 @@
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Query.Design;
 using Microsoft.EntityFrameworkCore.Query.Internal;
+using Microsoft.EntityFrameworkCore.Scaffolding.Internal;
 
 namespace Microsoft.EntityFrameworkCore.Design.Internal;
 
@@ -136,16 +137,53 @@ public virtual string ScriptDbContext(string? contextType)
     public virtual IReadOnlyList<string> Optimize(
         string? outputDir, string? modelNamespace, string? contextTypeName, string? suffix, bool scaffoldModel, bool precompileQueries)
     {
-        using var context = CreateContext(contextTypeName);
+        var optimizeAllInAssembly = contextTypeName == "*";
+        var contexts = optimizeAllInAssembly ? CreateAllContexts() : [CreateContext(contextTypeName)];
+
+        MSBuildLocator.RegisterDefaults();
+
+        List<string> generatedFiles = [];
+        HashSet<string> generatedFileNames = [];
+        foreach (var context in contexts)
+        {
+            using (context)
+            {
+                Optimize(
+                    outputDir,
+                    modelNamespace,
+                    suffix,
+                    scaffoldModel,
+                    precompileQueries,
+                    context,
+                    optimizeAllInAssembly,
+                    generatedFiles,
+                    generatedFileNames);
+            }
+        }
+
+        return generatedFiles;
+    }
+
+    private void Optimize(
+        string? outputDir,
+        string? modelNamespace,
+        string? suffix,
+        bool scaffoldModel,
+        bool precompileQueries,
+        DbContext context,
+        bool optimizeAllInAssembly,
+        List<string> generatedFiles,
+        HashSet<string> generatedFileNames)
+    {
         var contextType = context.GetType();
         var services = _servicesBuilder.Build(context);
 
-        IReadOnlyList<string> generatedFiles = [];
         IReadOnlyDictionary<MemberInfo, QualifiedName>? memberAccessReplacements = null;
 
-        if (scaffoldModel)
+        if (scaffoldModel
+            && (!optimizeAllInAssembly || contextType.Assembly == _assembly))
         {
-            generatedFiles = ScaffoldCompiledModel(outputDir, modelNamespace, context, suffix, services);
+            generatedFiles.AddRange(ScaffoldCompiledModel(outputDir, modelNamespace, context, suffix, services, generatedFileNames));
             if (precompileQueries)
             {
                 memberAccessReplacements = ((IRuntimeModel)context.GetService<IDesignTimeModel>().Model).GetUnsafeAccessors();
@@ -154,16 +192,23 @@ public virtual IReadOnlyList<string> Optimize(
 
         if (precompileQueries)
         {
-            generatedFiles = generatedFiles.Concat(PrecompileQueries(
-                outputDir, context, suffix, services, memberAccessReplacements ?? ((IRuntimeModel)context.Model).GetUnsafeAccessors()))
-                .ToList();
+            generatedFiles.AddRange(PrecompileQueries(
+                outputDir,
+                context,
+                suffix,
+                services,
+                memberAccessReplacements ?? ((IRuntimeModel)context.Model).GetUnsafeAccessors(),
+                generatedFileNames));
         }
-
-        return generatedFiles;
     }
 
     private IReadOnlyList<string> ScaffoldCompiledModel(
-        string? outputDir, string? modelNamespace, DbContext context, string? suffix, IServiceProvider services)
+        string? outputDir,
+        string? modelNamespace,
+        DbContext context,
+        string? suffix,
+        IServiceProvider services,
+        ISet<string> generatedFileNames)
     {
         var contextType = context.GetType();
         if (contextType.Assembly != _assembly)
@@ -199,7 +244,8 @@ private IReadOnlyList<string> ScaffoldCompiledModel(
                 ModelNamespace = finalModelNamespace,
                 Language = _language,
                 UseNullableReferenceTypes = _nullable,
-                Suffix = suffix
+                Suffix = suffix,
+                GeneratedFileNames = generatedFileNames
             });
 
         var fullName = contextType.ShortDisplayName() + "Model";
@@ -219,11 +265,10 @@ private IReadOnlyList<string> ScaffoldCompiledModel(
         return scaffoldedFiles;
     }
 
-    private IReadOnlyList<string> PrecompileQueries(string? outputDir, DbContext context, string? suffix, IServiceProvider services, IReadOnlyDictionary<MemberInfo, QualifiedName>? memberAccessReplacements)
+    private IReadOnlyList<string> PrecompileQueries(string? outputDir, DbContext context, string? suffix, IServiceProvider services, IReadOnlyDictionary<MemberInfo, QualifiedName>? memberAccessReplacements, ISet<string> generatedFileNames)
     {
         outputDir = Path.GetFullPath(Path.Combine(_projectDir, outputDir ?? "Generated"));
 
-        MSBuildLocator.RegisterDefaults();
         // TODO: pass through properties
         var workspace = MSBuildWorkspace.Create();
         workspace.LoadMetadataForReferencedProjects = true;
@@ -253,7 +298,14 @@ private IReadOnlyList<string> PrecompileQueries(string? outputDir, DbContext con
 
         var precompilationErrors = new List<PrecompiledQueryCodeGenerator.QueryPrecompilationError>();
         var generatedFiles = precompiledQueryCodeGenerator.GeneratePrecompiledQueries(
-            compilation, syntaxGenerator, context, memberAccessReplacements, precompilationErrors, assembly: _assembly, suffix);
+            compilation,
+            syntaxGenerator,
+            context,
+            memberAccessReplacements,
+            precompilationErrors,
+            generatedFileNames,
+            assembly: _assembly,
+            suffix);
 
         if (precompilationErrors.Count > 0)
         {
@@ -267,19 +319,15 @@ private IReadOnlyList<string> PrecompileQueries(string? outputDir, DbContext con
             throw new InvalidOperationException(errorBuilder.ToString());
         }
 
-        Directory.CreateDirectory(outputDir);
         var writtenFiles = new List<string>();
         foreach (var generatedFile in generatedFiles)
         {
-            var finalText = FormatCode(project, generatedFile).GetAwaiter().GetResult();
-            var outputFilePath = Path.Combine(outputDir, generatedFile.Path);
-            File.WriteAllText(outputFilePath, finalText.ToString());
-            writtenFiles.Add(outputFilePath);
+            generatedFile.Code = FormatCode(project, generatedFile).GetAwaiter().GetResult().ToString()!;
         }
 
-        return writtenFiles;
+        return CompiledModelScaffolder.WriteFiles(generatedFiles, outputDir);
 
-        static async Task<object> FormatCode(Project project, PrecompiledQueryCodeGenerator.GeneratedInterceptorFile generatedFile)
+        static async Task<object> FormatCode(Project project, ScaffoldedFile generatedFile)
         {
             var document = project.AddDocument("_EfGeneratedInterceptors.cs", generatedFile.Code);
 
@@ -334,7 +382,27 @@ static async Task<object> FormatCode(Project project, PrecompiledQueryCodeGenera
     public virtual DbContext CreateContext(string? contextType)
     {
         EF.IsDesignTime = true;
-        var contextPair = FindContextType(contextType);
+        return CreateContext(contextType, FindContextType(contextType));
+    }
+
+    /// <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 IEnumerable<DbContext> CreateAllContexts()
+    {
+        EF.IsDesignTime = true;
+        var types = FindContextTypes();
+        foreach (var contextPair in types)
+        {
+            yield return CreateContext(null, contextPair);
+        }
+    }
+
+    private DbContext CreateContext(string? contextType, KeyValuePair<Type, Func<DbContext>> contextPair)
+    {
         var factory = contextPair.Value;
         try
         {

src/EFCore.Design/Query/Design/IPrecompiledQueryCodeGenerator.cs

@@ -27,16 +27,18 @@ public interface IPrecompiledQueryCodeGenerator : ILanguageBasedService
     /// <param name="dbContext">The context.</param>
     /// <param name="memberAccessReplacements">The member access replacements.</param>
     /// <param name="precompilationErrors">A list that will contain precompilation errors.</param>
+    /// <param name="generatedFileNames">The set of file names generated so far.</param>
     /// <param name="assembly">The assembly corresponding to the provided compilation.</param>
     /// <param name="suffix">The suffix to attach to the name of all the generated files.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>The files containing precompiled queries code.</returns>
-    IReadOnlyList<GeneratedInterceptorFile> GeneratePrecompiledQueries(
+    IReadOnlyList<ScaffoldedFile> GeneratePrecompiledQueries(
         Compilation compilation,
         SyntaxGenerator syntaxGenerator,
         DbContext dbContext,
         IReadOnlyDictionary<MemberInfo, QualifiedName>? memberAccessReplacements,
         List<QueryPrecompilationError> precompilationErrors,
+        ISet<string> generatedFileNames,
         Assembly? assembly = null,
         string? suffix = null,
         CancellationToken cancellationToken = default);

src/EFCore.Design/Query/Internal/PrecompiledQueryCodeGenerator.cs

@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.EntityFrameworkCore.Design.Internal;
+using Microsoft.EntityFrameworkCore.Scaffolding.Internal;
 
 namespace Microsoft.EntityFrameworkCore.Query.Internal;
 
@@ -58,12 +59,13 @@ public PrecompiledQueryCodeGenerator()
     ///     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 IReadOnlyList<GeneratedInterceptorFile> GeneratePrecompiledQueries(
+    public virtual IReadOnlyList<ScaffoldedFile> GeneratePrecompiledQueries(
         Compilation compilation,
         SyntaxGenerator syntaxGenerator,
         DbContext dbContext,
         IReadOnlyDictionary<MemberInfo, QualifiedName>? memberAccessReplacements,
         List<QueryPrecompilationError> precompilationErrors,
+        ISet<string> generatedFileNames,
         Assembly? additionalAssembly = null,
         string? suffix = null,
         CancellationToken cancellationToken = default)
@@ -76,18 +78,19 @@ public virtual IReadOnlyList<GeneratedInterceptorFile> GeneratePrecompiledQuerie
         _liftableConstantProcessor = new LiftableConstantProcessor(null!);
         _queryCompiler = dbContext.GetService<IQueryCompiler>();
         _unsafeAccessors.Clear();
+        var contextType = dbContext.GetType();
         _funcletizer = new ExpressionTreeFuncletizer(
             dbContext.Model,
             dbContext.GetService<IEvaluatableExpressionFilter>(),
-            dbContext.GetType(),
+            contextType,
             generateContextAccessors: false,
             dbContext.GetService<IDiagnosticsLogger<DbLoggerCategory.Query>>());
 
         // This must be done after we complete generating the final compilation above
         _csharpToLinqTranslator.Load(compilation, dbContext, additionalAssembly);
 
         // TODO: Ignore our auto-generated code! Also compiled model, generated code (comment, filename...?).
-        var generatedFiles = new List<GeneratedInterceptorFile>();
+        var generatedFiles = new List<ScaffoldedFile>();
         foreach (var syntaxTree in compilation.SyntaxTrees)
         {
             if (_queryLocator.LocateQueries(syntaxTree, precompilationErrors, cancellationToken) is not { Count: > 0 } locatedQueries)
@@ -97,7 +100,13 @@ public virtual IReadOnlyList<GeneratedInterceptorFile> GeneratePrecompiledQuerie
 
             var semanticModel = compilation.GetSemanticModel(syntaxTree);
             var generatedFile = ProcessSyntaxTree(
-                syntaxTree, semanticModel, locatedQueries, precompilationErrors, suffix ?? ".g", cancellationToken);
+                syntaxTree,
+                semanticModel,
+                locatedQueries,
+                precompilationErrors,
+                "." + contextType.ShortDisplayName() + (suffix ?? ".g"),
+                generatedFileNames,
+                cancellationToken);
             if (generatedFile is not null)
             {
                 generatedFiles.Add(generatedFile);
@@ -113,12 +122,13 @@ public virtual IReadOnlyList<GeneratedInterceptorFile> GeneratePrecompiledQuerie
     ///     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>
-    protected virtual GeneratedInterceptorFile? ProcessSyntaxTree(
+    protected virtual ScaffoldedFile? ProcessSyntaxTree(
         SyntaxTree syntaxTree,
         SemanticModel semanticModel,
         IReadOnlyList<InvocationExpressionSyntax> locatedQueries,
         List<QueryPrecompilationError> precompilationErrors,
         string suffix,
+        ISet<string> generatedFileNames,
         CancellationToken cancellationToken)
     {
         var queriesPrecompiledInFile = 0;
@@ -296,11 +306,15 @@ namespace System.Runtime.CompilerServices
         public InterceptsLocationAttribute(string filePath, int line, int column) { }
     }
 }
-""");
-
-        return new(
-            $"{Path.GetFileNameWithoutExtension(syntaxTree.FilePath)}.EFInterceptors{suffix}{Path.GetExtension(syntaxTree.FilePath)}",
-            _code.ToString());
+"""
+        );
+
+        var name = Uniquifier.Uniquify(
+            Path.GetFileNameWithoutExtension(syntaxTree.FilePath),
+            generatedFileNames,
+            ".EFInterceptors" + suffix + Path.GetExtension(syntaxTree.FilePath),
+            CompiledModelScaffolder.MaxFileNameLength);
+        return new(name, _code.ToString());
     }
 
     /// <summary>
@@ -1135,11 +1149,4 @@ private INamedTypeSymbol GetTypeSymbolOrThrow(string fullyQualifiedMetadataName)
             => _compilation.GetTypeByMetadataName(fullyQualifiedMetadataName)
                 ?? throw new InvalidOperationException("Could not find type symbol for: " + fullyQualifiedMetadataName);
     }
-
-    /// <summary>
-    ///     A generated file containing LINQ operator interceptors.
-    /// </summary>
-    /// <param name="Path">The path of the generated file.</param>
-    /// <param name="Code">The code of the generated file.</param>
-    public sealed record GeneratedInterceptorFile(string Path, string Code);
 }

src/EFCore.Design/Query/Internal/QueryLocator.cs

@@ -294,7 +294,7 @@ bool IsDbContextType(ITypeSymbol typeSymbol)
             {
                 while (true)
                 {
-                    // TODO: Check for the user's specific DbContext type
+                    // TODO: Check for the user's specific DbContext type #33866
                     if (typeSymbol.Equals(_symbols.DbContext, SymbolEqualityComparer.Default))
                     {
                         return true;

src/EFCore.Design/Scaffolding/CompiledModelCodeGenerationOptions.cs

@@ -37,4 +37,10 @@ public class CompiledModelCodeGenerationOptions
     /// </summary>
     /// <value> The suffix to attach to the name of all the generated files. </value>
     public virtual string? Suffix { get; set; }
+
+    /// <summary>
+    ///     Gets or sets the set of file names generated so far.
+    /// </summary>
+    /// <value> The file names generated so far. </value>
+    public virtual ISet<string> GeneratedFileNames { get; set; } = new HashSet<string>();
 }

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

@@ -80,12 +80,10 @@ public override ScaffoldedModel GenerateModel(
         var resultingFiles = new ScaffoldedModel
         {
             ContextFile = new ScaffoldedFile
-            {
-                Path = options.ContextDir != null
-                    ? Path.Combine(options.ContextDir, dbContextFileName)
-                    : dbContextFileName,
-                Code = generatedCode
-            }
+            (options.ContextDir != null
+                ? Path.Combine(options.ContextDir, dbContextFileName)
+                : dbContextFileName,
+             generatedCode)
         };
 
         foreach (var entityType in model.GetEntityTypes())
@@ -106,8 +104,7 @@ public override ScaffoldedModel GenerateModel(
 
             // output EntityType poco .cs file
             var entityTypeFileName = entityType.Name + host.Extension;
-            resultingFiles.AdditionalFiles.Add(
-                new ScaffoldedFile { Path = entityTypeFileName, Code = generatedCode });
+            resultingFiles.AdditionalFiles.Add(new ScaffoldedFile(entityTypeFileName, generatedCode));
         }
 
         return resultingFiles;