Merge pull request #1985 from sharwell/backport-fixes

Back-port fixes to stabilization for RC 3

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1127CodeFixProvider.cs

@@ -6,6 +6,7 @@ namespace StyleCop.Analyzers.ReadabilityRules
     using System.Collections.Generic;
     using System.Collections.Immutable;
     using System.Composition;
+    using System.Linq;
     using System.Threading;
     using System.Threading.Tasks;
     using Helpers;
@@ -88,18 +89,11 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
 
         private static string GetParentIndentation(SyntaxToken token)
         {
-            var parentLine = token.Parent.Parent;
-            var parentIndentation = string.Empty;
-            var parentTrivia = parentLine.GetLeadingTrivia();
-            foreach (var trivia in parentTrivia)
-            {
-                if (trivia.IsKind(SyntaxKind.WhitespaceTrivia))
-                {
-                    parentIndentation += trivia.ToString();
-                }
-            }
+            var parentTrivia = token.Parent.Parent.GetLeadingTrivia();
 
-            return parentIndentation;
+            return parentTrivia
+                .LastOrDefault(SyntaxKind.WhitespaceTrivia)
+                .ToString();
         }
 
         // This function will remove any unnecessary whitespace or end-of-line trivia from a token.

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1133CodeFixProvider.cs

@@ -77,7 +77,9 @@ private static List<AttributeListSyntax> GetNewAttributeList(AttributeListSyntax
 
             for (var i = 0; i < attributeList.Attributes.Count; i++)
             {
-                var newAttributes = SyntaxFactory.SingletonSeparatedList(attributeList.Attributes[i]);
+                var newAttributes = SyntaxFactory.SingletonSeparatedList(
+                    attributeList.Attributes[i].WithLeadingTrivia(
+                        attributeList.Attributes[i].GetLeadingTrivia().WithoutLeadingWhitespace()));
                 var newAttributeList = SyntaxFactory.AttributeList(attributeList.Target, newAttributes);
 
                 newAttributeList = (i == 0)

StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1303UnitTests.cs

@@ -199,6 +199,24 @@ public async Task TestFieldWhichIsNotConstStartingWithLowerCaseAsync()
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Regression test for https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1936.
+        /// </summary>
+        /// <remarks>SA1303 should not be reported on <c>enum</c> declarations. SA1300 will be reported in this case.</remarks>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        [Fact]
+        public async Task TestEnumDeclarationsDoNotReportAsync()
+        {
+            var testCode = @"
+public enum SpecialFile
+{
+    iTunesMetadata
+}";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+
+        }
+
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {
             yield return new SA1303ConstFieldNamesMustBeginWithUpperCaseLetter();

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1127UnitTests.cs

@@ -128,6 +128,66 @@ private void Method<T>(
             await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// This is a regression test for DotNetAnalyzers/StyleCopAnalyzers#1652:
+        /// https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1652
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestViolationWithMethodDeclarationAndXmlCommentsAsync()
+        {
+            var testCode = $@"
+class Foo
+{{
+    /// <summary>Foo</summary>
+    /// <typeparam name=""T"">The type.</typeparam>
+    private void Method<T>() where T : class {{ }}
+}}";
+            var fixedCode = $@"
+class Foo
+{{
+    /// <summary>Foo</summary>
+    /// <typeparam name=""T"">The type.</typeparam>
+    private void Method<T>()
+        where T : class
+    {{ }}
+}}";
+            var expected = this.CSharpDiagnostic().WithLocation(6, 30);
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// This is a regression test for DotNetAnalyzers/StyleCopAnalyzers#1652:
+        /// https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1652
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestViolationWithMethodDeclarationRegionDirectiveAsync()
+        {
+            var testCode = $@"
+class Foo
+{{
+    #region Test
+    private void Method<T>() where T : class {{ }}
+    #endregion
+}}";
+            var fixedCode = $@"
+class Foo
+{{
+    #region Test
+    private void Method<T>()
+        where T : class
+    {{ }}
+    #endregion
+}}";
+            var expected = this.CSharpDiagnostic().WithLocation(5, 30);
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestViolationWithExpressionBodiedMethodDeclarationAsync()
         {

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1133UnitTests.cs

@@ -421,6 +421,51 @@ public enum ImplicitUseKindFlags { Assign }
             await this.VerifyCSharpFixAllFixAsync(testCode, fixedTestCode, maxNumberOfIterations: 1).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Regression test for issue 1883 (whitespace is preserved incorrectly): https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1883
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestWhitespaceIsHandledCorrectlyAsync()
+        {
+            var testCode = @"
+namespace SA1133CodeFix
+{
+    using System.ComponentModel;
+    using System.Diagnostics.CodeAnalysis;
+
+    [DefaultValue(true),
+    SuppressMessage(null, null)]
+    internal class Foo
+    {
+    }
+}
+";
+
+            var fixedTestCode = @"
+namespace SA1133CodeFix
+{
+    using System.ComponentModel;
+    using System.Diagnostics.CodeAnalysis;
+
+    [DefaultValue(true)]
+    [SuppressMessage(null, null)]
+    internal class Foo
+    {
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic().WithLocation(8, 5)
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
         /// <inheritdoc/>
         protected override CodeFixProvider GetCSharpCodeFixProvider()
         {

StyleCop.Analyzers/StyleCop.Analyzers/LinqHelpers/SyntaxTriviaListEnumerable.cs

@@ -5,6 +5,7 @@ namespace System.Linq
 {
     using Collections.Generic;
     using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
 
     /// <summary>
     /// This class supports a subset of LINQ operations on <see cref="SyntaxTriviaList"/> without requiring boxing of
@@ -93,5 +94,26 @@ internal static bool All(this SyntaxTriviaList list, Func<SyntaxTrivia, bool> pr
 
             return true;
         }
+
+        /// <summary>
+        /// Returns the last trivia of a specified kind in a trivia list.
+        /// </summary>
+        /// <param name="list">The trivia list.</param>
+        /// <param name="kind">The syntax kind.</param>
+        /// <returns>The last <see cref="SyntaxTrivia"/> in <paramref name="list"/> with the specified
+        /// <paramref name="kind"/>; otherwise, a default <see cref="SyntaxTrivia"/> instance if no matching trivia was
+        /// found.</returns>
+        internal static SyntaxTrivia LastOrDefault(this SyntaxTriviaList list, SyntaxKind kind)
+        {
+            foreach (var trivia in list.Reverse())
+            {
+                if (trivia.IsKind(kind))
+                {
+                    return trivia;
+                }
+            }
+
+            return default(SyntaxTrivia);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1303ConstFieldNamesMustBeginWithUpperCaseLetter.cs

@@ -71,7 +71,7 @@ public void HandleFieldDeclaration(SymbolAnalysisContext context)
             {
                 var symbol = context.Symbol as IFieldSymbol;
 
-                if (symbol == null || !symbol.IsConst)
+                if (symbol == null || !symbol.IsConst || symbol.ContainingType?.TypeKind == TypeKind.Enum)
                 {
                     return;
                 }