Merge pull request #72 from jaredpar/bug-fixes

Bug fixes

Author: jaredpar

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

@@ -128,6 +128,7 @@
     <Compile Include="Rules\HasNewLineBeforeFirstUsingFormattingRuleTests.cs" />
     <Compile Include="Rules\PrivateFieldNamingRuleTests.cs" />
     <Compile Include="Rules\NonAsciiCharactersAreEscapedInLiteralsRuleTests.cs" />
+    <Compile Include="Rules\UsingLocationRuleTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Properties\" />

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

@@ -390,6 +390,32 @@ internal class C
 
                 Verify(text, expected, runFormatter: false);
             }
+
+            [Fact]
+            public void Issue70()
+            {
+                var source = @"
+public class MyClass
+{
+    enum MyEnum { }
+    struct MyStruct
+    {
+        public MyStruct(MyEnum e) { }
+    }
+}";
+
+                var expected = @"
+public class MyClass
+{
+    private enum MyEnum { }
+    private struct MyStruct
+    {
+        public MyStruct(MyEnum e) { }
+    }
+}";
+
+                Verify(source, expected);
+            }
         }
 
         public sealed class VisualBasicTests : ExplicitVisibilityRuleTests

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

@@ -146,6 +146,72 @@ class C
 
                 Verify(text, expected, runFormatter: false);
             }
+
+            [Fact]
+            public void Issue68()
+            {
+                var text = @"
+delegate void Action();
+class C
+{
+    Action someAction;
+    void M(C p)
+    {
+        someAction();
+        this.someAction();
+        p.someAction();
+    }
+}";
+
+                var expected = @"
+delegate void Action();
+class C
+{
+    Action _someAction;
+    void M(C p)
+    {
+        _someAction();
+        this._someAction();
+        p._someAction();
+    }
+}";
+
+                Verify(text, expected);
+            }
+
+            /// <summary>
+            /// Ensure that Roslyn properly renames private fields when accessed through a non-this
+            /// instance within the same type.
+            /// </summary>
+            [Fact]
+            public void Issue69()
+            {
+                var text = @"
+class C
+{
+    int field;
+
+    int M(C p)
+    {
+        int x = p.field;
+        return x;
+    }
+}";
+
+                var expected = @"
+class C
+{
+    int _field;
+
+    int M(C p)
+    {
+        int x = p._field;
+        return x;
+    }
+}";
+
+                Verify(text, expected);
+            }
         }
 
         private sealed class VisualBasicFields : PrivateFieldNamingRuleTests
@@ -221,6 +287,32 @@ End Sub
 
                 Verify(text, expected, runFormatter: false, languageName: LanguageNames.VisualBasic);
             }
+
+            [Fact]
+            public void Issue69()
+            {
+                var text = @"
+Class C1
+    Private Field As Integer
+
+    Function M(p As C1) As Integer
+        Dim x = p.Field
+        Return x
+    End Function
+End Class";
+
+                var expected = @"
+Class C1
+    Private _field As Integer
+
+    Function M(p As C1) As Integer
+        Dim x = p._field
+        Return x
+    End Function
+End Class";
+
+                Verify(text, expected, languageName: LanguageNames.VisualBasic);
+            }
         }
     }
 }

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

@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Microsoft.DotNet.CodeFormatting.Tests
+{
+    public sealed class UsingLocationRuleTests : SyntaxRuleTestBase
+    {
+        internal override ISyntaxFormattingRule Rule
+        {
+            get { return new Rules.UsingLocationRule(); }
+        }
+
+        [Fact]
+        public void SimpleMove()
+        {
+            var source = @"
+using NS1;
+namespace NS2
+{
+    using NS3;
+    class C1 { }
+}";
+
+            var expected = @"
+using NS1;
+using NS3;
+namespace NS2
+{
+    class C1 { }
+}";
+
+            Verify(source, expected);
+        }
+
+        /// <summary>
+        /// There is no safe way to move a using outside a namespace when there are
+        /// multiple namespaces.  The rule should punt on this scenario. 
+        /// </summary>
+        [Fact]
+        public void SimpleMoveMultipleNamespaces()
+        {
+            var source = @"
+using NS1;
+namespace NS2
+{
+    using NS3;
+    class C1 { }
+}
+
+namespace NS3
+{
+    using NS4;
+    class C1 { }
+}";
+
+            Verify(source, source);
+        }
+
+        [Fact]
+        public void SimpleMoveWithComment()
+        {
+            var source = @"
+using NS1;
+namespace NS2
+{
+    // test
+    using NS3;
+    class C1 { }
+}";
+
+            var expected = @"
+using NS1;
+// test
+using NS3;
+namespace NS2
+{
+    class C1 { }
+}";
+
+            Verify(source, expected);
+        }
+
+        [Fact]
+        public void SimpleMoveWithBeforeAfterComments()
+        {
+            var source = @"
+using NS1;
+namespace NS2
+{
+    // test1
+    using NS3;
+    // test2
+    class C1 { }
+}";
+
+            var expected = @"
+using NS1;
+// test1
+using NS3;
+namespace NS2
+{
+    // test2
+    class C1 { }
+}";
+
+            Verify(source, expected);
+        }
+
+        [Fact]
+        public void MoveToEmptyList()
+        {
+            var source = @"namespace NS2
+{
+    // test
+    using NS3;
+    class C1 { }
+}";
+
+            var expected = @"// test
+using NS3;
+namespace NS2
+{
+    class C1 { }
+}";
+
+            Verify(source, expected);
+        }
+
+        /// <summary>
+        /// In the case a using directive is inside of a #pragma directive there is no
+        /// way to safely move the using.
+        /// </summary>
+        [Fact]
+        public void Issue71()
+        {
+            var source = @"
+namespace N
+{
+#if false
+    using NS1;
+    class C { } 
+#else
+    using NS2;
+    using D { } 
+#endif
+}";
+
+            Verify(source, source);
+        }
+
+    }
+}

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

@@ -134,7 +134,7 @@
     <Compile Include="Rules\HasNoIllegalHeadersFormattingRule.cs" />
     <Compile Include="Rules\HasNoCustomCopyrightHeaderFormattingRule.cs" />
     <Compile Include="Rules\PrivateFieldNamingRule.cs" />
-    <Compile Include="Rules\HasUsingsOutsideOfNamespaceFormattingRule.cs" />
+    <Compile Include="Rules\UsingLocationRule.cs" />
     <Compile Include="Rules\FormatDocumentFormattingRule.cs" />
     <Compile Include="Rules\NonAsciiCharactersAreEscapedInLiteralsRule.cs" />
     <Compile Include="Rules\ExplicitThisRule.cs" />

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

@@ -14,7 +14,7 @@ internal static class SyntaxRuleOrder
     {
         public const int HasNoCustomCopyrightHeaderFormattingRule = 1;
         public const int CopyrightHeaderRule = 2;
-        public const int HasUsingsOutsideOfNamespaceFormattingRule = 3;
+        public const int UsingLocationFormattingRule = 3;
         public const int HasNewLineBeforeFirstUsingFormattingRule = 4;
         public const int HasNewLineBeforeFirstNamespaceFormattingRule = 5;
         public const int BraceNewLineRule = 6;