Add method to exempt code from formatting

This change adds the preprocessor symbol DOTNET_FORMATTER to every
project in the formatted Solution.  This allows developers to exempt
code from formatting by surrounding blocks with

``` csharp
#if !DOTNET_FORMATTER
```

This should only be done on the rare occasions where insignificant white
space serves to make the code significantly more readable.  For example
in large unicode tables.  In general this feature should be avoided.

closes #37

Author: jaredpar

src/Microsoft.DotNet.CodeFormatting.Tests/Rules/CombinationTest.cs

@@ -146,5 +146,81 @@ internal void M()
             s_formattingEngine.PreprocessorConfigurations = ImmutableArray.CreateRange(new[] { new[] { "DOG" } });
             Verify(text, expected, runFormatter: false);
         }
+
+        [Fact]
+        public void TableCode()
+        {
+            var text = @"
+class C
+{
+    void G() { 
+
+    }
+
+#if !DOTNET_FORMATTER
+    void M() {
+}
+#endif 
+}";
+
+            var expected = @"
+// header
+
+internal class C
+{
+    private void G()
+    {
+    }
+
+#if !DOTNET_FORMATTER
+    void M() {
+}
+#endif 
+}";
+
+            Verify(text, expected, runFormatter: false);
+        }
+
+        /// <summary>
+        /// Make sure the code which deals with additional configurations respects the
+        /// table exception.
+        /// </summary>
+        [Fact]
+        public void TableCodeAndAdditionalConfiguration()
+        {
+            var text = @"
+class C
+{
+#if TEST
+    void G(){
+    }
+#endif
+
+#if !DOTNET_FORMATTER
+    void M() {
+}
+#endif 
+}";
+
+            var expected = @"
+// header
+
+internal class C
+{
+#if TEST
+    void G()
+    {
+    }
+#endif
+
+#if !DOTNET_FORMATTER
+    void M() {
+}
+#endif 
+}";
+
+            s_formattingEngine.PreprocessorConfigurations = ImmutableArray.CreateRange(new[] { new[] { "TEST" } });
+            Verify(text, expected, runFormatter: false);
+        }
     }
 }

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -14,12 +14,15 @@
 
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.CSharp;
 
 namespace Microsoft.DotNet.CodeFormatting
 {
     [Export(typeof(IFormattingEngine))]
     internal sealed class FormattingEngineImplementation : IFormattingEngine
     {
+        internal const string TablePreprocessorSymbolName = "DOTNET_FORMATTER";
+
         private readonly Options _options;
         private readonly IEnumerable<IFormattingFilter> _filters;
         private readonly IEnumerable<ISyntaxFormattingRule> _syntaxRules;
@@ -88,43 +91,44 @@ private async Task FormatAsync(Workspace workspace, IReadOnlyList<DocumentId> do
 
             watch.Stop();
 
-            await SaveChanges(solution, originalSolution, cancellationToken);
+            if (!workspace.TryApplyChanges(solution))
+            {
+                FormatLogger.WriteErrorLine("Unable to save changes to disk");
+            }
+
             FormatLogger.WriteLine("Total time {0}", watch.Elapsed);
         }
 
+        internal Solution AddTablePreprocessorSymbol(Solution solution)
+        {
+            var projectIds = solution.ProjectIds;
+            foreach (var projectId in projectIds)
+            {
+                var project = solution.GetProject(projectId);
+                var parseOptions = project.ParseOptions as CSharpParseOptions;
+                if (parseOptions != null)
+                {
+                    var list = new List<string>();
+                    list.AddRange(parseOptions.PreprocessorSymbolNames);
+                    list.Add(TablePreprocessorSymbolName);
+                    parseOptions = parseOptions.WithPreprocessorSymbols(list);
+                    solution = project.WithParseOptions(parseOptions).Solution;
+                }
+            }
+
+            return solution;
+        }
+
         internal async Task<Solution> FormatCoreAsync(Solution originalSolution, IReadOnlyList<DocumentId> documentIds, CancellationToken cancellationToken)
         {
             var solution = originalSolution;
+            solution = AddTablePreprocessorSymbol(originalSolution);
             solution = await RunSyntaxPass(solution, documentIds, cancellationToken);
             solution = await RunLocalSemanticPass(solution, documentIds, cancellationToken);
             solution = await RunGlobalSemanticPass(solution, documentIds, cancellationToken);
             return solution;
         }
 
-        private async Task SaveChanges(Solution solution, Solution originalSolution, CancellationToken cancellationToken)
-        {
-            foreach (var projectChange in solution.GetChanges(originalSolution).GetProjectChanges())
-            {
-                foreach (var documentId in projectChange.GetChangedDocuments())
-                {
-                    var document = solution.GetDocument(documentId);
-                    var sourceText = await document.GetTextAsync(cancellationToken);
-                    using (var file = File.Open(document.FilePath, FileMode.Truncate, FileAccess.Write))
-                    {
-                        // The encoding of the file can change during the rewrite.  Make sure to save with the
-                        // original encoding
-                        var originalDocument = originalSolution.GetDocument(documentId);
-                        var originalSourceText = await originalDocument.GetTextAsync(cancellationToken);
-
-                        using (var writer = new StreamWriter(file, originalSourceText.Encoding))
-                        {
-                            sourceText.Write(writer, cancellationToken);
-                        }
-                    }
-                }
-            }
-        }
-
         private bool ShouldBeProcessed(Document document)
         {
             foreach (var filter in _filters)

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

@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.CSharp;
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Generic;
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
@@ -35,7 +36,11 @@ public async Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxN
                 var parseOptions = (CSharpParseOptions)document.Project.ParseOptions;
                 foreach (var configuration in _options.PreprocessorConfigurations)
                 {
-                    var newParseOptions = parseOptions.WithPreprocessorSymbols(configuration);
+                    var list = new List<string>(configuration.Length + 1);
+                    list.AddRange(configuration);
+                    list.Add(FormattingEngineImplementation.TablePreprocessorSymbolName);
+
+                    var newParseOptions = parseOptions.WithPreprocessorSymbols(list);
                     document = project.WithParseOptions(newParseOptions).GetDocument(document.Id);
                     document = await Formatter.FormatAsync(document, cancellationToken: cancellationToken);
                 }