perf(codegen): migrate to incremental source generator

Directory.Build.targets

@@ -14,6 +14,7 @@
     <ProjectReference
       Include="$(SourceRoot)src/Orleans.CodeGenerator/Orleans.CodeGenerator.csproj"
       OutputItemType="Analyzer"
+      ReferenceOutputAssembly="false"
       PrivateAssets="None"
       Condition=" '$(OrleansBuildTimeCodeGen)' == 'true' "/>
     <ProjectReference
@@ -22,6 +23,7 @@
       UndefineProperties="TargetFramework"
       SkipGetTargetFrameworkProperties="true"
       OutputItemType="Analyzer"
+      ReferenceOutputAssembly="false"
       PrivateAssets="None"
       Condition=" '$(OrleansBuildTimeCodeGen)' == 'true' "/>
   </ItemGroup>

src/Orleans.CodeGenerator/ActivatorGenerator.cs

@@ -8,7 +8,7 @@ namespace Orleans.CodeGenerator
 {
     internal class ActivatorGenerator
     {
-        private readonly CodeGenerator _codeGenerator;
+        private readonly IGeneratorServices _generatorServices;
 
         private struct ConstructorArgument
         {
@@ -17,16 +17,16 @@ private struct ConstructorArgument
             public string ParameterName { get; set; }
         }
 
-        public ActivatorGenerator(CodeGenerator codeGenerator)
+        public ActivatorGenerator(IGeneratorServices generatorServices)
         {
-            _codeGenerator = codeGenerator;
+            _generatorServices = generatorServices;
         }
 
         public ClassDeclarationSyntax GenerateActivator(ISerializableTypeDescription type)
         {
             var simpleClassName = GetSimpleClassName(type);
 
-            var baseInterface = _codeGenerator.LibraryTypes.IActivator_1.ToTypeSyntax(type.TypeSyntax);
+            var baseInterface = _generatorServices.LibraryTypes.IActivator_1.ToTypeSyntax(type.TypeSyntax);
 
             var orderedFields = new List<ConstructorArgument>();
             var index = 0;
@@ -57,7 +57,7 @@ public ClassDeclarationSyntax GenerateActivator(ISerializableTypeDescription typ
             var classDeclaration = ClassDeclaration(simpleClassName)
                 .AddBaseListTypes(SimpleBaseType(baseInterface))
                 .AddModifiers(Token(SyntaxKind.InternalKeyword), Token(SyntaxKind.SealedKeyword))
-                .AddAttributeLists(CodeGenerator.GetGeneratedCodeAttributes())
+                .AddAttributeLists(GeneratedCodeUtilities.GetGeneratedCodeAttributes())
                 .AddMembers(members.ToArray());
 
             if (type.IsGenericType)
@@ -68,7 +68,23 @@ public ClassDeclarationSyntax GenerateActivator(ISerializableTypeDescription typ
             return classDeclaration;
         }
 
-        public static string GetSimpleClassName(ISerializableTypeDescription serializableType) => $"Activator_{serializableType.Name}";
+        public static string GetSimpleClassName(ISerializableTypeDescription serializableType) => GetSimpleClassName(serializableType.Name);
+
+        public static string GetSimpleClassName(string name) => $"Activator_{name}";
+
+        /// <summary>
+        /// Determines whether an activator should be generated for the specified type.
+        /// </summary>
+        internal static bool ShouldGenerateActivator(ISerializableTypeDescription type)
+        {
+            return !type.IsAbstractType
+                && !type.IsEnumType
+                && (!type.IsValueType
+                    && type.IsEmptyConstructable
+                    && !type.UseActivator
+                    && type is not GeneratedInvokableDescription
+                    || type.HasActivatorConstructor);
+        }
 
         private ConstructorDeclarationSyntax GenerateConstructor(
             string simpleClassName,
@@ -126,4 +142,4 @@ private MemberDeclarationSyntax GenerateCreateMethod(ISerializableTypeDescriptio
                 .AddModifiers(Token(SyntaxKind.PublicKeyword));
         }
     }
-}
+}

src/Orleans.CodeGenerator/ApplicationPartAttributeGenerator.cs

@@ -1,24 +1,24 @@
 using System.Collections.Generic;
-using Orleans.CodeGenerator.SyntaxGeneration;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Orleans.CodeGenerator.SyntaxGeneration;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 
 namespace Orleans.CodeGenerator
 {
-    internal static class ApplicationPartAttributeGenerator 
+    internal static class ApplicationPartAttributeGenerator
     {
-        public static List<AttributeListSyntax> GenerateSyntax(LibraryTypes wellKnownTypes, MetadataModel model)
+        public static List<AttributeListSyntax> GenerateSyntax(NameSyntax applicationPartAttribute, IEnumerable<string> applicationParts)
         {
             var attributes = new List<AttributeListSyntax>();
 
-            foreach (var assemblyName in model.ApplicationParts)
+            foreach (var assemblyName in applicationParts)
             {
                 // Generate an assembly-level attribute with an instance of that class.
                 var attribute = AttributeList(
                     AttributeTargetSpecifier(Token(SyntaxKind.AssemblyKeyword)),
                     SingletonSeparatedList(
-                        Attribute(wellKnownTypes.ApplicationPartAttribute.ToNameSyntax())
+                        Attribute(applicationPartAttribute)
                             .AddArgumentListArguments(AttributeArgument(assemblyName.GetLiteralExpression()))));
                 attributes.Add(attribute);
             }