Cleaned up the output.

Author: jaredpar

src/CodeFormatter/Program.cs

@@ -68,6 +68,7 @@ private static async Task RunAsync(string projectOrSolutionPath, IEnumerable<str
         {
             var workspace = MSBuildWorkspace.Create();
             var engine = FormattingEngine.Create(ruleTypes, filenames);
+            engine.Verbose = true;
 
             string extension = Path.GetExtension(projectOrSolutionPath);
             if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".sln"))

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -25,6 +25,13 @@ internal sealed class FormattingEngineImplementation : IFormattingEngine
         private readonly IEnumerable<ILocalSemanticFormattingRule> _localSemanticRules;
         private readonly IEnumerable<IGlobalSemanticFormattingRule> _globalSemanticRules;
         private readonly Stopwatch _watch = new Stopwatch();
+        private bool _verbose;
+
+        public bool Verbose
+        {
+            get { return _verbose; }
+            set { _verbose = value; }
+        }
 
         [ImportingConstructor]
         public FormattingEngineImplementation(
@@ -103,26 +110,23 @@ private async Task<SyntaxNode> GetSyntaxRootAndFilter(Document document, Cancell
             return await document.GetSyntaxRootAsync(cancellationToken);
         }
 
-        private void StartDocument(Document document, int depth = 1)
+        private void StartDocument()
         {
-            for (int i = 0; i < depth; i++)
-            {
-                Console.Write("  ");
-            }
-
-            Console.Write("Processing {0}", document.Name);
             _watch.Restart();
         }
 
-        private void EndDocument()
+        private void EndDocument(Document document)
         {
             _watch.Stop();
-            if (_watch.Elapsed.TotalSeconds > 1)
+            if (_verbose && _watch.Elapsed.TotalSeconds > 1)
             {
-                Console.WriteLine(" {0} seconds", _watch.Elapsed.TotalSeconds);
+                Console.WriteLine();
+                Console.WriteLine("    {0} {1} seconds", document.Name, _watch.Elapsed.TotalSeconds);
+            }
+            else
+            {
+                Console.Write(".");
             }
-
-            Console.WriteLine();
         }
 
         /// <summary>
@@ -145,16 +149,17 @@ private async Task<Solution> RunSyntaxPass(Solution originalSolution, IReadOnlyL
                     continue;
                 }
 
-                StartDocument(document);
+                StartDocument();
                 var newRoot = RunSyntaxPass(syntaxRoot);
-                EndDocument();
+                EndDocument(document);
 
                 if (newRoot != syntaxRoot)
                 {
                     currentSolution = currentSolution.WithDocumentSyntaxRoot(document.Id, newRoot); 
                 }
             }
 
+            Console.WriteLine();
             return currentSolution;
         }
 
@@ -176,6 +181,7 @@ private async Task<Solution> RunLocalSemanticPass(Solution solution, IReadOnlyLi
                 solution = await RunLocalSemanticPass(solution, documentIds, localSemanticRule, cancellationToken);
             }
 
+            Console.WriteLine();
             return solution;
         }
 
@@ -192,16 +198,17 @@ private async Task<Solution> RunLocalSemanticPass(Solution originalSolution, IRe
                     continue;
                 }
 
-                StartDocument(document, depth: 2);
+                StartDocument();
                 var newRoot = await localSemanticRule.ProcessAsync(document, syntaxRoot, cancellationToken);
-                EndDocument();
+                EndDocument(document);
 
                 if (syntaxRoot != newRoot)
                 {
                     currentSolution = currentSolution.WithDocumentSyntaxRoot(documentId, newRoot);
                 }
             }
 
+            Console.WriteLine();
             return currentSolution;
         }
 
@@ -213,6 +220,7 @@ private async Task<Solution> RunGlobalSemanticPass(Solution solution, IReadOnlyL
                 solution = await RunGlobalSemanticPass(solution, documentIds, globalSemanticRule, cancellationToken);
             }
 
+            Console.WriteLine();
             return solution;
         }
 
@@ -228,11 +236,12 @@ private async Task<Solution> RunGlobalSemanticPass(Solution solution, IReadOnlyL
                     continue;
                 }
 
-                StartDocument(document, depth: 2);
+                StartDocument();
                 solution = await globalSemanticRule.ProcessAsync(document, syntaxRoot, cancellationToken);
-                EndDocument();
+                EndDocument(document);
             }
 
+            Console.WriteLine();
             return solution;
         }
     }

src/Microsoft.DotNet.CodeFormatting/IFormattingEngine.cs

@@ -11,6 +11,7 @@ namespace Microsoft.DotNet.CodeFormatting
 {
     public interface IFormattingEngine
     {
+        bool Verbose { get; set; }
         Task FormatSolutionAsync(Solution solution, CancellationToken cancellationToken);
         Task FormatProjectAsync(Project porject, CancellationToken cancellationToken);
     }