removing warnings and simplifying code

Author: datacute

IncrementalGeneratorExtensions.Content/Datacute/IncrementalGeneratorExtensions/AttributeContextAndData.cs

@@ -5,13 +5,14 @@
 #if DATACUTE_EXCLUDE_EQUATABLEIMMUTABLEARRAY
 #error AttributeContextAndData requires EquatableImmutableArray (remove DATACUTE_EXCLUDE_EQUATABLEIMMUTABLEARRAY or also exclude DATACUTE_EXCLUDE_ATTRIBUTECONTEXTANDDATA)
 #endif
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Text;
 using System.Threading;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Datacute.IncrementalGeneratorExtensions
 {
@@ -79,25 +80,25 @@ public AttributeContextAndData(
         }
 
         /// <inheritdoc />
-        public bool Equals(AttributeContextAndData<T> other)
-        {
-            return Context.Equals(other.Context) && Equals(ContainingTypes, other.ContainingTypes) && AttributeData.Equals(other.AttributeData);
-        }
+        public bool Equals(AttributeContextAndData<T> other) => 
+            Context.Equals(other.Context) && 
+            Equals(ContainingTypes, other.ContainingTypes) &&
+            EqualityComparer<T>.Default.Equals(AttributeData, other.AttributeData) &&
+            IsInFileScopedNamespace == other.IsInFileScopedNamespace;
 
         /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            return obj is AttributeContextAndData<T> other && Equals(other);
-        }
+        public override bool Equals(object obj) => 
+            obj is AttributeContextAndData<T> other && Equals(other);
 
         /// <inheritdoc />
         public override int GetHashCode()
         {
             unchecked
             {
                 var hashCode = Context.GetHashCode();
-                hashCode = (hashCode * 397) ^ (ContainingTypes != null ? ContainingTypes.GetHashCode() : 0);
-                hashCode = (hashCode * 397) ^ (AttributeData != null ? AttributeData.GetHashCode() : 0);
+                hashCode = (hashCode * 397) ^ ContainingTypes.GetHashCode();
+                hashCode = (hashCode * 397) ^ EqualityComparer<T>.Default.GetHashCode(AttributeData);
+                hashCode = (hashCode * 397) ^ (IsInFileScopedNamespace ? 1 : 0);
                 return hashCode;
             }
         }
@@ -155,11 +156,11 @@ public static bool Predicate(SyntaxNode syntaxNode, CancellationToken token)
             LightweightTrace.IncrementCount(GeneratorStage.ForAttributeWithMetadataNamePredicate);
 #endif
             // We are only interested in partial type declarations
-            var typeDeclaration = syntaxNode as TypeDeclarationSyntax;
-            if (typeDeclaration == null || !typeDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword))
-            {
-                return false;
-            }
+            if (!(syntaxNode is TypeDeclarationSyntax typeDeclaration))
+                return false; // Not a type declaration
+
+            if (!typeDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword))
+                return false; // Must be partial
 
             // Now, ensure all containing types are also partial.
             // This is necessary to be able to generate code for partial types correctly.
@@ -213,19 +214,8 @@ public static AttributeContextAndData<T> Transform(
             var attributeTargetSymbol = (ITypeSymbol)generatorAttributeSyntaxContext.TargetSymbol;
             var typeDeclaration = (TypeDeclarationSyntax)generatorAttributeSyntaxContext.TargetNode;
 
-            var isInFileScopedNamespace = false;
-            if (typeDeclaration.SyntaxTree.GetRoot(token) is CompilationUnitSyntax compilationUnit)
-            {
-                foreach (var member in compilationUnit.Members)
-                {
-                    if (member.GetType().Name == "FileScopedNamespaceDeclarationSyntax")
-                    {
-                        isInFileScopedNamespace = true;
-                        break;
-                    }
-                }
-            }
-            
+            var isInFileScopedNamespace = HasFileScopedNamespace(typeDeclaration.SyntaxTree, token);
+
             var isNullableContextEnabled = GetIsNullableContextEnabled(generatorAttributeSyntaxContext.SemanticModel, typeDeclaration.SpanStart);
 
             EquatableImmutableArray<string> typeParameterNames;
@@ -241,16 +231,7 @@ public static AttributeContextAndData<T> Transform(
                 typeParameterNames = EquatableImmutableArray<string>.Empty;
             }
 
-            var typeContext = new TypeContext(
-                TypeContext.GetNamespaceDisplayString(attributeTargetSymbol.ContainingNamespace),
-                attributeTargetSymbol.Name,
-                attributeTargetSymbol.IsStatic,
-                isPartial: true, // Known to be true because of the predicate
-                attributeTargetSymbol.IsAbstract,
-                attributeTargetSymbol.IsSealed,
-                attributeTargetSymbol.DeclaredAccessibility,
-                TypeContext.GetTypeDeclarationKeyword(attributeTargetSymbol),
-                typeParameterNames);
+            var typeContext = CreateTypeContext(attributeTargetSymbol, isPartial: true, typeParameterNames);
 
             // Parse parent classes from symbol's containing types
             var parentClassCount = 0;
@@ -275,18 +256,9 @@ public static AttributeContextAndData<T> Transform(
                         : EquatableImmutableArray<string>.Empty;
 
                     // The predicate has already confirmed that this type is partial.
-                    var containingTypeIsPartial = true;
-
-                    containingTypesImmutableArrayBuilder.Insert(0, new TypeContext(
-                        TypeContext.GetNamespaceDisplayString(containingType.ContainingNamespace),
-                        containingType.Name, 
-                        containingType.IsStatic,
-                        containingTypeIsPartial,
-                        containingType.IsAbstract,
-                        containingType.IsSealed,
-                        containingType.DeclaredAccessibility,
-                        TypeContext.GetTypeDeclarationKeyword(containingType),
-                        containingTypeTypeParameterNames));
+                    const bool containingTypeIsPartial = true;
+                    var containingTypeContext = CreateTypeContext(containingType, containingTypeIsPartial, containingTypeTypeParameterNames);
+                    containingTypesImmutableArrayBuilder.Insert(0, containingTypeContext);
                     containingType = containingType.ContainingType;
                 }
 
@@ -297,19 +269,48 @@ public static AttributeContextAndData<T> Transform(
                 containingTypes = EquatableImmutableArray<TypeContext>.Empty;
             }
 
-            var attributeContextAndData = new AttributeContextAndData<T>(
+            return new AttributeContextAndData<T>(
                 typeContext,
                 containingTypes,
                 attributeData,
                 isInFileScopedNamespace,
                 isNullableContextEnabled);
+        }
+        private static TypeContext CreateTypeContext(
+            ITypeSymbol symbol,
+            bool isPartial,
+            EquatableImmutableArray<string> typeParameterNames)
+        {
+            return new TypeContext(
+                TypeContext.GetNamespaceDisplayString(symbol.ContainingNamespace),
+                symbol.Name,
+                symbol.IsStatic,
+                isPartial,
+                symbol.IsAbstract,
+                symbol.IsSealed,
+                symbol.DeclaredAccessibility,
+                TypeContext.GetTypeDeclarationKeyword(symbol),
+                typeParameterNames);
+        }
 
-            return attributeContextAndData;
+        private static bool HasFileScopedNamespace(SyntaxTree syntaxTree, CancellationToken token)
+        {
+            if (!(syntaxTree.GetRoot(token) is CompilationUnitSyntax root))
+                return false;
+
+            foreach (var member in root.Members)
+            {
+                if (member.GetType().Name == "FileScopedNamespaceDeclarationSyntax")
+                    return true;
+            }
+
+            return false;
         }
-        
-        
+
         // This delegate is initialized to point to the bootstrap method. 
         // After the first run, it will point to the final, efficient implementation.
+        // ReSharper disable once StaticMemberInGenericType There's typically only one instance.
+        // ReSharper disable once InconsistentNaming purposely named like a method
         private static Func<SemanticModel, int, bool> GetIsNullableContextEnabled = BootstrapGetIsNullableContextEnabled;
 
         private static bool BootstrapGetIsNullableContextEnabled(SemanticModel semanticModel, int position)

IncrementalGeneratorExtensions.Content/Datacute/IncrementalGeneratorExtensions/IndentingLineAppender.cs

@@ -25,8 +25,8 @@ public class IndentingLineAppender
         private string _currentIndentString = string.Empty;
 
         private readonly StringBuilder _buffer;
-        private char _indentationCharacter;
-        private int _indentationCharacterRepetition;
+        private readonly char _indentationCharacter;
+        private readonly int _indentationCharacterRepetition;
         private readonly string _blockStart;
         private readonly string _blockEnd;
         private readonly Dictionary<int, string> _indentationCache = new Dictionary<int, string>();
@@ -49,6 +49,9 @@ public int IndentLevel
             }
         }
 
+        private void IncreaseIndent() { IndentLevel = _indentLevel + 1; }
+        private void DecreaseIndent() { IndentLevel = _indentLevel - 1; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="IndentingLineAppender"/> class with a default <see cref="StringBuilder"/>.
         /// </summary>
@@ -95,6 +98,8 @@ public IndentingLineAppender(
             _blockEnd = blockEnd;
 
             SingleIndent = new string(_indentationCharacter, _indentationCharacterRepetition);
+            _indentationCache.Add(0, string.Empty);
+            _indentationCache.Add(1, SingleIndent);
         }
 
         /// <summary>
@@ -128,8 +133,7 @@ public string StringForIndent(int indent)
         public IndentingLineAppender Clear()
         {
             _buffer.Clear();
-            _indentLevel = 0;
-            _currentIndentString = string.Empty;
+            IndentLevel = 0;
             return this;
         }
 
@@ -201,8 +205,7 @@ public IndentingLineAppender Append(char c)
         public IndentingLineAppender AppendStartBlock()
         {
             AppendLine(_blockStart);
-            _indentLevel++;
-            UpdateCurrentIndent();
+            IncreaseIndent();
             return this;
         }
 
@@ -220,8 +223,7 @@ public IndentingLineAppender AppendStartBlock()
         /// <returns>Returns the current instance for method chaining.</returns>
         public IndentingLineAppender AppendEndBlock()
         {
-            _indentLevel--;
-            UpdateCurrentIndent();
+            DecreaseIndent();
             AppendLine(_blockEnd);
             return this;
         }