Some work on the new idea

Author: jaredpar

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -22,13 +22,25 @@ internal sealed class FormattingEngineImplementation : IFormattingEngine
     {
         private readonly IEnumerable<IFormattingFilter> _filters;
         private readonly IEnumerable<IFormattingRule> _rules;
+        private readonly IEnumerable<ISyntaxFormattingRule> _syntaxRules;
+        private readonly IEnumerable<ILocalSemanticFormattingRule> _localSemanticRules;
+        private readonly IEnumerable<IGlobalSemanticFormattingRule> _globalSemanticRules;
+        private readonly bool _verbose;
+        private readonly Stopwatch _watch = new Stopwatch();
 
         [ImportingConstructor]
-        public FormattingEngineImplementation([ImportMany] IEnumerable<IFormattingFilter> filters,
-                                              [ImportMany] IEnumerable<Lazy<IFormattingRule, IOrderMetadata>> rules)
+        public FormattingEngineImplementation(
+            [ImportMany] IEnumerable<IFormattingFilter> filters,
+            [ImportMany] IEnumerable<Lazy<IFormattingRule, IOrderMetadata>> rules,
+            [ImportMany] IEnumerable<Lazy<ISyntaxFormattingRule, IOrderMetadata>> syntaxRules,
+            [ImportMany] IEnumerable<Lazy<ILocalSemanticFormattingRule, IOrderMetadata>> localSemanticRules,
+            [ImportMany] IEnumerable<Lazy<IGlobalSemanticFormattingRule, IOrderMetadata>> globalSemanticRules)
         {
             _filters = filters;
             _rules = rules.OrderBy(r => r.Metadata.Order).Select(r => r.Value);
+            _syntaxRules = syntaxRules.OrderBy(r => r.Metadata.Order).Select(r => r.Value);
+            _localSemanticRules = localSemanticRules.OrderBy(r => r.Metadata.Order).Select(r => r.Value);
+            _globalSemanticRules = globalSemanticRules.OrderBy(r => r.Metadata.Order).Select(r => r.Value);
         }
 
         public Task<bool> FormatSolutionAsync(Solution solution, CancellationToken cancellationToken)
@@ -115,6 +127,97 @@ private async Task<Document> RewriteDocumentAsync(Document document, List<Tuple<
             return await ChangeEncoding(document, originalEncoding);
         }
 
+        private void StartDocument(Document document)
+        {
+            Console.Write("\tProcessing {0}", document.Name);
+            _watch.Restart();
+        }
+
+        private void EndDocument()
+        {
+            _watch.Stop();
+            if (_verbose && _watch.Elapsed.TotalSeconds > 1)
+            {
+
+            }
+        }
+
+        private Task<Solution> FormatDocumentsSyntaxPass(Solution originalSolution, IReadOnlyList<DocumentId> documentIds, CancellationToken cancellationToken)
+        {
+            Console.WriteLine("Syntax Pass");
+
+            var currentSolution = originalSolution;
+            foreach (var documentId in documentIds)
+            {
+                var document = originalSolution.GetDocument(documentId);
+
+                Console.Write("\tProcessing {0}", document.Name);
+
+                watch.Restart();
+                var newRoot = await documentFunc(document);
+                watch.Stop();
+
+                if (_verbose && watch.Elapsed.TotalSeconds > 1)
+                {
+                    Console.Write(" {0} seconds", watch.Elapsed.TotalSeconds);
+                }
+                Console.WriteLine();
+
+                if (newRoot != null)
+                {
+                    currentSolution = currentSolution.WithDocumentSyntaxRoot(documentId, newRoot);
+                }
+            }
+
+            return currentSolution;
+        }
+
+        private async Task<Solution> FormatDocumentsLocalSemanticPass(Solution originalSolution, IReadOnlyList<DocumentId> documentIds, CancellationToken cancellationToken)
+        {
+            Console.WriteLine("Local Semantic Pass");
+            Func<Document, Task<SyntaxTree> documentFunc = async(documentFunc) =>
+                {
+                    var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken);
+                    if (syntaxRoot == null)
+                    {
+                        return null;
+                    }
+
+                    return FormatLocalSemantic(document, syntaxRoot);
+                };
+
+            return FormatDocumentsCore(originalSolution, documentIds, documentFunc, cancellationToken);
+        }
+
+        private async Task<Solution> FormatDocumentsCore(
+            Solution originalSolution, 
+            IReadOnlyList<DocumentId> documentIds, 
+            Func<Document, Task<SyntaxTree> documentFunc,
+            CancellationToken cancellationToken)
+        {
+        }
+
+        private Task<SyntaxTree> FormatSyntaxTree(Document document, SyntaxNode syntaxRoot)
+        {
+            foreach (var syntaxRule in _syntaxRules)
+            {
+                syntaxRoot = syntaxRule.Process(syntaxRoot);
+            }
+
+            return Task.FromResult(root);
+        }
+
+        private async Task<SyntaxTree> FormatLocalSemantic(Document originalDocument, SyntaxNode originalSyntaxRoot)
+        {
+            var currentSyntaxRoot = originalSyntaxRoot;
+            foreach (var localSemanticRule in _localSemanticRules)
+            {
+                currentSyntaxRoot = await localSemanticRule.ProcessAsync(originalDocument, originalSyntaxRoot, currentSyntaxRoot)
+            }
+
+            return currentSyntaxRoot;
+        }
+
         private async Task<Document> ChangeEncoding(Document document, Encoding encoding)
         {
             var text = await document.GetTextAsync();

src/Microsoft.DotNet.CodeFormatting/IFormattingFilter.cs

@@ -8,6 +8,7 @@
 
 namespace Microsoft.DotNet.CodeFormatting
 {
+    // TODO: does this need to be async? 
     internal interface IFormattingFilter
     {
         Task<bool> ShouldBeProcessedAsync(Document document);

src/Microsoft.DotNet.CodeFormatting/IFormattingRule.cs

@@ -9,8 +9,36 @@
 
 namespace Microsoft.DotNet.CodeFormatting
 {
+    // TODO: delete
     internal interface IFormattingRule
     {
         Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken);
     }
+
+    /// <summary>
+    /// Rules which need no semantic information and operate on parse trees only 
+    /// </summary>
+    internal interface ISyntaxFormattingRule
+    {
+        SyntaxNode Process(SyntaxNode syntaxRoot);
+    }
+
+    /// <summary>
+    /// Rules which possibly need semantic information but only operate on a 
+    /// specific document.  
+    /// </summary>
+    internal interface ILocalSemanticFormattingRule
+    {
+        Task Record(Document document, SyntaxRoot  )
+
+        Task<SyntaxNode> ProcessAsync(Document originalDocument, SyntaxNode originalSyntaxRoot, SyntaxNode currentSyntaxRoot, CancellationToken cancellationToken);
+    }
+
+    /// <summary>
+    /// Rules which can affect more than the local document
+    /// </summary>
+    internal interface IGlobalSemanticFormattingRule
+    {
+        Task<Solution> ProcessAsync(Solution solution, CancellationToken cancellationToken);
+    }
 }