Avoid NormalizeWhitespace to improve performance

NikolayPianikov · NikolayPianikov · commit b644e1cd37de · 2022-06-08T17:33:07.000+03:00
diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "teamcity.csi": {
+      "version": "1.0.4-beta5",
+      "commands": [
+        "dotnet-csi"
+      ]
+    }
+  }
+}
diff --git a/Build/Build.csproj b/Build/Build.csproj
@@ -5,6 +5,6 @@
         <Nullable>enable</Nullable>
     </PropertyGroup>
     <ItemGroup>
-        <PackageReference Include="TeamCity.CSharpInteractive" Version="1.0.4-beta3" />
+        <PackageReference Include="TeamCity.CSharpInteractive" Version="1.0.4-beta4" />
     </ItemGroup>
 </Project>
diff --git a/Immutype/Core/CommentsGenerator.cs b/Immutype/Core/CommentsGenerator.cs
@@ -48,7 +48,7 @@ where comment.StartsWith("//") && !comment.StartsWith("///")
             }
 
             lines.Add("/// <returns>The modified copy of the original instance.</returns>");
-            return target.WithLeadingTrivia(lines.Select(SyntaxFactory.Comment));
+            return target.WithLeadingTrivia(lines.SelectMany(s => new List<SyntaxTrivia>() { SyntaxFactory.CarriageReturn, SyntaxFactory.LineFeed, SyntaxFactory.Comment(s)}));
         }
         
         return target;
diff --git a/Immutype/Core/DataContainerFactory.cs b/Immutype/Core/DataContainerFactory.cs
@@ -86,7 +86,7 @@ public bool TryCreate(GenericNameSyntax genericNameSyntax, ref ExpressionSyntax?
         var elementType = genericNameSyntax.TypeArgumentList.Arguments[0];
         var newArgumentParameter = argumentParameter.WithType(
                 SyntaxFactory.ArrayType(elementType).AddRankSpecifiers(SyntaxFactory.ArrayRankSpecifier()))
-            .AddModifiers(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
+            .AddModifiers(SyntaxKind.ParamsKeyword.WithSpace());
 
         if (GenericTypeMap.TryGetValue(genericNameSyntax.Identifier.Text, out var genericTypeName))
         {
@@ -141,7 +141,7 @@ private static ExpressionSyntax CreateGenericContainer(ExpressionSyntax? express
                 SyntaxFactory.Identifier($"System.Collections.Generic.{genericTypeName}"))
             .AddTypeArgumentListArguments(elementType);
 
-        var result = SyntaxFactory.ObjectCreationExpression(genericDataType);
+        var result = SyntaxRepo.ObjectCreationExpression(genericDataType);
         return expressionSyntax != default
             ? result.AddArgumentListArguments(SyntaxFactory.Argument(expressionSyntax))
             : result.AddArgumentListArguments();
diff --git a/Immutype/Core/ExtensionsFactory.cs b/Immutype/Core/ExtensionsFactory.cs
@@ -13,7 +13,7 @@ internal class ExtensionsFactory : IUnitFactory
 {
     private static readonly UsingDirectiveSyntax[] AdditionalUsings =
     {
-        SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Collections.Generic")), SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Linq"))
+        SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Collections.Generic").WithSpace()), SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Linq").WithSpace())
     };
 
     private readonly IMethodsFactory _methodsFactory;
@@ -26,7 +26,7 @@ public IEnumerable<Source> Create(GenerationContext<TypeDeclarationSyntax> conte
         var typeDeclarationSyntax = context.Syntax;
         var ns = typeDeclarationSyntax.Ancestors()
 #if ROSLYN38
-                .OfType<NamespaceDeclarationSyntax>()
+            .OfType<NamespaceDeclarationSyntax>()
 #else
             .OfType<BaseNamespaceDeclarationSyntax>()
 #endif
@@ -42,14 +42,14 @@ public IEnumerable<Source> Create(GenerationContext<TypeDeclarationSyntax> conte
 
         var typeSyntax = SyntaxFactory.ParseName(typeName);
         var className = $"{typeDeclarationSyntax.Identifier.Text}Extensions";
-        var extensionsClass = SyntaxFactory.ClassDeclaration(className)
-            .AddModifiers(typeDeclarationSyntax.Modifiers.Where(i => !i.IsKind(SyntaxKind.ReadOnlyKeyword) && !i.IsKind(SyntaxKind.PartialKeyword)).ToArray())
-            .AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword))
-            .AddMembers(_methodsFactory.Create(context, typeSyntax, parameters).ToArray());
+        var extensionsClass = SyntaxRepo.ClassDeclaration(className)
+            .AddModifiers(typeDeclarationSyntax.Modifiers.Where(i => !i.IsKind(SyntaxKind.ReadOnlyKeyword) && !i.IsKind(SyntaxKind.PartialKeyword)).Select(i => i.WithSpace()).ToArray())
+            .AddModifiers(SyntaxKind.StaticKeyword.WithSpace(), SyntaxKind.PartialKeyword.WithSpace())
+            .AddMembers(_methodsFactory.Create(context, typeSyntax, parameters).Select(i => i.WithNewLine().WithNewLine()).ToArray());
 
         extensionsClass = TryAddAttribute(context.SemanticModel, extensionsClass, "System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage");
 
-        var code = CreateRootNode(typeDeclarationSyntax, AdditionalUsings, extensionsClass).NormalizeWhitespace().ToString();
+        var code = CreateRootNode(typeDeclarationSyntax, AdditionalUsings, extensionsClass).ToString();
         var fileName = string.Join(".", ns.Select(i => i.Name.ToString()).Concat(new[]
         {
             typeDeclarationSyntax.Identifier.Text
@@ -82,16 +82,17 @@ private static CompilationUnitSyntax CreateRootNode(SyntaxNode targetNode, Using
     private static UsingDirectiveSyntax[] GetUsings(IEnumerable<UsingDirectiveSyntax> usings, IEnumerable<UsingDirectiveSyntax> additionalUsings)
     {
         var currentUsins = usings.Select(i => i.Name.ToString()).ToImmutableHashSet();
-        return additionalUsings.Where(i => !currentUsins.Contains(i.Name.ToString())).ToArray();
+        return additionalUsings.Where(i => !currentUsins.Contains(i.Name.ToString())).Select(i => i.WithNewLine()).ToArray();
     }
 
     private static ClassDeclarationSyntax TryAddAttribute(SemanticModel semanticModel, ClassDeclarationSyntax classDeclarationSyntax, string attributeClassName)
     {
         var excludeFromCodeCoverageType = semanticModel.Compilation.GetTypeByMetadataName(attributeClassName + "Attribute");
         if (excludeFromCodeCoverageType != default)
         {
-            classDeclarationSyntax = classDeclarationSyntax
-                .AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(attributeClassName))));
+            classDeclarationSyntax = classDeclarationSyntax.WithNewLine()
+                .AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(attributeClassName))))
+                .WithNewLine();
         }
 
         return classDeclarationSyntax;
diff --git a/Immutype/Core/MethodAddRemoveFactory.cs b/Immutype/Core/MethodAddRemoveFactory.cs
@@ -37,7 +37,7 @@ public IEnumerable<MethodDeclarationSyntax> Create(GenerationContext<TypeDeclara
         }
         
         var arrayType = SyntaxFactory.ArrayType(elementType).AddRankSpecifiers(SyntaxFactory.ArrayRankSpecifier());
-        var arrayParameter = SyntaxFactory.Parameter(currentParameter.Identifier).WithType(arrayType).AddModifiers(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
+        var arrayParameter = SyntaxRepo.Parameter(currentParameter.Identifier).WithType(arrayType).AddModifiers(SyntaxKind.ParamsKeyword.WithSpace());
 
         var addArgs = CreateArguments(nameof(Enumerable.Concat), targetDeclaration, thisParameter, curParameters, currentParameter, arrayParameter);
         if (addArgs.Any())
diff --git a/Immutype/Core/MethodWithFactory.cs b/Immutype/Core/MethodWithFactory.cs
@@ -48,7 +48,7 @@ public IEnumerable<MethodDeclarationSyntax> Create(GenerationContext<TypeDeclara
         var isCollectionParam = !AreEqu(argumentParameter, newArgumentParameter) || isArrayParam;
         if (isArrayParam && argumentParameter.Modifiers.All(i => i.Kind() != SyntaxKind.ParamsKeyword))
         {
-            argumentParameter = argumentParameter.AddModifiers(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
+            argumentParameter = argumentParameter.AddModifiers(SyntaxKind.ParamsKeyword.WithSpace());
         }
         
         var variants = new List<ParameterSyntax>();
@@ -90,7 +90,7 @@ public IEnumerable<MethodDeclarationSyntax> Create(GenerationContext<TypeDeclara
                     .AddParameterListParameters(thisParameter)
                     .WithConstraintClauses(targetDeclaration.ConstraintClauses)
                     .AddBodyStatements(
-                        SyntaxFactory.ReturnStatement(
+                        SyntaxRepo.ReturnStatement(
                             SyntaxFactory.InvocationExpression(
                                 SyntaxFactory.MemberAccessExpression(
                                     SyntaxKind.SimpleMemberAccessExpression,
@@ -154,7 +154,7 @@ private ExpressionSyntax CreateWithExpression(TypeSyntax? currentParameterType,
             case ArrayTypeSyntax:
                 if (!argumentParameter.Modifiers.Any(i => i.IsKind(SyntaxKind.ParamsKeyword)))
                 {
-                    argumentParameter = argumentParameter.AddModifiers(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
+                    argumentParameter = argumentParameter.AddModifiers(SyntaxKind.ParamsKeyword.WithSpace());
                 }
 
                 break;
diff --git a/Immutype/Core/MethodsFactory.cs b/Immutype/Core/MethodsFactory.cs
@@ -15,15 +15,15 @@ public MethodsFactory(ImmutableArray<IMethodFactory> methodFactories, ISyntaxNod
     public IEnumerable<MemberDeclarationSyntax> Create(GenerationContext<TypeDeclarationSyntax> context, TypeSyntax targetType, IReadOnlyList<ParameterSyntax> parameters)
     {
         var thisParameter =
-            SyntaxFactory.Parameter(SyntaxFactory.Identifier("it"))
+            SyntaxRepo.Parameter(SyntaxFactory.Identifier("it"))
                 .WithType(targetType)
-                .AddModifiers(SyntaxFactory.Token(SyntaxKind.ThisKeyword));
+                .AddModifiers(SyntaxKind.ThisKeyword.WithSpace());
 
         if (
             context.Options is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp7_2 }
             && _syntaxNodeFactory.IsReadonlyType(context.Syntax))
         {
-            thisParameter = thisParameter.AddModifiers(SyntaxFactory.Token(SyntaxKind.InKeyword));
+            thisParameter = thisParameter.AddModifiers(SyntaxKind.InKeyword.WithSpace());
         }
 
         return
diff --git a/Immutype/Core/SyntaxNodeFactory.cs b/Immutype/Core/SyntaxNodeFactory.cs
@@ -45,16 +45,18 @@ public bool IsAccessible(IEnumerable<SyntaxToken> modifiers) =>
         !modifiers.Any(i => i.IsKind(SyntaxKind.StaticKeyword) || i.IsKind(SyntaxKind.PrivateKeyword) || i.IsKind(SyntaxKind.ProtectedKeyword));
 
     public ReturnStatementSyntax CreateReturnStatement(TypeSyntax typeSyntax, IEnumerable<ArgumentSyntax> arguments) =>
-        SyntaxFactory.ReturnStatement(
-            SyntaxFactory.ObjectCreationExpression(typeSyntax)
+        SyntaxRepo.ReturnStatement(
+            SyntaxRepo.ObjectCreationExpression(typeSyntax)
                 .AddArgumentListArguments(
-                    arguments.ToArray()));
+                    arguments.ToArray()))
+            .WithNewLine();
 
     public MethodDeclarationSyntax CreateExtensionMethod(TypeSyntax returnTypeSyntax, string name) =>
-        SyntaxFactory.MethodDeclaration(returnTypeSyntax, name)
+        SyntaxRepo.MethodDeclaration(returnTypeSyntax, name)
             .AddModifiers(
-                SyntaxFactory.Token(SyntaxKind.PublicKeyword),
-                SyntaxFactory.Token(SyntaxKind.StaticKeyword))
+                SyntaxKind.PublicKeyword.WithSpace(),
+                SyntaxKind.StaticKeyword.WithSpace())
+            .WithNewLine()
             .AddAttributeLists(
                 SyntaxFactory.AttributeList()
                     .AddAttributes(AggressiveInliningAttr, PureAttr));
@@ -88,14 +90,15 @@ public IEnumerable<StatementSyntax> CreateGuards(GenerationContext<TypeDeclarati
         yield return
             SyntaxFactory.IfStatement(
                 checkDefault,
-                SyntaxFactory.ThrowStatement(
-                    SyntaxFactory.ObjectCreationExpression(
+                SyntaxRepo.ThrowStatement(
+                    SyntaxRepo.ObjectCreationExpression(
                         SyntaxFactory.IdentifierName(
                             SyntaxFactory.Identifier("System.ArgumentNullException"))).AddArgumentListArguments(
                         SyntaxFactory.Argument(
                             SyntaxFactory.LiteralExpression(
                                 SyntaxKind.StringLiteralExpression,
-                                SyntaxFactory.Literal(parameter.Identifier.Text))))));
+                                SyntaxFactory.Literal(parameter.Identifier.Text))))))
+                .WithNewLine();
     }
 
     private static bool IsReferenceType(GenerationContext<TypeDeclarationSyntax> context, TypeSyntax type)
diff --git a/Immutype/Core/SyntaxRepo.cs b/Immutype/Core/SyntaxRepo.cs
@@ -0,0 +1,50 @@
+namespace Immutype.Core;
+
+internal static class SyntaxRepo
+{
+    public static SyntaxToken WithSpace(this SyntaxKind syntaxKind) =>
+        SyntaxFactory.Token(SyntaxFactory.TriviaList(), syntaxKind, SyntaxFactory.TriviaList(SyntaxFactory.ElasticSpace));
+    
+    public static SyntaxToken WithSpace(this SyntaxToken syntaxToken) =>
+        syntaxToken.WithLeadingTrivia(syntaxToken.LeadingTrivia.Concat(new []{SyntaxFactory.ElasticSpace}));
+
+    private static SyntaxToken WithNewLine(this SyntaxKind syntaxKind) =>
+        SyntaxFactory.Token(SyntaxFactory.TriviaList(), syntaxKind, SyntaxFactory.TriviaList(SyntaxFactory.CarriageReturn, SyntaxFactory.LineFeed));
+
+    public static TSyntax WithSpace<TSyntax>(this TSyntax node) where TSyntax : SyntaxNode => 
+        node.WithLeadingTrivia(node.GetLeadingTrivia().Concat(new []{SyntaxFactory.ElasticSpace}));
+
+    public static TSyntax WithNewLine<TSyntax>(this TSyntax node) where TSyntax : SyntaxNode =>
+        node.WithLeadingTrivia(node.GetLeadingTrivia().Concat(new []{SyntaxFactory.CarriageReturn, SyntaxFactory.LineFeed}));
+    
+    public static ExpressionStatementSyntax ExpressionStatement(ExpressionSyntax expression)
+        => SyntaxFactory.ExpressionStatement(default, expression, SyntaxKind.SemicolonToken.WithNewLine());
+    
+    public static ObjectCreationExpressionSyntax ObjectCreationExpression(TypeSyntax type, ArgumentListSyntax? argumentList = default, InitializerExpressionSyntax? initializer = default)
+        => SyntaxFactory.ObjectCreationExpression(SyntaxKind.NewKeyword.WithSpace(), type, argumentList, initializer);
+    
+#pragma warning disable RS0027
+    public static ReturnStatementSyntax ReturnStatement(ExpressionSyntax? expression = default)
+        => SyntaxFactory.ReturnStatement(default, SyntaxKind.ReturnKeyword.WithSpace(), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+#pragma warning restore RS0027
+    
+    public static ArrayCreationExpressionSyntax ArrayCreationExpression(ArrayTypeSyntax type, InitializerExpressionSyntax? initializer = default)
+        => SyntaxFactory.ArrayCreationExpression(SyntaxKind.NewKeyword.WithSpace(), type, initializer);
+    
+    public static MethodDeclarationSyntax MethodDeclaration(TypeSyntax returnType, string identifier)
+        => SyntaxFactory.MethodDeclaration(default, default, returnType, default, SyntaxFactory.Identifier(identifier).WithSpace(), default, SyntaxFactory.ParameterList(), default, default, default, default);
+    
+    public static MethodDeclarationSyntax MethodDeclaration(TypeSyntax returnType, SyntaxToken identifier)
+        => SyntaxFactory.MethodDeclaration(default, default, returnType, default, identifier.WithSpace(), default, SyntaxFactory.ParameterList(), default, default, default, default);
+    
+    public static ClassDeclarationSyntax ClassDeclaration(string identifier)
+        => SyntaxFactory.ClassDeclaration(default, default, SyntaxKind.ClassKeyword.WithSpace(), SyntaxFactory.Identifier(identifier), default, default, default, SyntaxKind.OpenBraceToken.WithNewLine(), default, SyntaxKind.CloseBraceToken.WithNewLine(), default);
+    
+    public static ParameterSyntax Parameter(SyntaxToken identifier)
+        => SyntaxFactory.Parameter(default, default, default, identifier.WithSpace(), default);
+    
+#pragma warning disable RS0027
+    public static ThrowStatementSyntax ThrowStatement(ExpressionSyntax? expression = default)
+        => SyntaxFactory.ThrowStatement(default, SyntaxKind.ThrowKeyword.WithSpace(), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+#pragma warning restore RS0027
+}

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ where comment.StartsWith("//") && !comment.StartsWith("///")`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`lines.Add("/// <returns>The modified copy of the original instance.</returns>");`
`51`		`- return target.WithLeadingTrivia(lines.Select(SyntaxFactory.Comment));`
	`51`	`+ return target.WithLeadingTrivia(lines.SelectMany(s => new List<SyntaxTrivia>() { SyntaxFactory.CarriageReturn, SyntaxFactory.LineFeed, SyntaxFactory.Comment(s)}));`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`return target;`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public IEnumerable<MethodDeclarationSyntax> Create(GenerationContext<TypeDeclara`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`var arrayType = SyntaxFactory.ArrayType(elementType).AddRankSpecifiers(SyntaxFactory.ArrayRankSpecifier());`
`40`		`- var arrayParameter = SyntaxFactory.Parameter(currentParameter.Identifier).WithType(arrayType).AddModifiers(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));`
	`40`	`+ var arrayParameter = SyntaxRepo.Parameter(currentParameter.Identifier).WithType(arrayType).AddModifiers(SyntaxKind.ParamsKeyword.WithSpace());`
`41`	`41`
`42`	`42`	`var addArgs = CreateArguments(nameof(Enumerable.Concat), targetDeclaration, thisParameter, curParameters, currentParameter, arrayParameter);`
`43`	`43`	`if (addArgs.Any())`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public IEnumerable<MethodDeclarationSyntax> Create(GenerationContext<TypeDeclara`
`48`	`48`	`var isCollectionParam = !AreEqu(argumentParameter, newArgumentParameter) \|\| isArrayParam;`
`49`	`49`	`if (isArrayParam && argumentParameter.Modifiers.All(i => i.Kind() != SyntaxKind.ParamsKeyword))`
`50`	`50`	`{`
`51`		`- argumentParameter = argumentParameter.AddModifiers(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));`
	`51`	`+ argumentParameter = argumentParameter.AddModifiers(SyntaxKind.ParamsKeyword.WithSpace());`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`var variants = new List<ParameterSyntax>();`
`@@ -90,7 +90,7 @@ public IEnumerable<MethodDeclarationSyntax> Create(GenerationContext<TypeDeclara`
`90`	`90`	`.AddParameterListParameters(thisParameter)`
`91`	`91`	`.WithConstraintClauses(targetDeclaration.ConstraintClauses)`
`92`	`92`	`.AddBodyStatements(`
`93`		`- SyntaxFactory.ReturnStatement(`
	`93`	`+ SyntaxRepo.ReturnStatement(`
`94`	`94`	`SyntaxFactory.InvocationExpression(`
`95`	`95`	`SyntaxFactory.MemberAccessExpression(`
`96`	`96`	`SyntaxKind.SimpleMemberAccessExpression,`
`@@ -154,7 +154,7 @@ private ExpressionSyntax CreateWithExpression(TypeSyntax? currentParameterType,`
`154`	`154`	`case ArrayTypeSyntax:`
`155`	`155`	`if (!argumentParameter.Modifiers.Any(i => i.IsKind(SyntaxKind.ParamsKeyword)))`
`156`	`156`	`{`
`157`		`- argumentParameter = argumentParameter.AddModifiers(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));`
	`157`	`+ argumentParameter = argumentParameter.AddModifiers(SyntaxKind.ParamsKeyword.WithSpace());`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -15,15 +15,15 @@ public MethodsFactory(ImmutableArray<IMethodFactory> methodFactories, ISyntaxNod`
`15`	`15`	`public IEnumerable<MemberDeclarationSyntax> Create(GenerationContext<TypeDeclarationSyntax> context, TypeSyntax targetType, IReadOnlyList<ParameterSyntax> parameters)`
`16`	`16`	`{`
`17`	`17`	`var thisParameter =`
`18`		`- SyntaxFactory.Parameter(SyntaxFactory.Identifier("it"))`
	`18`	`+ SyntaxRepo.Parameter(SyntaxFactory.Identifier("it"))`
`19`	`19`	`.WithType(targetType)`
`20`		`- .AddModifiers(SyntaxFactory.Token(SyntaxKind.ThisKeyword));`
	`20`	`+ .AddModifiers(SyntaxKind.ThisKeyword.WithSpace());`
`21`	`21`
`22`	`22`	`if (`
`23`	`23`	`context.Options is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp7_2 }`
`24`	`24`	`&& _syntaxNodeFactory.IsReadonlyType(context.Syntax))`
`25`	`25`	`{`
`26`		`- thisParameter = thisParameter.AddModifiers(SyntaxFactory.Token(SyntaxKind.InKeyword));`
	`26`	`+ thisParameter = thisParameter.AddModifiers(SyntaxKind.InKeyword.WithSpace());`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`return`