Minor optimizations

Author: PawelGerr

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/AdHocUnions/AdHocUnionCodeGenerator.cs

@@ -156,8 +156,8 @@ private void GenerateConversionsFromValue()
       /// <summary>
       /// ").Append(_state.Settings.ConversionFromValue == ConversionOperatorsGeneration.Implicit ? "Implicit" : "Explicit").Append(" conversion from type ").AppendTypeForXmlComment(memberType).Append(@".
       /// </summary>
-      /// <param name=""").Append(memberType.ArgumentName).Append(@""">Value to covert from.</param>
-      /// <returns>A new instance of ").AppendTypeForXmlComment(_state).Append(@" converted from <paramref name=""").Append(memberType.ArgumentName).Append(@"""/>.</returns>
+      /// <param name=""").AppendArgumentName(memberType.ArgumentName).Append(@""">Value to covert from.</param>
+      /// <returns>A new instance of ").AppendTypeForXmlComment(_state).Append(@" converted from <paramref name=""").AppendArgumentName(memberType.ArgumentName).Append(@"""/>.</returns>
       public static ").AppendConversionOperator(_state.Settings.ConversionFromValue).Append(" operator ").AppendTypeFullyQualified(_state).Append("(").AppendTypeFullyQualified(memberType).Append(" ").AppendEscaped(memberType.ArgumentName).Append(@")
       {
          return new ").AppendTypeFullyQualified(_state).Append("(").AppendEscaped(memberType.ArgumentName).Append(@");
@@ -423,7 +423,7 @@ private void GenerateSwitchForAction(bool withState, bool isPartially)
          var memberType = _state.MemberTypes[i];
 
          _sb.Append(@"
-      /// <param name=""").Append(memberType.ArgumentName).Append(@""">The action to execute if the current value is of type ").AppendTypeForXmlComment(memberType).Append(".</param>");
+      /// <param name=""").AppendArgumentName(memberType.ArgumentName).Append(@""">The action to execute if the current value is of type ").AppendTypeForXmlComment(memberType).Append(".</param>");
       }
 
       if (!_state.IsReferenceType)
@@ -581,7 +581,7 @@ private void GenerateSwitchForFunc(bool withState, bool isPartially)
          var memberType = _state.MemberTypes[i];
 
          _sb.Append(@"
-      /// <param name=""").Append(memberType.ArgumentName).Append(@""">The function to execute if the current value is of type ").AppendTypeForXmlComment(memberType).Append(".</param>");
+      /// <param name=""").AppendArgumentName(memberType.ArgumentName).Append(@""">The function to execute if the current value is of type ").AppendTypeForXmlComment(memberType).Append(".</param>");
       }
 
       if (!_state.IsReferenceType)
@@ -735,7 +735,7 @@ private void GenerateMap(bool isPartially)
          var memberType = _state.MemberTypes[i];
 
          _sb.Append(@"
-      /// <param name=""").Append(memberType.ArgumentName).Append(@""">The instance to return if the current value is of type ").AppendTypeForXmlComment(memberType).Append(".</param>");
+      /// <param name=""").AppendArgumentName(memberType.ArgumentName).Append(@""">The instance to return if the current value is of type ").AppendTypeForXmlComment(memberType).Append(".</param>");
       }
 
       if (!_state.IsReferenceType)
@@ -840,6 +840,8 @@ private void GenerateIndexBasedMapSwitchBody(bool isPartially)
 
    private void GenerateConstructors()
    {
+      var valueArgName = ArgumentName.Create("value", renderAsIs: true);
+
       for (var i = 0; i < _state.MemberTypes.Count; i++)
       {
          var memberType = _state.MemberTypes[i];
@@ -848,7 +850,7 @@ private void GenerateConstructors()
             continue;
 
          var hasDuplicates = memberType.TypeDuplicateCounter != 0;
-         var argName = hasDuplicates ? "value" : memberType.ArgumentName;
+         var argName = hasDuplicates ? valueArgName : memberType.ArgumentName;
 
          _sb.Append(@"
 ");
@@ -857,9 +859,9 @@ private void GenerateConstructors()
          {
             _sb.Append(@"
       /// <summary>
-      /// Initializes new instance with <paramref name=""").Append(argName).Append(@"""/>.
+      /// Initializes new instance with <paramref name=""").AppendArgumentName(argName).Append(@"""/>.
       /// </summary>
-      /// <param name=""").Append(argName).Append(@""">Value to create a new instance for.</param>");
+      /// <param name=""").AppendArgumentName(argName).Append(@""">Value to create a new instance for.</param>");
          }
 
          _sb.Append(@"
@@ -906,9 +908,9 @@ private void GenerateFactoriesForTypeDuplicates()
          _sb.Append(@"
 
       /// <summary>
-      /// Creates new instance with <paramref name=""").Append(memberType.ArgumentName).Append(@"""/>.
+      /// Creates new instance with <paramref name=""").AppendArgumentName(memberType.ArgumentName).Append(@"""/>.
       /// </summary>
-      /// <param name=""").Append(memberType.ArgumentName).Append(@""">Value to create a new instance for.</param>");
+      /// <param name=""").AppendArgumentName(memberType.ArgumentName).Append(@""">Value to create a new instance for.</param>");
 
          _sb.Append(@"
       ").AppendAccessModifier(_state.Settings.ConstructorAccessModifier).Append(" static ").Append(_state.Name).Append(" Create").Append(memberType.Name).Append("(")

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/AdHocUnions/AdHocUnionMemberTypeState.cs

@@ -17,7 +17,7 @@ public sealed class AdHocUnionMemberTypeState
    public bool IsInterface { get; }
    public int TypeDuplicateCounter { get; }
 
-   public string ArgumentName { get; }
+   public ArgumentName ArgumentName { get; }
    public string BackingFieldName { get; }
    public AdHocUnionMemberTypeSetting Setting { get; }
 
@@ -32,7 +32,7 @@ public AdHocUnionMemberTypeState(
       AdHocUnionMemberTypeSetting setting)
    {
       Name = name;
-      ArgumentName = Name.MakeArgumentName();
+      ArgumentName = ArgumentName.Create(Name);
 
       var backingFieldName = (typeDuplicateCounter == 0 ? Name : defaultName).MakeBackingFieldName();
       BackingFieldName = backingFieldName == Name ? $"_{backingFieldName}" : backingFieldName;

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/AdHocUnions/AdHocUnionSourceGenerator.cs

@@ -3,13 +3,8 @@
 namespace Thinktecture.CodeAnalysis.AdHocUnions;
 
 [Generator]
-public class AdHocUnionSourceGenerator : ThinktectureSourceGeneratorBase, IIncrementalGenerator
+public sealed class AdHocUnionSourceGenerator() : ThinktectureSourceGeneratorBase(20_000), IIncrementalGenerator
 {
-   public AdHocUnionSourceGenerator()
-      : base(20_000)
-   {
-   }
-
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
       var options = GetGeneratorOptions(context);
@@ -35,27 +30,26 @@ private void InitializeGenericUnionSourceGen(
       IncrementalValueProvider<GeneratorOptions> options,
       string fullyQualifiedMetadataName)
    {
-      InitializeUnionSourceGen(context, options, fullyQualifiedMetadataName, IsGenericCandidate, GetSourceGenContextOrNullForGeneric);
+      InitializeUnionSourceGen(context, options, fullyQualifiedMetadataName, GetSourceGenContextOrNullForGeneric);
    }
 
    private void InitializeNonGenericUnionSourceGen(
       IncrementalGeneratorInitializationContext context,
       IncrementalValueProvider<GeneratorOptions> options,
       string fullyQualifiedMetadataName)
    {
-      InitializeUnionSourceGen(context, options, fullyQualifiedMetadataName, IsNonGenericCandidate, GetSourceGenContextOrNullForNonGeneric);
+      InitializeUnionSourceGen(context, options, fullyQualifiedMetadataName, GetSourceGenContextOrNullForNonGeneric);
    }
 
    private void InitializeUnionSourceGen(
       IncrementalGeneratorInitializationContext context,
       IncrementalValueProvider<GeneratorOptions> options,
       string fullyQualifiedMetadataName,
-      Func<SyntaxNode, CancellationToken, bool> isCandate,
       Func<GeneratorAttributeSyntaxContext, CancellationToken, SourceGenContext?> getSourceGenContextOrNull)
    {
       var unionTypeOrError = context.SyntaxProvider
                                     .ForAttributeWithMetadataName(fullyQualifiedMetadataName,
-                                                                  isCandate,
+                                                                  IsCandidate,
                                                                   getSourceGenContextOrNull)
                                     .SelectMany(static (state, _) => state.HasValue
                                                                         ? [state.Value]
@@ -71,115 +65,39 @@ private void InitializeUnionSourceGen(
       InitializeExceptionReporting(context, unionTypeOrError);
    }
 
-   private bool IsGenericCandidate(SyntaxNode syntaxNode, CancellationToken cancellationToken)
+   private static bool IsCandidate(SyntaxNode syntaxNode, CancellationToken cancellationToken)
    {
-      try
+      return syntaxNode switch
       {
-         return syntaxNode switch
-         {
-            ClassDeclarationSyntax classDeclaration when IsUnionCandidate(classDeclaration) => true,
-            StructDeclarationSyntax structDeclaration when IsUnionCandidate(structDeclaration) => true,
-            _ => false
-         };
-      }
-      catch (Exception ex)
-      {
-         Logger.LogError("Error during checking whether a syntax node is a discriminated union candidate", exception: ex);
-         return false;
-      }
-   }
-
-   private bool IsNonGenericCandidate(SyntaxNode syntaxNode, CancellationToken cancellationToken)
-   {
-      try
-      {
-         return syntaxNode switch
-         {
-            ClassDeclarationSyntax => true,
-            StructDeclarationSyntax => true,
-            _ => false
-         };
-      }
-      catch (Exception ex)
-      {
-         Logger.LogError("Error during checking whether a syntax node is a discriminated union candidate", exception: ex);
-         return false;
-      }
-   }
-
-   private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)
-   {
-      var isCandidate = !typeDeclaration.IsGeneric();
-
-      if (isCandidate)
-      {
-         Logger.LogDebug("The type declaration is a discriminated union candidate", typeDeclaration);
-      }
-      else
-      {
-         Logger.LogTrace("The type declaration is not a discriminated union candidate", typeDeclaration);
-      }
-
-      return isCandidate;
+         ClassDeclarationSyntax classDeclaration => !classDeclaration.IsGeneric(),
+         StructDeclarationSyntax structDeclaration => !structDeclaration.IsGeneric(),
+         _ => false
+      };
    }
 
    private SourceGenContext? GetSourceGenContextOrNullForGeneric(GeneratorAttributeSyntaxContext context, CancellationToken cancellationToken)
    {
       return GetSourceGenContextOrNull(
          context,
-         (tds, data) =>
-         {
-            var attributeType = data.AttributeClass;
-
-            if (attributeType is null)
-            {
-               Logger.LogDebug("The attribute type is null", tds);
-               return null;
-            }
-
-            if (attributeType.TypeKind == TypeKind.Error)
-            {
-               Logger.LogDebug("The attribute type is erroneous", tds);
-               return null;
-            }
-
-            if (attributeType.TypeArguments.IsDefaultOrEmpty)
-               return null;
-
-            return attributeType.TypeArguments;
-         },
+         static (attributeClass, _) => attributeClass.TypeArguments.IsDefaultOrEmpty ? null : attributeClass.TypeArguments,
          cancellationToken);
    }
 
    private SourceGenContext? GetSourceGenContextOrNullForNonGeneric(GeneratorAttributeSyntaxContext context, CancellationToken cancellationToken)
    {
       return GetSourceGenContextOrNull(
          context,
-         (tds, data) =>
+         static (_, constructorArguments) =>
          {
-            var attributeType = data.AttributeClass;
-
-            if (attributeType is null)
-            {
-               Logger.LogDebug("The attribute type is null", tds);
-               return null;
-            }
-
-            if (attributeType.TypeKind == TypeKind.Error)
-            {
-               Logger.LogDebug("The attribute type is erroneous", tds);
-               return null;
-            }
-
-            if(data.ConstructorArguments.IsDefaultOrEmpty)
+            if (constructorArguments.IsDefaultOrEmpty)
                return null;
 
-            var types = new List<ITypeSymbol>();
+            var types = new List<ITypeSymbol>(constructorArguments.Length);
             var foundNull = false;
 
-            for (var i = 0; i < data.ConstructorArguments.Length; i++)
+            for (var i = 0; i < constructorArguments.Length; i++)
             {
-               var argument = data.ConstructorArguments[i];
+               var argument = constructorArguments[i];
 
                if (argument.IsNull)
                {
@@ -193,14 +111,14 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)
                types.Add(type);
             }
 
-            return types;
+            return types.Count > 0 ? types : null;
          },
          cancellationToken);
    }
 
    private SourceGenContext? GetSourceGenContextOrNull(
       GeneratorAttributeSyntaxContext context,
-      Func<TypeDeclarationSyntax, AttributeData, IReadOnlyList<ITypeSymbol>?> getMemberTypes,
+      Func<INamedTypeSymbol, ImmutableArray<TypedConstant>, IReadOnlyList<ITypeSymbol>?> getMemberTypes,
       CancellationToken cancellationToken)
    {
       var tds = (TypeDeclarationSyntax)context.TargetNode;
@@ -209,44 +127,35 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)
       {
          var type = (INamedTypeSymbol)context.TargetSymbol;
 
-         if (type.TypeKind == TypeKind.Error)
+         if (type.TypeKind == TypeKind.Error
+             || context.Attributes.IsDefaultOrEmpty
+             || context.Attributes.Length != 1)
          {
-            Logger.LogDebug("Type from semantic model is erroneous", tds);
-            return null;
-         }
-
-         if (context.Attributes.IsDefaultOrEmpty)
-            return null;
-
-         if (context.Attributes.Length > 1)
-         {
-            Logger.LogDebug($"Type has more than 1 '{Constants.Attributes.Union.NAME}'", tds);
             return null;
          }
 
          var attributeData = context.Attributes[0];
-         var memberTypeSymbols = getMemberTypes(tds, attributeData);
 
-         if (memberTypeSymbols is null)
+         if (attributeData.AttributeClass is null
+             || attributeData.AttributeClass.TypeKind == TypeKind.Error)
          {
             return null;
          }
 
-         if (memberTypeSymbols.Count < 2)
+         var memberTypeSymbols = getMemberTypes(attributeData.AttributeClass, attributeData.ConstructorArguments);
+
+         if (memberTypeSymbols is null
+             || memberTypeSymbols.Count < 2)
          {
-            Logger.LogDebug($"Expected the union to have at least 2 member types but found {memberTypeSymbols.Count}", tds);
             return null;
          }
 
          var errorMessage = AttributeInfo.TryCreate(type, out var attributeInfo);
 
          if (errorMessage is not null)
-         {
-            Logger.LogDebug(errorMessage, tds);
-            return null;
-         }
+            return new SourceGenContext(new SourceGenError(errorMessage, tds));
 
-         var factory = TypedMemberStateFactoryProvider.GetFactoryOrNull(context.SemanticModel.Compilation, Logger);
+         var factory = TypedMemberStateFactoryProvider.GetFactoryOrNull(context.SemanticModel.Compilation);
 
          if (factory is null)
             return new SourceGenContext(new SourceGenError("Could not fetch type information for code generation of a discriminated union", tds));
@@ -260,10 +169,7 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)
             var memberType = memberTypeSymbols[i];
 
             if (memberType.TypeKind == TypeKind.Error)
-            {
-               Logger.LogDebug("Type of the member is erroneous", tds);
                return null;
-            }
 
             var memberTypeSettings = settings.MemberTypeSettings[i];
             memberType = memberType.IsReferenceType && memberTypeSettings.IsNullableReferenceType ? memberType.WithNullableAnnotation(NullableAnnotation.Annotated) : memberType;
@@ -292,13 +198,15 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)
 
             if (!memberType.TryBuildMemberName(out var defaultName))
             {
-               Logger.LogError("Type of the member must be a named type or array type", tds);
-               return null;
+               return new SourceGenContext(new SourceGenError("Type of the member must be a named type or array type", tds));
             }
 
             var name = memberTypeSettings.Name ??
                        (typeDuplicateCounter == 0 ? defaultName : defaultName + typeDuplicateCounter);
 
+            if (String.IsNullOrWhiteSpace(name))
+               return null;
+
             memberTypeStates[i] = new AdHocUnionMemberTypeState(name,
                                                                 defaultName,
                                                                 typeDuplicateCounter,
@@ -311,8 +219,6 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)
                                                        settings,
                                                        attributeInfo);
 
-         Logger.LogDebug("The type declaration is a valid union", null, unionState);
-
          return new SourceGenContext(unionState);
       }
       catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)