Begin support for VB.Net

This commit sets the stage for adding VB.Net support into the code
formatter by allowing rules to partition their support based on the
language in question.

This is the start of getting issue #55 implemented.

Author: jaredpar

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -150,6 +150,16 @@ private Task<SyntaxNode> GetSyntaxRootAndFilter(Document document, CancellationT
             return document.GetSyntaxRootAsync(cancellationToken);
         }
 
+        private Task<SyntaxNode> GetSyntaxRootAndFilter(IFormattingRule formattingRule, Document document, CancellationToken cancellationToken)
+        {
+            if (!formattingRule.SupportsLanguage(document.Project.Language))
+            {
+                return Task.FromResult<SyntaxNode>(null);
+            }
+
+            return GetSyntaxRootAndFilter(formattingRule, document, cancellationToken);
+        }
+
         private void StartDocument()
         {
             _watch.Restart();
@@ -182,7 +192,7 @@ private async Task<Solution> RunSyntaxPass(Solution originalSolution, IReadOnlyL
                 }
 
                 StartDocument();
-                var newRoot = RunSyntaxPass(syntaxRoot);
+                var newRoot = RunSyntaxPass(syntaxRoot, document.Project.Language);
                 EndDocument(document);
 
                 if (newRoot != syntaxRoot)
@@ -194,11 +204,14 @@ private async Task<Solution> RunSyntaxPass(Solution originalSolution, IReadOnlyL
             return currentSolution;
         }
 
-        private SyntaxNode RunSyntaxPass(SyntaxNode root)
+        private SyntaxNode RunSyntaxPass(SyntaxNode root, string langaugeName)
         {
             foreach (var rule in _syntaxRules)
             {
-                root = rule.Process(root);
+                if (rule.SupportsLanguage(langaugeName))
+                {
+                    root = rule.Process(root);
+                }
             }
 
             return root;
@@ -222,7 +235,7 @@ private async Task<Solution> RunLocalSemanticPass(Solution originalSolution, IRe
             foreach (var documentId in documentIds)
             {
                 var document = originalSolution.GetDocument(documentId);
-                var syntaxRoot = await GetSyntaxRootAndFilter(document, cancellationToken);
+                var syntaxRoot = await GetSyntaxRootAndFilter(localSemanticRule, document, cancellationToken);
                 if (syntaxRoot == null)
                 {
                     continue;
@@ -258,7 +271,7 @@ private async Task<Solution> RunGlobalSemanticPass(Solution solution, IReadOnlyL
             foreach (var documentId in documentIds)
             {
                 var document = solution.GetDocument(documentId);
-                var syntaxRoot = await GetSyntaxRootAndFilter(document, cancellationToken);
+                var syntaxRoot = await GetSyntaxRootAndFilter(globalSemanticRule, document, cancellationToken);
                 if (syntaxRoot == null)
                 {
                     continue;

src/Microsoft.DotNet.CodeFormatting/IFormattingRule.cs

@@ -9,10 +9,18 @@
 
 namespace Microsoft.DotNet.CodeFormatting
 {
+    /// <summary>
+    /// Base formatting rule which helps establish which language the rule applies to.
+    /// </summary>
+    internal interface IFormattingRule
+    {
+        bool SupportsLanguage(string languageName);
+    }
+
     /// <summary>
     /// Rules which need no semantic information and operate on parse trees only.  
     /// </summary>
-    internal interface ISyntaxFormattingRule
+    internal interface ISyntaxFormattingRule : IFormattingRule
     {
         SyntaxNode Process(SyntaxNode syntaxRoot);
     }
@@ -22,15 +30,15 @@ internal interface ISyntaxFormattingRule
     /// 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
+    internal interface ILocalSemanticFormattingRule : IFormattingRule
     {
         Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken);
     }
 
     /// <summary>
     /// Rules which can affect more than the local document
     /// </summary>
-    internal interface IGlobalSemanticFormattingRule 
+    internal interface IGlobalSemanticFormattingRule : IFormattingRule
     {
         Task<Solution> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken);
     }

src/Microsoft.DotNet.CodeFormatting/Microsoft.DotNet.CodeFormatting.csproj

@@ -87,6 +87,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="IOrderMetadata.cs" />
     <Compile Include="Rules\BraceNewLineRule.cs" />
+    <Compile Include="Rules\CSharpOnlyFormattingRule.cs" />
     <Compile Include="Rules\ExplicitVisibilityRule.cs" />
     <Compile Include="Rules\HasCopyrightHeaderFormattingRule.cs" />
     <Compile Include="Rules\HasNewLineBeforeFirstNamespaceFormattingRule.cs" />

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

@@ -14,7 +14,7 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [SyntaxRuleOrder(SyntaxRuleOrder.BraceNewLineRule)]
-    internal sealed class BraceNewLineRule : ISyntaxFormattingRule
+    internal sealed class BraceNewLineRule : CSharpOnlyFormattingRule, ISyntaxFormattingRule
     {
         private enum NewLineKind
         {

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

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.CodeAnalysis;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.CodeFormatting.Rules
+{
+    internal class CSharpOnlyFormattingRule : IFormattingRule
+    {
+        protected CSharpOnlyFormattingRule()
+        {
+        }
+
+        public bool SupportsLanguage(string languageName)
+        {
+            return languageName == LanguageNames.CSharp;
+        }
+    }
+}

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

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

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

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

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

@@ -16,7 +16,7 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [LocalSemanticRuleOrder(LocalSemanticRuleOrder.IsFormattedFormattingRule)]
-    internal sealed class FormatDocumentFormattingRule : ILocalSemanticFormattingRule
+    internal sealed class FormatDocumentFormattingRule : CSharpOnlyFormattingRule, ILocalSemanticFormattingRule
     {
         private readonly Options _options;
 

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

@@ -14,7 +14,7 @@
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [SyntaxRuleOrder(SyntaxRuleOrder.HasCopyrightHeaderFormattingRule)]
-    internal sealed class HasCopyrightHeaderFormattingRule : ISyntaxFormattingRule
+    internal sealed class HasCopyrightHeaderFormattingRule : CSharpOnlyFormattingRule, ISyntaxFormattingRule
     {
         private readonly Options _options;
 

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

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