Update command line parsing

The command line parsing code didn't reflect the current state of the
tool.  The <rule types> switch for instance was only used to add in the
xUnit conversion rules which are no longer a part of the code style
tool.   This and some other dead code was removed and it now reflects
the real feature set of the tool.

Author: jaredpar

src/CodeFormatter/Program.cs

@@ -24,14 +24,15 @@ private static int Main(string[] args)
         {
             if (args.Length < 1)
             {
-                Console.WriteLine("CodeFormatter <project or solution> [<rule types>] [/file:<filename>] [/nocopyright] [/tables] [/c:<config1,config2> [/copyright:file]");
-                Console.WriteLine("    <rule types> - Rule types to use in addition to the default ones.");
-                Console.WriteLine("                   Use ConvertTests to convert MSTest tests to xUnit.");
+                Console.WriteLine("CodeFormatter <project or solution> [/file:<filename>] [/nocopyright] [/nounicode] [/tables] [/c:<config1,config2> [/copyright:file]");
                 Console.WriteLine("    <filename>   - Only apply changes to files with specified name.");
                 Console.WriteLine("    <configs>    - Additional preprocessor configurations the formatter");
                 Console.WriteLine("                   should run under.");
                 Console.WriteLine("    <copyright>  - Specifies file containing copyright header.");
+                Console.WriteLine("                   Use ConvertTests to convert MSTest tests to xUnit.");
                 Console.WriteLine("    <tables>     - Let tables opt out of formatting by defining DOTNET_FORMATTER");
+                Console.WriteLine("    <nounicode>  - Do not convert unicode strings to escape sequences");
+                Console.WriteLine("    <nocopyright>- Do not update the copyright message.");
                 return -1;
             }
 
@@ -46,6 +47,7 @@ private static int Main(string[] args)
             var ruleTypeBuilder = ImmutableArray.CreateBuilder<string>();
             var configBuilder = ImmutableArray.CreateBuilder<string[]>();
             var copyrightHeader = FormattingConstants.DefaultCopyrightHeader;
+            var convertUnicode = true;
             var allowTables = false;
             var comparer = StringComparer.OrdinalIgnoreCase;
 
@@ -82,6 +84,10 @@ private static int Main(string[] args)
                 {
                     copyrightHeader = ImmutableArray<string>.Empty;
                 }
+                else if (comparer.Equals(arg, "/nounicode"))
+                {
+                    convertUnicode = false;
+                }
                 else if (comparer.Equals(arg, "/tables"))
                 {
                     allowTables = true;
@@ -106,6 +112,7 @@ private static int Main(string[] args)
                     configBuilder.ToImmutableArray(),
                     copyrightHeader,
                     allowTables,
+                    convertUnicode,
                     ct).Wait(ct);
                 Console.WriteLine("Completed formatting.");
                 return 0;
@@ -132,6 +139,7 @@ private static async Task RunAsync(
             ImmutableArray<string[]> preprocessorConfigurations, 
             ImmutableArray<string> copyrightHeader,
             bool allowTables,
+            bool convertUnicode,
             CancellationToken cancellationToken)
         {
             var workspace = MSBuildWorkspace.Create();
@@ -140,6 +148,7 @@ private static async Task RunAsync(
             engine.FileNames = fileNames;
             engine.CopyrightHeader = copyrightHeader;
             engine.AllowTables = allowTables;
+            engine.ConvertUnicodeCharacters = convertUnicode;
 
             string extension = Path.GetExtension(projectOrSolutionPath);
             if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".sln"))

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

@@ -10,7 +10,7 @@ public class NonAsciiCharactersAreEscapedInLiteralsTests : SyntaxRuleTestBase
     {
         internal override ISyntaxFormattingRule Rule
         {
-            get { return new Rules.NonAsciiCharactersAreEscapedInLiterals(); }
+            get { return new Rules.NonAsciiCharactersAreEscapedInLiterals(new Options() { ConvertUnicodeCharacters = true }); }
         }
 
         [Fact]

src/Microsoft.DotNet.CodeFormatting/FormattingEngine.cs

@@ -17,45 +17,9 @@ public static class FormattingEngine
         public static IFormattingEngine Create(ImmutableArray<string> ruleTypes)
         {
             var catalog = new AssemblyCatalog(typeof(FormattingEngine).Assembly);
-
-            var ruleTypesHash = new HashSet<string>(ruleTypes, StringComparer.InvariantCultureIgnoreCase);
-            var notFoundRuleTypes = new HashSet<string>(ruleTypes, StringComparer.InvariantCultureIgnoreCase);
-
-            var filteredCatalog = new FilteredCatalog(catalog, cpd =>
-            {
-                if (cpd.ExportDefinitions.Any(em =>
-                    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;
-                    if (cpd.Metadata.TryGetValue(RuleTypeConstants.PartMetadataKey, out ruleType))
-                    {
-                        if (ruleType is string)
-                        {
-                            notFoundRuleTypes.Remove((string)ruleType);
-                            if (!ruleTypesHash.Contains((string)ruleType))
-                            {
-                                return false;
-                            }
-                        }
-                    }
-                }
-
-                return true;
-            });
-
-            var container = new CompositionContainer(filteredCatalog);
+            var container = new CompositionContainer(catalog);
             var engine = container.GetExportedValue<IFormattingEngine>();
             var consoleFormatLogger = new ConsoleFormatLogger();
-
-            //  Need to do this after the catalog is queried, otherwise the lambda won't have been run
-            foreach (var notFoundRuleType in notFoundRuleTypes)
-            {
-                consoleFormatLogger.WriteErrorLine("The specified rule type was not found: {0}", notFoundRuleType);
-            }
-
             return engine;
         }
     }

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -64,6 +64,12 @@ public bool AllowTables
             get { return _allowTables; }
             set { _allowTables = value; }
         }
+        
+        public bool ConvertUnicodeCharacters
+        {
+            get { return _options.ConvertUnicodeCharacters; }
+            set { _options.ConvertUnicodeCharacters = value; }
+        }
 
         [ImportingConstructor]
         internal FormattingEngineImplementation(

src/Microsoft.DotNet.CodeFormatting/IFormattingEngine.cs

@@ -16,6 +16,7 @@ public interface IFormattingEngine
         ImmutableArray<string[]> PreprocessorConfigurations { get; set; }
         ImmutableArray<string> FileNames { get; set; }
         bool AllowTables { get; set; }
+        bool ConvertUnicodeCharacters { get; set; }
         Task FormatSolutionAsync(Solution solution, CancellationToken cancellationToken);
         Task FormatProjectAsync(Project porject, CancellationToken cancellationToken);
     }

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

@@ -138,7 +138,6 @@
     <Compile Include="Rules\NonAsciiCharactersAreEscapedInLiteralsRule.cs" />
     <Compile Include="Rules\ExplicitThisRule.cs" />
     <Compile Include="Rules\RuleOrder.cs" />
-    <Compile Include="RuleTypeConstants.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />

src/Microsoft.DotNet.CodeFormatting/Options.cs

@@ -24,13 +24,16 @@ internal sealed class Options
 
         internal IFormatLogger FormatLogger { get; set; }
 
+        internal bool ConvertUnicodeCharacters { get; set; }
+
         [ImportingConstructor]
         internal Options()
         {
             CopyrightHeader = FormattingConstants.DefaultCopyrightHeader;
             FileNames = ImmutableArray<string>.Empty;
             PreprocessorConfigurations = ImmutableArray<string[]>.Empty;
             FormatLogger = new ConsoleFormatLogger();
+            ConvertUnicodeCharacters = true;
         }
     }
 }

src/Microsoft.DotNet.CodeFormatting/RuleTypeConstants.cs

@@ -18,8 +18,21 @@ namespace Microsoft.DotNet.CodeFormatting.Rules
     [SyntaxRuleOrder(SyntaxRuleOrder.NonAsciiChractersAreEscapedInLiterals)]
     internal sealed class NonAsciiCharactersAreEscapedInLiterals : CSharpOnlyFormattingRule, ISyntaxFormattingRule
     {
+        private readonly Options _options;
+
+        [ImportingConstructor]
+        internal NonAsciiCharactersAreEscapedInLiterals(Options options)
+        {
+            _options = options;
+        }
+
         public SyntaxNode Process(SyntaxNode root, string languageName)
         {
+            if (!_options.ConvertUnicodeCharacters)
+            {
+                return root;
+            }
+
             return UnicodeCharacterEscapingSyntaxRewriter.Rewriter.Visit(root);
         }