More changes

Author: jaredpar

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -29,14 +29,14 @@ internal sealed class FormattingEngineImplementation : IFormattingEngine
         [ImportingConstructor]
         public FormattingEngineImplementation(
             [ImportMany] IEnumerable<IFormattingFilter> filters,
-            [ImportMany] IEnumerable<Lazy<ISyntaxFormattingRule, IOrderMetadata>> syntaxRules,
-            [ImportMany] IEnumerable<Lazy<ILocalSemanticFormattingRule, IOrderMetadata>> localSemanticRules,
-            [ImportMany] IEnumerable<Lazy<IGlobalSemanticFormattingRule, IOrderMetadata>> globalSemanticRules)
+            [ImportMany] IEnumerable<Lazy<IFormattingRule, IOrderMetadata>> allRules)
         {
             _filters = filters;
-            _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);
+            var rulesSorted = allRules.OrderBy(r => r.Metadata.Order).Select(r => r.Value).ToList();
+
+            _syntaxRules = rulesSorted.OfType<ISyntaxFormattingRule>().ToList();
+            _localSemanticRules = rulesSorted.OfType<ILocalSemanticFormattingRule>().ToList();
+            _globalSemanticRules = rulesSorted.OfType<IGlobalSemanticFormattingRule>().ToList();
         }
 
         public Task FormatSolutionAsync(Solution solution, CancellationToken cancellationToken)

src/Microsoft.DotNet.CodeFormatting/IFormattingRule.cs

@@ -9,10 +9,10 @@
 
 namespace Microsoft.DotNet.CodeFormatting
 {
-    // TODO: delete
+    // TODO: this is a hack.  Need to delete it 
     internal interface IFormattingRule
     {
-        Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken);
+
     }
 
     /// <summary>

src/Microsoft.DotNet.CodeFormatting/Rules/ExplicitThisRule.cs

@@ -12,7 +12,7 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.RemoveExplicitThisRule)]
-    public sealed class ExplicitThisRule : IFormattingRule
+    public sealed class ExplicitThisRule : ILocalSemanticFormattingRule
     {
         private sealed class ExplicitThisRewriter : CSharpSyntaxRewriter
         {
@@ -66,22 +66,17 @@ private bool IsPrivateField(MemberAccessExpressionSyntax memberSyntax)
             }
         }
 
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public async Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxNode, CancellationToken cancellationToken)
         {
-            var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
-            if (syntaxNode == null)
-            {
-                return document;
-            }
-
             var rewriter = new ExplicitThisRewriter(document, cancellationToken);
             var newNode = rewriter.Visit(syntaxNode);
             if (!rewriter.AddedAnnotations)
             {
-                return document;
+                return syntaxNode;
             }
 
-            return await Simplifier.ReduceAsync(document.WithSyntaxRoot(newNode), cancellationToken: cancellationToken);
+            document = await Simplifier.ReduceAsync(document.WithSyntaxRoot(newNode), cancellationToken: cancellationToken);
+            return await document.GetSyntaxRootAsync(cancellationToken);
         }
     }
 }

src/Microsoft.DotNet.CodeFormatting/Rules/PrivateFieldNamingRule.cs

@@ -18,7 +18,7 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.PrivateFieldNamingRule)]
-    internal sealed class PrivateFieldNamingRule : IFormattingRule
+    internal sealed class PrivateFieldNamingRule : IGlobalSemanticFormattingRule
     {
         /// <summary>
         /// This will add an annotation to any private field that needs to be renamed.
@@ -159,27 +159,21 @@ public override SyntaxToken VisitToken(SyntaxToken token)
             }
         }
 
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public async Task<Solution> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken)
         {
-            var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
-            if (syntaxRoot == null)
-            {
-                return document;
-            }
-
             int count;
             var newSyntaxRoot = PrivateFieldAnnotationsRewriter.AddAnnotations(syntaxRoot, out count);
 
             if (count == 0)
             {
-                return document;
+                return document.Project.Solution;
             }
 
             var documentId = document.Id;
             var solution = document.Project.Solution;
             solution = solution.WithDocumentSyntaxRoot(documentId, newSyntaxRoot);
             solution = await RenameFields(solution, documentId, count, cancellationToken);
-            return solution.GetDocument(documentId);
+            return solution;
         }
 
         private static async Task<Solution> RenameFields(Solution solution, DocumentId documentId, int count, CancellationToken cancellationToken)