Passing a project should only use that project

When passing a project file name the formatter was still using the
resulting Workspace to drive the formatter.  In the case a project is a
part of a larger solution loading a project will load the larger
solution, not the individual project.  This means that every possible
document in the solution was processed instead of the project.

Changed the formatter to process the project only in that case.

Author: jaredpar

src/CodeFormatter/Program.cs

@@ -67,19 +67,19 @@ 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);
 
             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);
+                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/FormattingEngineImplementation.cs

@@ -3,7 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.ComponentModel.Composition;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -21,7 +23,6 @@ internal sealed class FormattingEngineImplementation : IFormattingEngine
         private readonly IEnumerable<IFormattingFilter> _filters;
         private readonly IEnumerable<IFormattingRule> _rules;
 
-
         [ImportingConstructor]
         public FormattingEngineImplementation([ImportMany] IEnumerable<IFormattingFilter> filters,
                                               [ImportMany] IEnumerable<Lazy<IFormattingRule, IOrderMetadata>> rules)
@@ -30,22 +31,44 @@ public FormattingEngineImplementation([ImportMany] IEnumerable<IFormattingFilter
             _rules = rules.OrderBy(r => r.Metadata.Order).Select(r => r.Value);
         }
 
-        public async Task<bool> RunAsync(Workspace workspace, CancellationToken cancellationToken)
+        public Task<bool> FormatSolutionAsync(Solution solution, CancellationToken cancellationToken)
+        {
+            var documentIds = solution.Projects.SelectMany(x => x.DocumentIds).ToList();
+            return FormatAsync(solution.Workspace, documentIds, cancellationToken);
+        }
+
+        public Task<bool> FormatProjectAsync(Project project, CancellationToken cancellationToken)
+        {
+            return FormatAsync(project.Solution.Workspace, project.DocumentIds, cancellationToken);
+        }
+
+        private async Task<bool> FormatAsync(Workspace workspace, IReadOnlyList<DocumentId> documentIds, CancellationToken cancellationToken)
         {
             var solution = workspace.CurrentSolution;
-            var documentIds = solution.Projects.SelectMany(p => p.DocumentIds);
             var hasChanges = false;
+            var longRuleList = new List<Tuple<string, TimeSpan>>();
 
             foreach (var id in documentIds)
             {
                 var document = solution.GetDocument(id);
                 var shouldBeProcessed = await ShouldBeProcessedAsync(document);
                 if (!shouldBeProcessed)
+                {
                     continue;
+                }
 
-                Console.WriteLine("Processing document: " + document.Name);
-                var newDocument = await RewriteDocumentAsync(document, cancellationToken);
+                longRuleList.Clear();
+                var watch = new Stopwatch();
+                watch.Start();
+                Console.Write("Processing document: " + document.Name);
+                var newDocument = await RewriteDocumentAsync(document, longRuleList, cancellationToken);
                 hasChanges |= newDocument != document;
+                watch.Stop();
+                Console.WriteLine(" {0} seconds", watch.Elapsed.TotalSeconds);
+                foreach (var tuple in longRuleList)
+                {
+                    Console.WriteLine("\t{0} {1} seconds", tuple.Item1, tuple.Item2.TotalSeconds);
+                }
 
                 solution = newDocument.Project.Solution;
             }
@@ -70,12 +93,24 @@ private async Task<bool> ShouldBeProcessedAsync(Document document)
             return true;
         }
 
-        private async Task<Document> RewriteDocumentAsync(Document document, CancellationToken cancellationToken)
+        private async Task<Document> RewriteDocumentAsync(Document document, List<Tuple<string, TimeSpan>> longRuleList, CancellationToken cancellationToken)
         {
             var docText = await document.GetTextAsync();
             var originalEncoding = docText.Encoding;
+            var watch = new Stopwatch();
             foreach (var rule in _rules)
+            {
+                watch.Start();
                 document = await rule.ProcessAsync(document, cancellationToken);
+                watch.Stop();
+                var timeSpan = watch.Elapsed;
+                if (timeSpan.TotalSeconds > 1.0)
+                {
+                    longRuleList.Add(Tuple.Create(rule.GetType().Name, timeSpan));
+                }
+
+                watch.Reset();
+            }
 
             return await ChangeEncoding(document, originalEncoding);
         }

src/Microsoft.DotNet.CodeFormatting/IFormattingEngine.cs

@@ -11,6 +11,7 @@ namespace Microsoft.DotNet.CodeFormatting
 {
     public interface IFormattingEngine
     {
-        Task<bool> RunAsync(Workspace workspace, CancellationToken cancellationToken);
+        Task<bool> FormatSolutionAsync(Solution solution, CancellationToken cancellationToken);
+        Task<bool> FormatProjectAsync(Project porject, CancellationToken cancellationToken);
     }
 }