Convert to new rule format

jaredpar · jaredpar · commit d35b4d34ca38 · 2015-01-22T17:47:42.000-08:00
diff --git a/src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs b/src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs
@@ -21,23 +21,19 @@ namespace Microsoft.DotNet.CodeFormatting
     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,
             [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);
@@ -115,7 +111,7 @@ private void StartDocument(Document document, int depth = 1)
         private void EndDocument()
         {
             _watch.Stop();
-            if (_verbose && _watch.Elapsed.TotalSeconds > 1)
+            if (_watch.Elapsed.TotalSeconds > 1)
             {
                 Console.WriteLine(" {0} seconds", _watch.Elapsed.TotalSeconds);
             }
@@ -227,13 +223,8 @@ private async Task<Solution> RunGlobalSemanticPass(Solution solution, IReadOnlyL
                 }
 
                 StartDocument(document, depth: 2);
-                var newRoot = await globalSemanticRule.ProcessAsync(document, syntaxRoot, cancellationToken);
+                solution = await globalSemanticRule.ProcessAsync(document, syntaxRoot, cancellationToken);
                 EndDocument();
-
-                if (syntaxRoot != newRoot)
-                {
-                    solution = solution.WithDocumentSyntaxRoot(documentId, newRoot);
-                }
             }
 
             return solution;
diff --git a/src/Microsoft.DotNet.CodeFormatting/IFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/IFormattingRule.cs
@@ -16,16 +16,17 @@ internal interface IFormattingRule
     }
 
     /// <summary>
-    /// Rules which need no semantic information and operate on parse trees only 
+    /// 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.  
+    /// Rules which possibly need semantic information but only operate on a specific document.  Also
+    /// used for rules that need to see a <see cref="Document"/> and <see cref="SyntaxNode"/> which
+    /// are in sync with each other,
     /// </summary>
     internal interface ILocalSemanticFormattingRule
     {
@@ -37,6 +38,6 @@ internal interface ILocalSemanticFormattingRule
     /// </summary>
     internal interface IGlobalSemanticFormattingRule
     {
-        Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken);
+        Task<Solution> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/BraceNewLineRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/BraceNewLineRule.cs
@@ -13,19 +13,13 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.BraceNewLineRule)]
-    internal sealed class BraceNewLineRule : IFormattingRule
+    internal sealed class BraceNewLineRule : ISyntaxFormattingRule
     {
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public SyntaxNode Process(SyntaxNode syntaxNode)
         {
-            var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken);
-            if (syntaxNode == null)
-            {
-                return document;
-            }
-
             syntaxNode = FixOpenBraces(syntaxNode);
             syntaxNode = FixCloseBraces(syntaxNode);
-            return document.WithSyntaxRoot(syntaxNode);
+            return syntaxNode;
         }
 
         private static SyntaxNode FixOpenBraces(SyntaxNode syntaxNode)
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/ExplicitVisibilityRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/ExplicitVisibilityRule.cs
@@ -15,7 +15,7 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.ExplicitVisibilityRule)]
-    internal sealed class ExplicitVisibilityRule : IFormattingRule
+    internal sealed class ExplicitVisibilityRule : ILocalSemanticFormattingRule
     {
         private sealed class VisibilityRewriter : CSharpSyntaxRewriter
         {
@@ -235,17 +235,11 @@ private static MemberDeclarationSyntax EnsureVisibility<T>(T node, SyntaxTokenLi
             }
         }
 
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public 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 VisibilityRewriter(document, cancellationToken);
             var newNode = rewriter.Visit(syntaxNode);
-            return document.WithSyntaxRoot(newNode);
+            return Task.FromResult(newNode);
         }
     }
 }
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasCopyrightHeaderFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasCopyrightHeaderFormattingRule.cs
@@ -14,25 +14,20 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.HasCopyrightHeaderFormattingRule)]
-    internal sealed class HasCopyrightHeaderFormattingRule : IFormattingRule
+    internal sealed class HasCopyrightHeaderFormattingRule : ISyntaxFormattingRule
     {
         private static readonly string[] s_copyrightHeader =
         {
             "// Copyright (c) Microsoft. All rights reserved.",
             "// Licensed under the MIT license. See LICENSE file in the project root for full license information."
         };
 
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public SyntaxNode Process(SyntaxNode syntaxNode)
         {
-            var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
-            if (syntaxNode == null)
-                return document;
-
             if (HasCopyrightHeader(syntaxNode))
-                return document;
+                return syntaxNode;
 
-            var newNode = AddCopyrightHeader(syntaxNode);
-            return document.WithSyntaxRoot(newNode);
+            return AddCopyrightHeader(syntaxNode);
         }
 
         private static bool HasCopyrightHeader(SyntaxNode syntaxNode)
@@ -46,7 +41,7 @@ private static bool HasCopyrightHeader(SyntaxNode syntaxNode)
                                   .SequenceEqual(s_copyrightHeader);
         }
 
-        private static SyntaxNode AddCopyrightHeader(CSharpSyntaxNode syntaxNode)
+        private static SyntaxNode AddCopyrightHeader(SyntaxNode syntaxNode)
         {
             var newTrivia = GetCopyrightHeader().Concat(syntaxNode.GetLeadingTrivia());
             return syntaxNode.WithLeadingTrivia(newTrivia);
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasNewLineBeforeFirstNamespaceFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasNewLineBeforeFirstNamespaceFormattingRule.cs
@@ -15,19 +15,15 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.HasNewLineBeforeFirstNamespaceFormattingRule)]
-    internal sealed class HasNewLineBeforeFirstNamespaceFormattingRule : IFormattingRule
+    internal sealed class HasNewLineBeforeFirstNamespaceFormattingRule : ISyntaxFormattingRule
     {
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public SyntaxNode Process(SyntaxNode syntaxRoot)
         {
-            var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
-            if (syntaxRoot == null)
-                return document;
-
             var firstNamespace = syntaxRoot.DescendantNodesAndSelf().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();
             IEnumerable<SyntaxTrivia> newTrivia = Enumerable.Empty<SyntaxTrivia>();
 
             if (firstNamespace == null)
-                return document;
+                return syntaxRoot;
 
             if (firstNamespace.HasLeadingTrivia)
             {
@@ -52,7 +48,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca
                 newTrivia = newTrivia.AddNewLine();
             }
 
-            return document.WithSyntaxRoot(syntaxRoot.ReplaceNode(firstNamespace, firstNamespace.WithLeadingTrivia(newTrivia)));
+            return syntaxRoot.ReplaceNode(firstNamespace, firstNamespace.WithLeadingTrivia(newTrivia));
         }
 
         private IEnumerable<SyntaxTrivia> GetLeadingTriviaWithEndNewLines(IEnumerable<SyntaxTrivia> trivia)
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasNewLineBeforeFirstUsingFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasNewLineBeforeFirstUsingFormattingRule.cs
@@ -16,19 +16,15 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.HasNewLineBeforeFirstUsingFormattingRule)]
-    internal sealed class HasNewLineBeforeFirstUsingFormattingRule : IFormattingRule
+    internal sealed class HasNewLineBeforeFirstUsingFormattingRule : ISyntaxFormattingRule
     {
         private const string FormatError = "Could not format using";
 
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public SyntaxNode Process(SyntaxNode syntaxRoot)
         {
-            var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
-            if (syntaxRoot == null)
-                return document;
-
             var firstUsing = syntaxRoot.DescendantNodesAndSelf().OfType<UsingDirectiveSyntax>().FirstOrDefault();
             if (firstUsing == null)
-                return document;
+                return syntaxRoot;
 
             IEnumerable<SyntaxTrivia> newTrivia = Enumerable.Empty<SyntaxTrivia>();
 
@@ -39,9 +35,8 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca
                 var disabledUsingSpan = trivia.FirstOrDefault(t => t.CSharpKind() == SyntaxKind.DisabledTextTrivia && t.ToFullString().Contains("using")).Span;
                 if (!disabledUsingSpan.IsEmpty)
                 {
-                    var line = syntaxRoot.SyntaxTree.GetLineSpan(disabledUsingSpan, cancellationToken).StartLinePosition.Line + 1;
-                    FormatError.WriteConsoleError(line, document.Name);
-                    return document;
+                    Console.WriteLine("!!!Error with using");
+                    return syntaxRoot;
                 }
 
                 if (SyntaxKind.EndOfLineTrivia == trivia.Last().CSharpKind())
@@ -59,7 +54,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca
                 }
             }
 
-            return document.WithSyntaxRoot(syntaxRoot.ReplaceNode(firstUsing, firstUsing.WithLeadingTrivia(newTrivia)));
+            return syntaxRoot.ReplaceNode(firstUsing, firstUsing.WithLeadingTrivia(newTrivia));
         }
 
         private IEnumerable<SyntaxTrivia> GetLeadingTriviaWithEndNewLines(IEnumerable<SyntaxTrivia> trivia)
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoCustomCopyrightHeaderFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoCustomCopyrightHeaderFormattingRule.cs
@@ -16,7 +16,7 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.HasNoCustomCopyrightHeaderFormattingRule)]
-    internal sealed class HasNoCustomCopyrightHeaderFormattingRule : IFormattingRule
+    internal sealed class HasNoCustomCopyrightHeaderFormattingRule : ISyntaxFormattingRule
     {
         private static string RulerMarker { get; set; }
         private static string StartMarker { get; set; }
@@ -26,26 +26,21 @@ internal sealed class HasNoCustomCopyrightHeaderFormattingRule : IFormattingRule
 
         private const string FileSyntaxError = "There should be exactly 3 lines in CopyrightHeader.md.";
 
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public SyntaxNode Process(SyntaxNode syntaxNode)
         {
-            var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
-            if (syntaxNode == null)
-                return document;
-
             // SetHeaders
             if (!SetHeaders())
-                return document;
+                return syntaxNode;
 
             var triviaList = syntaxNode.GetLeadingTrivia();
 
             SyntaxTrivia start;
             SyntaxTrivia end;
             if (!TryGetStartAndEndOfXmlHeader(triviaList, out start, out end))
-                return document;
+                return syntaxNode;
 
             var filteredList = Filter(triviaList, start, end);
-            var newSyntaxNode = syntaxNode.WithLeadingTrivia(filteredList);
-            return document.WithSyntaxRoot(newSyntaxNode);
+            return syntaxNode.WithLeadingTrivia(filteredList);
         }
 
         private static IEnumerable<SyntaxTrivia> Filter(SyntaxTriviaList triviaList, SyntaxTrivia start, SyntaxTrivia end)
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoIllegalHeadersFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoIllegalHeadersFormattingRule.cs
@@ -16,7 +16,7 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.HasNoIllegalHeadersFormattingRule)]
-    internal sealed class HasNoIllegalHeadersFormattingRule : IFormattingRule
+    internal sealed class HasNoIllegalHeadersFormattingRule 
     {
         // We are going to replace this header with the actual filename of the document being processed
         private const string FileNameIllegalHeader = "<<<filename>>>";
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasUsingsOutsideOfNamespaceFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasUsingsOutsideOfNamespaceFormattingRule.cs
@@ -14,17 +14,15 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.HasUsingsOutsideOfNamespaceFormattingRule)]
-    internal sealed class HasUsingsOutsideOfNamespaceFormattingRule : IFormattingRule
+    internal sealed class HasUsingsOutsideOfNamespaceFormattingRule : ISyntaxFormattingRule
     {
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public SyntaxNode Process(SyntaxNode syntaxNode)
         {
-            var root = await document.GetSyntaxRootAsync(cancellationToken) as CompilationUnitSyntax;
-
+            var root = syntaxNode as CompilationUnitSyntax;
             if (root == null)
-                return document;
+                return syntaxNode;
 
             var newRoot = root;
-
             while (true)
             {
                 var namespaceWithUsings = newRoot.Members.OfType<NamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Any());
@@ -34,7 +32,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca
                 // Moving a using with an alias out of a namespace is an operation which requires
                 // semantic knowledge to get correct.
                 if (namespaceWithUsings.Usings.Any(x => x.Alias != null))
-                    return document;
+                    return syntaxNode;
 
                 // Remove nested usings
 
@@ -67,7 +65,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca
                 newRoot = newRoot.AddUsings(usings);
             }
 
-            return document.WithSyntaxRoot(newRoot);
+            return newRoot;
         }
     }
 }
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/IsFormattedFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/IsFormattedFormattingRule.cs
@@ -15,9 +15,9 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.IsFormattedFormattingRule)]
-    internal sealed class IsFormattedFormattingRule : IFormattingRule
+    internal sealed class IsFormattedFormattingRule : ILocalSemanticFormattingRule
     {
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public async Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxNode, CancellationToken cancellationToken)
         {
             var newDocument = await Formatter.FormatAsync(document, cancellationToken: cancellationToken);
             // TODO Bug 1076609: Roslyn formatter doesn't format code in #if false as it's considered as DisabledTextTrivia. Will be removed after the bug is fixed.
@@ -26,7 +26,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca
             newDocument = await newDocument.GetNewDocumentWithPreprocessorSymbols(preprocessorNames, cancellationToken);
             newDocument = await Formatter.FormatAsync(newDocument, cancellationToken: cancellationToken);
 
-            return newDocument.GetOriginalDocumentWithPreprocessorSymbols(preprocessorNames);
+            return await newDocument.GetOriginalDocumentWithPreprocessorSymbols(preprocessorNames).GetSyntaxRootAsync(cancellationToken);
         }
     }
 }
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/IsSimplifiedFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/IsSimplifiedFormattingRule.cs
@@ -19,7 +19,7 @@ namespace Microsoft.DotNet.CodeFormatting.Rules
     // 
     // I left it in because in case we want to have batch support for it in the future.
     // 
-    internal sealed class IsSimplifiedFormattingRule : IFormattingRule
+    internal sealed class IsSimplifiedFormattingRule 
     {
         public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
         {
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/NonAsciiCharactersAreEscapedInLiteralsRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/NonAsciiCharactersAreEscapedInLiteralsRule.cs
@@ -16,18 +16,11 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [RuleOrder(RuleOrder.NonAsciiChractersAreEscapedInLiterals)]
-    internal sealed class NonAsciiCharactersAreEscapedInLiterals : IFormattingRule
+    internal sealed class NonAsciiCharactersAreEscapedInLiterals : ISyntaxFormattingRule
     {
-        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public SyntaxNode Process(SyntaxNode root)
         {
-            var root = await document.GetSyntaxRootAsync(cancellationToken) as CompilationUnitSyntax;
-
-            if (root == null)
-                return document;
-
-            var newRoot = UnicodeCharacterEscapingSyntaxRewriter.Rewriter.Visit(root);
-
-            return document.WithSyntaxRoot(newRoot);
+            return UnicodeCharacterEscapingSyntaxRewriter.Rewriter.Visit(root);
         }
 
         /// <summary>
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/UsesXunitForTestsFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/UsesXunitForTestsFormattingRule.cs

Original file line number	Diff line number	Diff line change
`@@ -16,16 +16,17 @@ internal interface IFormattingRule`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`/// <summary>`
`19`		`- /// Rules which need no semantic information and operate on parse trees only`
	`19`	`+ /// Rules which need no semantic information and operate on parse trees only.`
`20`	`20`	`/// </summary>`
`21`	`21`	`internal interface ISyntaxFormattingRule`
`22`	`22`	`{`
`23`	`23`	`SyntaxNode Process(SyntaxNode syntaxRoot);`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`/// <summary>`
`27`		`- /// Rules which possibly need semantic information but only operate on a`
`28`		`- /// specific document.`
	`27`	`+ /// Rules which possibly need semantic information but only operate on a specific document. Also`
	`28`	`+ /// used for rules that need to see a <see cref="Document"/> and <see cref="SyntaxNode"/> which`
	`29`	`+ /// are in sync with each other,`
`29`	`30`	`/// </summary>`
`30`	`31`	`internal interface ILocalSemanticFormattingRule`
`31`	`32`	`{`
`@@ -37,6 +38,6 @@ internal interface ILocalSemanticFormattingRule`
`37`	`38`	`/// </summary>`
`38`	`39`	`internal interface IGlobalSemanticFormattingRule`
`39`	`40`	`{`
`40`		`- Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken);`
	`41`	`+ Task<Solution> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken);`
`41`	`42`	`}`
`42`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,19 +13,13 @@`
`13`	`13`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`14`	`14`	`{`
`15`	`15`	`[RuleOrder(RuleOrder.BraceNewLineRule)]`
`16`		`- internal sealed class BraceNewLineRule : IFormattingRule`
	`16`	`+ internal sealed class BraceNewLineRule : ISyntaxFormattingRule`
`17`	`17`	`{`
`18`		`- public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)`
	`18`	`+ public SyntaxNode Process(SyntaxNode syntaxNode)`
`19`	`19`	`{`
`20`		`- var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken);`
`21`		`- if (syntaxNode == null)`
`22`		`- {`
`23`		`- return document;`
`24`		`- }`
`25`		`-`
`26`	`20`	`syntaxNode = FixOpenBraces(syntaxNode);`
`27`	`21`	`syntaxNode = FixCloseBraces(syntaxNode);`
`28`		`- return document.WithSyntaxRoot(syntaxNode);`
	`22`	`+ return syntaxNode;`
`29`	`23`	`}`
`30`	`24`
`31`	`25`	`private static SyntaxNode FixOpenBraces(SyntaxNode syntaxNode)`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@`
`15`	`15`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`16`	`16`	`{`
`17`	`17`	`[RuleOrder(RuleOrder.ExplicitVisibilityRule)]`
`18`		`- internal sealed class ExplicitVisibilityRule : IFormattingRule`
	`18`	`+ internal sealed class ExplicitVisibilityRule : ILocalSemanticFormattingRule`
`19`	`19`	`{`
`20`	`20`	`private sealed class VisibilityRewriter : CSharpSyntaxRewriter`
`21`	`21`	`{`
`@@ -235,17 +235,11 @@ private static MemberDeclarationSyntax EnsureVisibility<T>(T node, SyntaxTokenLi`
`235`	`235`	`}`
`236`	`236`	`}`
`237`	`237`
`238`		`- public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)`
	`238`	`+ public Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxNode, CancellationToken cancellationToken)`
`239`	`239`	`{`
`240`		`- var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;`
`241`		`- if (syntaxNode == null)`
`242`		`- {`
`243`		`- return document;`
`244`		`- }`
`245`		`-`
`246`	`240`	`var rewriter = new VisibilityRewriter(document, cancellationToken);`
`247`	`241`	`var newNode = rewriter.Visit(syntaxNode);`
`248`		`- return document.WithSyntaxRoot(newNode);`
	`242`	`+ return Task.FromResult(newNode);`
`249`	`243`	`}`
`250`	`244`	`}`
`251`	`245`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,25 +14,20 @@`
`14`	`14`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`15`	`15`	`{`
`16`	`16`	`[RuleOrder(RuleOrder.HasCopyrightHeaderFormattingRule)]`
`17`		`- internal sealed class HasCopyrightHeaderFormattingRule : IFormattingRule`
	`17`	`+ internal sealed class HasCopyrightHeaderFormattingRule : ISyntaxFormattingRule`
`18`	`18`	`{`
`19`	`19`	`private static readonly string[] s_copyrightHeader =`
`20`	`20`	`{`
`21`	`21`	`"// Copyright (c) Microsoft. All rights reserved.",`
`22`	`22`	`"// Licensed under the MIT license. See LICENSE file in the project root for full license information."`
`23`	`23`	`};`
`24`	`24`
`25`		`- public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)`
	`25`	`+ public SyntaxNode Process(SyntaxNode syntaxNode)`
`26`	`26`	`{`
`27`		`- var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;`
`28`		`- if (syntaxNode == null)`
`29`		`- return document;`
`30`		`-`
`31`	`27`	`if (HasCopyrightHeader(syntaxNode))`
`32`		`- return document;`
	`28`	`+ return syntaxNode;`
`33`	`29`
`34`		`- var newNode = AddCopyrightHeader(syntaxNode);`
`35`		`- return document.WithSyntaxRoot(newNode);`
	`30`	`+ return AddCopyrightHeader(syntaxNode);`
`36`	`31`	`}`
`37`	`32`
`38`	`33`	`private static bool HasCopyrightHeader(SyntaxNode syntaxNode)`
`@@ -46,7 +41,7 @@ private static bool HasCopyrightHeader(SyntaxNode syntaxNode)`
`46`	`41`	`.SequenceEqual(s_copyrightHeader);`
`47`	`42`	`}`
`48`	`43`
`49`		`- private static SyntaxNode AddCopyrightHeader(CSharpSyntaxNode syntaxNode)`
	`44`	`+ private static SyntaxNode AddCopyrightHeader(SyntaxNode syntaxNode)`
`50`	`45`	`{`
`51`	`46`	`var newTrivia = GetCopyrightHeader().Concat(syntaxNode.GetLeadingTrivia());`
`52`	`47`	`return syntaxNode.WithLeadingTrivia(newTrivia);`
Original file line number	Diff line number	Diff line change
`@@ -15,19 +15,15 @@`
`15`	`15`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`16`	`16`	`{`
`17`	`17`	`[RuleOrder(RuleOrder.HasNewLineBeforeFirstNamespaceFormattingRule)]`
`18`		`- internal sealed class HasNewLineBeforeFirstNamespaceFormattingRule : IFormattingRule`
	`18`	`+ internal sealed class HasNewLineBeforeFirstNamespaceFormattingRule : ISyntaxFormattingRule`
`19`	`19`	`{`
`20`		`- public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)`
	`20`	`+ public SyntaxNode Process(SyntaxNode syntaxRoot)`
`21`	`21`	`{`
`22`		`- var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;`
`23`		`- if (syntaxRoot == null)`
`24`		`- return document;`
`25`		`-`
`26`	`22`	`var firstNamespace = syntaxRoot.DescendantNodesAndSelf().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();`
`27`	`23`	`IEnumerable<SyntaxTrivia> newTrivia = Enumerable.Empty<SyntaxTrivia>();`
`28`	`24`
`29`	`25`	`if (firstNamespace == null)`
`30`		`- return document;`
	`26`	`+ return syntaxRoot;`
`31`	`27`
`32`	`28`	`if (firstNamespace.HasLeadingTrivia)`
`33`	`29`	`{`
`@@ -52,7 +48,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca`
`52`	`48`	`newTrivia = newTrivia.AddNewLine();`
`53`	`49`	`}`
`54`	`50`
`55`		`- return document.WithSyntaxRoot(syntaxRoot.ReplaceNode(firstNamespace, firstNamespace.WithLeadingTrivia(newTrivia)));`
	`51`	`+ return syntaxRoot.ReplaceNode(firstNamespace, firstNamespace.WithLeadingTrivia(newTrivia));`
`56`	`52`	`}`
`57`	`53`
`58`	`54`	`private IEnumerable<SyntaxTrivia> GetLeadingTriviaWithEndNewLines(IEnumerable<SyntaxTrivia> trivia)`
Original file line number	Diff line number	Diff line change
`@@ -16,19 +16,15 @@`
`16`	`16`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`17`	`17`	`{`
`18`	`18`	`[RuleOrder(RuleOrder.HasNewLineBeforeFirstUsingFormattingRule)]`
`19`		`- internal sealed class HasNewLineBeforeFirstUsingFormattingRule : IFormattingRule`
	`19`	`+ internal sealed class HasNewLineBeforeFirstUsingFormattingRule : ISyntaxFormattingRule`
`20`	`20`	`{`
`21`	`21`	`private const string FormatError = "Could not format using";`
`22`	`22`
`23`		`- public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)`
	`23`	`+ public SyntaxNode Process(SyntaxNode syntaxRoot)`
`24`	`24`	`{`
`25`		`- var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;`
`26`		`- if (syntaxRoot == null)`
`27`		`- return document;`
`28`		`-`
`29`	`25`	`var firstUsing = syntaxRoot.DescendantNodesAndSelf().OfType<UsingDirectiveSyntax>().FirstOrDefault();`
`30`	`26`	`if (firstUsing == null)`
`31`		`- return document;`
	`27`	`+ return syntaxRoot;`
`32`	`28`
`33`	`29`	`IEnumerable<SyntaxTrivia> newTrivia = Enumerable.Empty<SyntaxTrivia>();`
`34`	`30`
`@@ -39,9 +35,8 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca`
`39`	`35`	`var disabledUsingSpan = trivia.FirstOrDefault(t => t.CSharpKind() == SyntaxKind.DisabledTextTrivia && t.ToFullString().Contains("using")).Span;`
`40`	`36`	`if (!disabledUsingSpan.IsEmpty)`
`41`	`37`	`{`
`42`		`- var line = syntaxRoot.SyntaxTree.GetLineSpan(disabledUsingSpan, cancellationToken).StartLinePosition.Line + 1;`
`43`		`- FormatError.WriteConsoleError(line, document.Name);`
`44`		`- return document;`
	`38`	`+ Console.WriteLine("!!!Error with using");`
	`39`	`+ return syntaxRoot;`
`45`	`40`	`}`
`46`	`41`
`47`	`42`	`if (SyntaxKind.EndOfLineTrivia == trivia.Last().CSharpKind())`
`@@ -59,7 +54,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca`
`59`	`54`	`}`
`60`	`55`	`}`
`61`	`56`
`62`		`- return document.WithSyntaxRoot(syntaxRoot.ReplaceNode(firstUsing, firstUsing.WithLeadingTrivia(newTrivia)));`
	`57`	`+ return syntaxRoot.ReplaceNode(firstUsing, firstUsing.WithLeadingTrivia(newTrivia));`
`63`	`58`	`}`
`64`	`59`
`65`	`60`	`private IEnumerable<SyntaxTrivia> GetLeadingTriviaWithEndNewLines(IEnumerable<SyntaxTrivia> trivia)`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`17`	`17`	`{`
`18`	`18`	`[RuleOrder(RuleOrder.HasNoIllegalHeadersFormattingRule)]`
`19`		`- internal sealed class HasNoIllegalHeadersFormattingRule : IFormattingRule`
	`19`	`+ internal sealed class HasNoIllegalHeadersFormattingRule`
`20`	`20`	`{`
`21`	`21`	`// We are going to replace this header with the actual filename of the document being processed`
`22`	`22`	`private const string FileNameIllegalHeader = "<<<filename>>>";`
Original file line number	Diff line number	Diff line change
`@@ -14,17 +14,15 @@`
`14`	`14`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`15`	`15`	`{`
`16`	`16`	`[RuleOrder(RuleOrder.HasUsingsOutsideOfNamespaceFormattingRule)]`
`17`		`- internal sealed class HasUsingsOutsideOfNamespaceFormattingRule : IFormattingRule`
	`17`	`+ internal sealed class HasUsingsOutsideOfNamespaceFormattingRule : ISyntaxFormattingRule`
`18`	`18`	`{`
`19`		`- public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)`
	`19`	`+ public SyntaxNode Process(SyntaxNode syntaxNode)`
`20`	`20`	`{`
`21`		`- var root = await document.GetSyntaxRootAsync(cancellationToken) as CompilationUnitSyntax;`
`22`		`-`
	`21`	`+ var root = syntaxNode as CompilationUnitSyntax;`
`23`	`22`	`if (root == null)`
`24`		`- return document;`
	`23`	`+ return syntaxNode;`
`25`	`24`
`26`	`25`	`var newRoot = root;`
`27`		`-`
`28`	`26`	`while (true)`
`29`	`27`	`{`
`30`	`28`	`var namespaceWithUsings = newRoot.Members.OfType<NamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Any());`
`@@ -34,7 +32,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca`
`34`	`32`	`// Moving a using with an alias out of a namespace is an operation which requires`
`35`	`33`	`// semantic knowledge to get correct.`
`36`	`34`	`if (namespaceWithUsings.Usings.Any(x => x.Alias != null))`
`37`		`- return document;`
	`35`	`+ return syntaxNode;`
`38`	`36`
`39`	`37`	`// Remove nested usings`
`40`	`38`
`@@ -67,7 +65,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca`
`67`	`65`	`newRoot = newRoot.AddUsings(usings);`
`68`	`66`	`}`
`69`	`67`
`70`		`- return document.WithSyntaxRoot(newRoot);`
	`68`	`+ return newRoot;`
`71`	`69`	`}`
`72`	`70`	`}`
`73`	`71`	`}`