Better handle wrong see tags

Author: pdelvo

StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1642UnitTests.cs

@@ -411,15 +411,14 @@ internal abstract class CustomizableBlockSubscriberBase<TSource, TTarget, TSubsc
 {
     /// <summary>
     /// Initializes a new instance of the <see cref=""CustomizableBlockSubscriberBase{TSource, TTarget, TSubscribedElement}""/> class.
-    /// Initializes a new instance of the <see cref=""ProjectBuildSnapshotService""/> class.
     /// </summary>
     protected CustomizableBlockSubscriberBase()
     {
     }
 }
 ";
 
-            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(6, 9);
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(7, 43);
             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);
@@ -592,7 +591,8 @@ private async Task TestConstructorSimpleDocumentationAsync(string typeKind, stri
 
             await this.VerifyCSharpDiagnosticAsync(
                 testCode,
-                expected, CancellationToken.None).ConfigureAwait(false);
+                expected,
+                CancellationToken.None).ConfigureAwait(false);
 
             var fixedCode = @"namespace FooNamespace
 {{
@@ -637,7 +637,8 @@ private async Task TestConstructorSimpleDocumentationWrongTypeNameAsync(string t
 
             await this.VerifyCSharpDiagnosticAsync(
                 testCode,
-                expected, CancellationToken.None).ConfigureAwait(false);
+                expected,
+                CancellationToken.None).ConfigureAwait(false);
 
             var fixedCode = @"namespace FooNamespace
 {{

StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1642SA1643CodeFixProvider.cs

@@ -54,13 +54,19 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                     continue;
                 }
 
-                var node = root.FindNode(diagnostic.Location.SourceSpan, findInsideTrivia: true) as XmlElementSyntax;
-                if (node == null)
+                var node = root.FindNode(diagnostic.Location.SourceSpan, findInsideTrivia: true) as XmlNodeSyntax;
+
+                var xmlElementSyntax = node as XmlElementSyntax;
+
+                if (xmlElementSyntax != null)
                 {
-                    continue;
+                    context.RegisterCodeFix(CodeAction.Create(DocumentationResources.SA1642SA1643CodeFix, token => GetTransformedDocumentAsync(context.Document, root, xmlElementSyntax), equivalenceKey: nameof(SA1642SA1643CodeFixProvider)), diagnostic);
+                }
+                else
+                {
+                    var xmlEmptyElementSyntax = node as XmlEmptyElementSyntax;
+                    context.RegisterCodeFix(CodeAction.Create(DocumentationResources.SA1642SA1643CodeFix, token => GetTransformedDocumentAsync(context.Document, root, xmlEmptyElementSyntax), equivalenceKey: nameof(SA1642SA1643CodeFixProvider)), diagnostic);
                 }
-
-                context.RegisterCodeFix(CodeAction.Create(DocumentationResources.SA1642SA1643CodeFix, token => GetTransformedDocumentAsync(context.Document, root, node), equivalenceKey: nameof(SA1642SA1643CodeFixProvider)), diagnostic);
             }
         }
 
@@ -136,6 +142,30 @@ private static Task<Document> GetTransformedDocumentAsync(Document document, Syn
             return Task.FromResult(newDocument);
         }
 
+        private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, XmlEmptyElementSyntax node)
+        {
+            var typeDeclaration = node.FirstAncestorOrSelf<BaseTypeDeclarationSyntax>();
+            var declarationSyntax = node.FirstAncestorOrSelf<BaseMethodDeclarationSyntax>();
+            bool isStruct = typeDeclaration.IsKind(SyntaxKind.StructDeclaration);
+
+            TypeParameterListSyntax typeParameterList;
+            ClassDeclarationSyntax classDeclaration = typeDeclaration as ClassDeclarationSyntax;
+            if (classDeclaration != null)
+            {
+                typeParameterList = classDeclaration.TypeParameterList;
+            }
+            else
+            {
+                typeParameterList = (typeDeclaration as StructDeclarationSyntax)?.TypeParameterList;
+            }
+
+            var newRoot = root.ReplaceNode(node, BuildSeeElement(typeDeclaration.Identifier, typeParameterList));
+
+            var newDocument = document.WithSyntaxRoot(newRoot);
+
+            return Task.FromResult(newDocument);
+        }
+
         private static SyntaxList<XmlNodeSyntax> RemoveMalformattedStandardText(SyntaxList<XmlNodeSyntax> content, SyntaxToken identifier, string preText, string postText, ref string trailingString)
         {
             var regex = new Regex(@"^\s*" + Regex.Escape(preText) + "[^ ]+" + Regex.Escape(postText));
@@ -208,6 +238,15 @@ private static SyntaxList<XmlNodeSyntax> RemoveMalformattedStandardText(SyntaxLi
         }
 
         private static SyntaxList<XmlNodeSyntax> BuildStandardText(SyntaxToken identifier, TypeParameterListSyntax typeParameters, string newLineText, string preText, string postText)
+        {
+            return XmlSyntaxFactory.List(
+                XmlSyntaxFactory.NewLine(newLineText),
+                XmlSyntaxFactory.Text(preText),
+                BuildSeeElement(identifier, typeParameters),
+                XmlSyntaxFactory.Text(postText.EndsWith(".") ? postText : (postText + ".")));
+        }
+
+        private static XmlEmptyElementSyntax BuildSeeElement(SyntaxToken identifier, TypeParameterListSyntax typeParameters)
         {
             TypeSyntax identifierName;
 
@@ -221,11 +260,7 @@ private static SyntaxList<XmlNodeSyntax> BuildStandardText(SyntaxToken identifie
                 identifierName = SyntaxFactory.GenericName(identifier.WithoutTrivia(), ParameterToArgumentListSyntax(typeParameters));
             }
 
-            return XmlSyntaxFactory.List(
-                XmlSyntaxFactory.NewLine(newLineText),
-                XmlSyntaxFactory.Text(preText),
-                XmlSyntaxFactory.SeeElement(SyntaxFactory.TypeCref(identifierName)),
-                XmlSyntaxFactory.Text(postText.EndsWith(".") ? postText : (postText + ".")));
+            return XmlSyntaxFactory.SeeElement(SyntaxFactory.TypeCref(identifierName));
         }
 
         private static TypeArgumentListSyntax ParameterToArgumentListSyntax(TypeParameterListSyntax typeParameters)

StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/StandardTextDiagnosticBase.cs

@@ -31,6 +31,11 @@ public enum MatchResult
             /// </summary>
             None,
 
+            /// <summary>
+            /// A standard text was found but the see element was incorrect.
+            /// </summary>
+            InvalidSeeTag,
+
             /// <summary>
             /// A match to the expected text was found.
             /// </summary>
@@ -75,11 +80,22 @@ protected static MatchResult HandleDeclaration(SyntaxNodeAnalysisContext context
 
                 if (firstTextPartSyntax != null && classReferencePart != null && secondTextParSyntaxt != null)
                 {
-                    if (TextPartsMatch(firstTextPart, secondTextPart, firstTextPartSyntax, secondTextParSyntaxt)
-                        && SeeTagIsCorrect(context, classReferencePart, declarationSyntax))
+                    if (TextPartsMatch(firstTextPart, secondTextPart, firstTextPartSyntax, secondTextParSyntaxt))
                     {
-                        // We found a correct standard text
-                        return MatchResult.FoundMatch;
+                        if (SeeTagIsCorrect(context, classReferencePart, declarationSyntax))
+                        {
+                            // We found a correct standard text
+                            return MatchResult.FoundMatch;
+                        }
+                        else
+                        {
+                            if (diagnosticDescriptor != null)
+                            {
+                                context.ReportDiagnostic(Diagnostic.Create(diagnosticDescriptor, classReferencePart.GetLocation()));
+                            }
+
+                            return MatchResult.None;
+                        }
                     }
                 }
             }