Straw man design for preprocessor directives

This is a straw man design for the problem being discussed in issue #38.
Essentially let the developer specify on the command line what
configurations they want the code to be formatted under.  This is much
safer than assuming all configurations in the file are valid.

Author: jaredpar

src/CodeFormatter/Program.cs

@@ -37,6 +37,7 @@ private static int Main(string[] args)
             var filenames = new List<string>();
             var disableCopyright = false;
             var comparer = StringComparer.OrdinalIgnoreCase;
+            var preprocessorConfigurations = new List<string[]>();
 
             for (int i = 1; i < args.Length; i++)
             {
@@ -54,6 +55,12 @@ private static int Main(string[] args)
                 {
                     disableCopyright = true;
                 }
+                else if (arg.StartsWith("/c:", StringComparison.OrdinalIgnoreCase))
+                {
+                    var all = arg.Substring(3);
+                    var configs = all.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+                    preprocessorConfigurations.Add(configs);
+                }
                 else
                 {
                     ruleTypes.Add(arg);
@@ -65,16 +72,18 @@ private static int Main(string[] args)
 
             Console.CancelKeyPress += delegate { cts.Cancel(); };
 
-            RunAsync(projectOrSolutionPath, ruleTypes, filenames, disableCopyright, ct).Wait(ct);
+            RunAsync(projectOrSolutionPath, ruleTypes, filenames, disableCopyright, ImmutableArray.CreateRange(preprocessorConfigurations), ct).Wait(ct);
             Console.WriteLine("Completed formatting.");
             return 0;
         }
 
-        private static async Task RunAsync(string projectOrSolutionPath, IEnumerable<string> ruleTypes, IEnumerable<string> filenames, bool disableCopright, CancellationToken cancellationToken)
+        private static async Task RunAsync(string projectOrSolutionPath, IEnumerable<string> ruleTypes, IEnumerable<string> filenames, bool disableCopright, ImmutableArray<string[]> preprocessorConfigurations, CancellationToken cancellationToken)
         {
             var workspace = MSBuildWorkspace.Create();
             var engine = FormattingEngine.Create(ruleTypes, filenames);
             engine.Verbose = true;
+            engine.PreprocessorConfigurations = preprocessorConfigurations;
+
             if (disableCopright)
             {
                 engine.CopyrightHeader = ImmutableArray<string>.Empty;

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -34,6 +34,12 @@ public ImmutableArray<string> CopyrightHeader
             set { _options.CopyrightHeader = value; }
         }
 
+        public ImmutableArray<string[]> PreprocessorConfigurations
+        {
+            get { return _options.PreprocessorConfigurations; }
+            set { _options.PreprocessorConfigurations = value; }
+        }
+
         public IFormatLogger FormatLogger
         {
             get { return _options.FormatLogger; }

src/Microsoft.DotNet.CodeFormatting/IFormattingEngine.cs

@@ -13,7 +13,9 @@ namespace Microsoft.DotNet.CodeFormatting
     public interface IFormattingEngine
     {
         ImmutableArray<string> CopyrightHeader { get; set; }
+        ImmutableArray<string[]> PreprocessorConfigurations { get; set; }
         bool Verbose { get; set; }
+        
         Task FormatSolutionAsync(Solution solution, CancellationToken cancellationToken);
         Task FormatProjectAsync(Project porject, CancellationToken cancellationToken);
     }

src/Microsoft.DotNet.CodeFormatting/Options.cs

@@ -21,12 +21,14 @@ internal sealed class Options
         };
 
         internal ImmutableArray<string> CopyrightHeader { get; set; }
+        internal ImmutableArray<string[]> PreprocessorConfigurations { get; set; }
         internal IFormatLogger FormatLogger { get; set; }
 
         [ImportingConstructor]
         internal Options()
         {
             CopyrightHeader = ImmutableArray.Create(s_defaultCopyrightHeader);
+            PreprocessorConfigurations = ImmutableArray<string[]>.Empty;
             FormatLogger = new ConsoleFormatLogger();
         }
     }

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

@@ -17,16 +17,31 @@ namespace Microsoft.DotNet.CodeFormatting.Rules
     [LocalSemanticRuleOrder(LocalSemanticRuleOrder.IsFormattedFormattingRule)]
     internal sealed class IsFormattedFormattingRule : ILocalSemanticFormattingRule
     {
+        private readonly Options _options;
+
+        [ImportingConstructor]
+        internal IsFormattedFormattingRule(Options options)
+        {
+            _options = options;
+        }
+
         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.
-            // Doing that manually here
-            var preprocessorNames = document.DefinedProjectPreprocessorNames();
-            newDocument = await newDocument.GetNewDocumentWithPreprocessorSymbols(preprocessorNames, cancellationToken);
-            newDocument = await Formatter.FormatAsync(newDocument, cancellationToken: cancellationToken);
+            document = await Formatter.FormatAsync(document, cancellationToken: cancellationToken);
+
+            if (!_options.PreprocessorConfigurations.IsDefaultOrEmpty)
+            {
+                var project = document.Project;
+                var parseOptions = (CSharpParseOptions)document.Project.ParseOptions;
+                foreach (var configuration in _options.PreprocessorConfigurations)
+                {
+                    var newParseOptions = parseOptions.WithPreprocessorSymbols(configuration);
+                    document = project.WithParseOptions(newParseOptions).GetDocument(document.Id);
+                    document = await Formatter.FormatAsync(document, cancellationToken: cancellationToken);
+                }
+            }
 
-            return await newDocument.GetOriginalDocumentWithPreprocessorSymbols(preprocessorNames).GetSyntaxRootAsync(cancellationToken);
+            return await document.GetSyntaxRootAsync(cancellationToken);
         }
     }
 }

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

@@ -29,27 +29,5 @@ public static IEnumerable<SyntaxTrivia> AddWhiteSpaceTrivia(this IEnumerable<Syn
         {
             return trivia.Concat(new[] { SyntaxFactory.Tab });
         }
-
-        public async static Task<Document> GetNewDocumentWithPreprocessorSymbols(this Document document, IEnumerable<string> preprocessorNamesDefined, CancellationToken cancellationToken)
-        {
-            var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
-            var preprocessorNamesToAdd = syntaxRoot.DescendantTrivia().Where(trivia => trivia.CSharpKind() == SyntaxKind.IfDirectiveTrivia)
-                .SelectMany(trivia => trivia.GetStructure().DescendantNodes().OfType<IdentifierNameSyntax>())
-                .Select(identifier => identifier.Identifier.Text).Distinct().Where((name) => !preprocessorNamesDefined.Contains(name));
-
-            var newParseOptions = new CSharpParseOptions().WithPreprocessorSymbols(preprocessorNamesToAdd);
-
-            return document.Project.WithParseOptions(newParseOptions).GetDocument(document.Id);
-        }
-
-        public static IEnumerable<string> DefinedProjectPreprocessorNames(this Document document)
-        {
-            return document.Project.ParseOptions.PreprocessorSymbolNames;
-        }
-
-        public static Document GetOriginalDocumentWithPreprocessorSymbols(this Document document, IEnumerable<string> preprocessorNamesDefined)
-        {
-            return document.Project.WithParseOptions(new CSharpParseOptions().WithPreprocessorSymbols(preprocessorNamesDefined)).GetDocument(document.Id);
-        }
     }
 }