Merge pull request #34 from jaredpar/perf-work

Performance Work

Author: jaredpar

src/CodeFormatter/Program.cs

@@ -67,19 +67,21 @@ private static int Main(string[] args)
         private static async Task RunAsync(string projectOrSolutionPath, IEnumerable<string> ruleTypes, IEnumerable<string> filenames, CancellationToken cancellationToken)
         {
             var workspace = MSBuildWorkspace.Create();
+            var engine = FormattingEngine.Create(ruleTypes, filenames);
+            engine.Verbose = true;
 
             string extension = Path.GetExtension(projectOrSolutionPath);
             if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".sln"))
             {
-                await workspace.OpenSolutionAsync(projectOrSolutionPath, cancellationToken);
+                var solution = await workspace.OpenSolutionAsync(projectOrSolutionPath, cancellationToken);
+                await engine.FormatSolutionAsync(solution, cancellationToken);
             }
             else
             {
-                await workspace.OpenProjectAsync(projectOrSolutionPath, cancellationToken);
+                workspace.LoadMetadataForReferencedProjects = true;
+                var project = await workspace.OpenProjectAsync(projectOrSolutionPath, cancellationToken);
+                await engine.FormatProjectAsync(project, cancellationToken);
             }
-
-            var engine = FormattingEngine.Create(ruleTypes, filenames);
-            await engine.RunAsync(workspace, cancellationToken);
         }
     }
 }

src/Microsoft.DotNet.CodeFormatting.Tests/CodeFormattingTestBase.cs

@@ -8,6 +8,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.DotNet.CodeFormatting;
 using Xunit;
@@ -25,13 +26,6 @@ public abstract class CodeFormattingTestBase
         private const string VBFileExtension = ".vb";
         private const string TestProjectName = "TestProject";
 
-        internal abstract IFormattingRule GetFormattingRule();
-
-        internal static IFormattingRule GetDefaultVSFormatter()
-        {
-            return new Rules.IsFormattedFormattingRule();
-        }
-
         protected virtual IEnumerable<MetadataReference> GetSolutionMetadataReferences()
         {
             yield return s_CorlibReference;
@@ -55,34 +49,32 @@ private Solution CreateSolution(string[] sources, string language = LanguageName
                 var fileName = FileNamePrefix + count + fileExtension;
                 var documentId = DocumentId.CreateNewId(projectId, fileName);
                 solution = solution.AddDocument(documentId, fileName, SourceText.From(source));
+                count++;
             }
 
             return solution;
         }
 
-        private static async Task<Solution> Format(Solution solution, IFormattingRule rule, bool runFormatter)
+        private async Task<Solution> Format(Solution solution, bool runFormatter)
         {
             var documentIds = solution.Projects.SelectMany(p => p.DocumentIds);
 
             foreach (var id in documentIds)
             {
                 var document = solution.GetDocument(id);
-                var newDocument = await RewriteDocumentAsync(document, rule, runFormatter);
-                solution = newDocument.Project.Solution;
+                document = await RewriteDocumentAsync(document);
+                if (runFormatter)
+                {
+                    document = await Formatter.FormatAsync(document);
+                }
+
+                solution = document.Project.Solution;
             }
 
             return solution;
         }
 
-        private static async Task<Document> RewriteDocumentAsync(Document document, IFormattingRule rule, bool runFormatter)
-        {
-            document = await rule.ProcessAsync(document, CancellationToken.None);
-            if (runFormatter)
-                return await GetDefaultVSFormatter().ProcessAsync(document, CancellationToken.None);
-            return document;
-        }
-
-        private static void AssertSolutionEqual(Solution expectedSolution, Solution actualSolution)
+        private void AssertSolutionEqual(Solution expectedSolution, Solution actualSolution)
         {
             var expectedDocuments = expectedSolution.Projects.SelectMany(p => p.Documents);
             var actualDocuments = actualSolution.Projects.SelectMany(p => p.Documents);
@@ -99,26 +91,67 @@ private static void AssertSolutionEqual(Solution expectedSolution, Solution actu
             }
         }
 
-        private void Verify(string[] sources, string[] expected, IFormattingRule rule, bool runFormatter)
+        protected abstract Task<Document> RewriteDocumentAsync(Document document);
+
+        protected void Verify(string[] sources, string[] expected, bool runFormatter)
         {
             var inputSolution = CreateSolution(sources);
             var expectedSolution = CreateSolution(expected);
-            var actualSolution = Format(inputSolution, rule, runFormatter).Result;
+            var actualSolution = Format(inputSolution, runFormatter).Result;
 
             if (actualSolution == null)
                 Assert.False(true, "Solution is null. Test Failed.");
 
             AssertSolutionEqual(expectedSolution, actualSolution);
         }
 
-        protected void Verify(string[] source, string[] expected, bool runFormatter)
+        protected void Verify(string source, string expected, bool runFormatter = true)
         {
-            Verify(source, expected, GetFormattingRule(), runFormatter);
+            Verify(new string[] { source }, new string[] { expected }, runFormatter);
         }
+    }
 
-        protected void Verify(string source, string expected, bool runFormatter = true)
+    public abstract class SyntaxRuleTestBase : CodeFormattingTestBase
+    {
+        internal abstract ISyntaxFormattingRule Rule
         {
-            Verify(new string[] { source }, new string[] { expected }, runFormatter);
+            get;
+        }
+
+        protected override async Task<Document> RewriteDocumentAsync(Document document)
+        {
+            var syntaxRoot = await document.GetSyntaxRootAsync();
+            syntaxRoot = Rule.Process(syntaxRoot);
+            return document.WithSyntaxRoot(syntaxRoot);
+        }
+    }
+
+    public abstract class LocalSemanticRuleTestBase : CodeFormattingTestBase
+    {
+        internal abstract ILocalSemanticFormattingRule Rule
+        {
+            get;
+        }
+
+        protected override async Task<Document> RewriteDocumentAsync(Document document)
+        {
+            var syntaxRoot = await document.GetSyntaxRootAsync();
+            syntaxRoot = await Rule.ProcessAsync(document, syntaxRoot, CancellationToken.None);
+            return document.WithSyntaxRoot(syntaxRoot);
+        }
+    }
+
+    public abstract class GlobalSemanticRuleTestBase : CodeFormattingTestBase
+    {
+        internal abstract IGlobalSemanticFormattingRule Rule
+        {
+            get;
+        }
+
+        protected override async Task<Document> RewriteDocumentAsync(Document document)
+        {
+            var solution = await Rule.ProcessAsync(document, await document.GetSyntaxRootAsync(), CancellationToken.None);
+            return solution.GetDocument(document.Id);
         }
     }
 }

src/Microsoft.DotNet.CodeFormatting.Tests/Microsoft.DotNet.CodeFormatting.Tests.csproj

@@ -105,13 +105,13 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CodeFormattingTestBase.cs" />
+    <Compile Include="Rules\BracesRuleTests.cs" />
+    <Compile Include="Rules\CombinationTest.cs" />
     <Compile Include="Rules\ExplicitThisRuleTests.cs" />
     <Compile Include="Rules\ExplicitVisibilityRuleTests.cs" />
     <Compile Include="Rules\HasNewLineBeforeFirstNamespaceFormattingRuleTests.cs" />
     <Compile Include="Rules\HasNoIllegalHeadersFormattingRuleTests.cs" />
     <Compile Include="Rules\HasNewLineBeforeFirstUsingFormattingRuleTests.cs" />
-    <Compile Include="Rules\HasNoNewLineAfterOpenBraceFormattingRuleTests.cs" />
-    <Compile Include="Rules\HasNoNewLineBeforeEndBraceFormattingRuleTests.cs" />
     <Compile Include="Rules\PrivateFieldNamingRuleTests.cs" />
     <Compile Include="Rules\NonAsciiCharactersAreEscapedInLiteralsRuleTests.cs" />
     <Compile Include="Rules\UsesXunitForTestsFormattingRuleTests.cs" />