Removed the old IFormattingRule

This rule is no longer needed now that we have the more specific
formatting rules in place.

Author: jaredpar

src/Microsoft.DotNet.CodeFormatting/FormattingEngine.cs

@@ -25,7 +25,9 @@ public static IFormattingEngine Create(IEnumerable<string> ruleTypes, IEnumerabl
             var filteredCatalog = new FilteredCatalog(catalog, cpd =>
             {
                 if (cpd.ExportDefinitions.Any(em =>
-                    em.ContractName == AttributedModelServices.GetContractName(typeof(IFormattingRule)) ||
+                    em.ContractName == AttributedModelServices.GetContractName(typeof(ISyntaxFormattingRule)) ||
+                    em.ContractName == AttributedModelServices.GetContractName(typeof(ILocalSemanticFormattingRule)) ||
+                    em.ContractName == AttributedModelServices.GetContractName(typeof(IGlobalSemanticFormattingRule)) ||
                     em.ContractName == AttributedModelServices.GetContractName(typeof(IFormattingFilter))))
                 {
                     object ruleType;

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

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

src/Microsoft.DotNet.CodeFormatting/IFormattingRule.cs

@@ -9,16 +9,10 @@
 
 namespace Microsoft.DotNet.CodeFormatting
 {
-    // TODO: this is a hack.  Need to delete it 
-    internal interface IFormattingRule
-    {
-
-    }
-
     /// <summary>
     /// Rules which need no semantic information and operate on parse trees only.  
     /// </summary>
-    internal interface ISyntaxFormattingRule : IFormattingRule
+    internal interface ISyntaxFormattingRule
     {
         SyntaxNode Process(SyntaxNode syntaxRoot);
     }
@@ -28,15 +22,15 @@ internal interface ISyntaxFormattingRule : IFormattingRule
     /// 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 : IFormattingRule
+    internal interface ILocalSemanticFormattingRule
     {
         Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken);
     }
 
     /// <summary>
     /// Rules which can affect more than the local document
     /// </summary>
-    internal interface IGlobalSemanticFormattingRule : IFormattingRule
+    internal interface IGlobalSemanticFormattingRule 
     {
         Task<Solution> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken);
     }

src/Microsoft.DotNet.CodeFormatting/RuleOrderAttribute.cs

@@ -13,10 +13,38 @@ namespace Microsoft.DotNet.CodeFormatting
 {
     [MetadataAttribute]
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
-    public sealed class RuleOrderAttribute : ExportAttribute
+    public sealed class SyntaxRuleOrderAttribute : ExportAttribute
     {
-        public RuleOrderAttribute(int order)
-            : base(typeof(IFormattingRule))
+        public SyntaxRuleOrderAttribute(int order)
+            : base(typeof(ISyntaxFormattingRule))
+        {
+            Order = order;
+        }
+
+        [DefaultValue(int.MaxValue)]
+        public int Order { get; private set; }
+    }
+
+    [MetadataAttribute]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public sealed class LocalSemanticRuleOrderAttribute : ExportAttribute
+    {
+        public LocalSemanticRuleOrderAttribute(int order)
+            : base(typeof(ILocalSemanticFormattingRule))
+        {
+            Order = order;
+        }
+
+        [DefaultValue(int.MaxValue)]
+        public int Order { get; private set; }
+    }
+
+    [MetadataAttribute]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public sealed class GlobalSemanticRuleOrderAttribute : ExportAttribute
+    {
+        public GlobalSemanticRuleOrderAttribute(int order)
+            : base(typeof(IGlobalSemanticFormattingRule))
         {
             Order = order;
         }

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

@@ -12,7 +12,7 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [RuleOrder(RuleOrder.BraceNewLineRule)]
+    [SyntaxRuleOrder(SyntaxRuleOrder.BraceNewLineRule)]
     internal sealed class BraceNewLineRule : ISyntaxFormattingRule
     {
         public SyntaxNode Process(SyntaxNode syntaxNode)

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

@@ -11,7 +11,7 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [RuleOrder(RuleOrder.RemoveExplicitThisRule)]
+    [LocalSemanticRuleOrder(LocalSemanticRuleOrder.RemoveExplicitThisRule)]
     public sealed class ExplicitThisRule : ILocalSemanticFormattingRule
     {
         private sealed class ExplicitThisRewriter : CSharpSyntaxRewriter

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

@@ -14,7 +14,7 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [RuleOrder(RuleOrder.ExplicitVisibilityRule)]
+    [LocalSemanticRuleOrder(LocalSemanticRuleOrder.ExplicitVisibilityRule)]
     internal sealed class ExplicitVisibilityRule : ILocalSemanticFormattingRule
     {
         private sealed class VisibilityRewriter : CSharpSyntaxRewriter

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

@@ -13,7 +13,7 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [RuleOrder(RuleOrder.HasCopyrightHeaderFormattingRule)]
+    [SyntaxRuleOrder(SyntaxRuleOrder.HasCopyrightHeaderFormattingRule)]
     internal sealed class HasCopyrightHeaderFormattingRule : ISyntaxFormattingRule
     {
         private static readonly string[] s_copyrightHeader =

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

@@ -14,7 +14,7 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [RuleOrder(RuleOrder.HasNewLineBeforeFirstNamespaceFormattingRule)]
+    [SyntaxRuleOrder(SyntaxRuleOrder.HasNewLineBeforeFirstNamespaceFormattingRule)]
     internal sealed class HasNewLineBeforeFirstNamespaceFormattingRule : ISyntaxFormattingRule
     {
         public SyntaxNode Process(SyntaxNode syntaxRoot)

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

@@ -15,7 +15,7 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [RuleOrder(RuleOrder.HasNewLineBeforeFirstUsingFormattingRule)]
+    [SyntaxRuleOrder(SyntaxRuleOrder.HasNewLineBeforeFirstUsingFormattingRule)]
     internal sealed class HasNewLineBeforeFirstUsingFormattingRule : ISyntaxFormattingRule
     {
         private const string FormatError = "Could not format using";