Merge pull request #40 from jaredpar/small-fixes

Couple of small fixes

Author: jaredpar

src/CodeFormatter/Program.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -32,13 +33,15 @@ private static int Main(string[] args)
                 return -1;
             }
 
-            List<string> ruleTypes = new List<string>();
-            List<string> filenames = new List<string>();
+            var ruleTypes = new List<string>();
+            var filenames = new List<string>();
+            var disableCopyright = false;
+            var comparer = StringComparer.OrdinalIgnoreCase;
 
             for (int i = 1; i < args.Length; i++)
             {
                 string arg = args[i];
-                if (arg.Equals("/file", StringComparison.InvariantCultureIgnoreCase))
+                if (comparer.Equals(arg, "/file"))
                 {
                     if (i + 1 < args.Length)
                     {
@@ -47,28 +50,35 @@ private static int Main(string[] args)
                         i++;
                     }
                 }
+                else if (comparer.Equals(arg, "/nocopyright"))
+                {
+                    disableCopyright = true;
+                }
                 else
                 {
                     ruleTypes.Add(arg);
                 }
             }
 
-
             var cts = new CancellationTokenSource();
             var ct = cts.Token;
 
             Console.CancelKeyPress += delegate { cts.Cancel(); };
 
-            RunAsync(projectOrSolutionPath, ruleTypes, filenames, ct).Wait(ct);
+            RunAsync(projectOrSolutionPath, ruleTypes, filenames, disableCopyright, ct).Wait(ct);
             Console.WriteLine("Completed formatting.");
             return 0;
         }
 
-        private static async Task RunAsync(string projectOrSolutionPath, IEnumerable<string> ruleTypes, IEnumerable<string> filenames, CancellationToken cancellationToken)
+        private static async Task RunAsync(string projectOrSolutionPath, IEnumerable<string> ruleTypes, IEnumerable<string> filenames, bool disableCopright, CancellationToken cancellationToken)
         {
             var workspace = MSBuildWorkspace.Create();
             var engine = FormattingEngine.Create(ruleTypes, filenames);
             engine.Verbose = true;
+            if (disableCopright)
+            {
+                engine.CopyrightHeader = ImmutableArray<string>.Empty;
+            }
 
             string extension = Path.GetExtension(projectOrSolutionPath);
             if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".sln"))

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

@@ -113,5 +113,36 @@ class C3
 
             Verify(text, expected, runFormatter: true);
         }
+
+        /// <summary>
+        /// If the name is pascal cased make it camel cased during the rewrite.  If it is not
+        /// pascal cased then do not change the casing.
+        /// </summary>
+        [Fact]
+        public void NameCasingField()
+        {
+            var text = @"
+class C
+{
+    int Field;
+    static int Other;
+    int GCField;
+    static int GCOther;
+}
+";
+
+            var expected = @"
+class C
+{
+    int _field;
+    static int s_other;
+    int _GCField;
+    static int s_GCOther;
+}
+";
+
+            Verify(text, expected, runFormatter: false);
+
+        }
     }
 }

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -105,18 +105,12 @@ private async Task SaveChanges(Solution solution, Solution originalSolution, Can
                     var sourceText = await document.GetTextAsync(cancellationToken);
                     using (var file = File.Open(document.FilePath, FileMode.Truncate, FileAccess.Write))
                     {
-                        var encoding = sourceText.Encoding;
+                        // 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);
 
-                        // TODO: It seems like a bug that Encoding could change but it is definitely
-                        // happening.  Ex: ArrayBuilder.Enumerator.cs
-                        if (encoding == null)
-                        {
-                            var originalDocument = originalSolution.GetDocument(documentId);
-                            var originalSourceText = await originalDocument.GetTextAsync(cancellationToken);
-                            encoding = originalSourceText.Encoding;
-                        }
-
-                        using (var writer = new StreamWriter(file, encoding))
+                        using (var writer = new StreamWriter(file, originalSourceText.Encoding))
                         {
                             sourceText.Write(writer, cancellationToken);
                         }

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

@@ -26,6 +26,11 @@ internal HasCopyrightHeaderFormattingRule(Options options)
 
         public SyntaxNode Process(SyntaxNode syntaxNode)
         {
+            if (_options.CopyrightHeader.IsDefaultOrEmpty)
+            {
+                return syntaxNode;
+            }
+
             if (HasCopyrightHeader(syntaxNode))
                 return syntaxNode;
 

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

@@ -24,7 +24,7 @@ internal sealed class HasNoIllegalHeadersFormattingRule : ILocalSemanticFormatti
         // We are going to remove any multiline comments that *only* contain these characters
         private const string CommentFormattingCharacters = "*/=-";
 
-        public async Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxNode, CancellationToken cancellationToken)
+        public Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxNode, CancellationToken cancellationToken)
         {
             var leadingTrivia = syntaxNode.GetLeadingTrivia();
             SyntaxTriviaList newTrivia = leadingTrivia;
@@ -71,9 +71,9 @@ public async Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxN
             }
 
             if (leadingTrivia.Equals(newTrivia))
-                return syntaxNode;
+                return Task.FromResult(syntaxNode);
 
-            return syntaxNode.WithLeadingTrivia(newTrivia);
+            return Task.FromResult(syntaxNode.WithLeadingTrivia(newTrivia));
         }
 
         private string[] GetIllegalHeaders(Document document)

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

@@ -215,6 +215,11 @@ private static string GetNewFieldName(IFieldSymbol fieldSymbol)
                 return fieldSymbol.Name;
             }
 
+            if (name.Length > 2 && char.IsUpper(name[0]) && char.IsLower(name[1]))
+            {
+                name = char.ToLower(name[0]) + name.Substring(1);
+            }
+
             if (fieldSymbol.IsStatic)
             {
                 // Check for ThreadStatic private fields.