Merge pull request #20 from sharwell/cleanup

Cleanup

Author: sharwell

OpenStackNetAnalyzers/OpenStackNetAnalyzers/AssertNullAnalyzer.cs

@@ -64,27 +64,10 @@ private void HandleInvocationExpression(SyntaxNodeAnalysisContext context)
                 return;
 
             TypeInfo typeInfo = context.SemanticModel.GetTypeInfo(argumentExpression);
-            INamedTypeSymbol namedType = typeInfo.Type as INamedTypeSymbol;
-            if (namedType == null)
+            if (!typeInfo.Type.IsNonNullableValueType())
                 return;
 
-            if (!namedType.IsValueType)
-            {
-                // don't report the diagnostic for reference types
-                return;
-            }
-
-            INamedTypeSymbol originalDefinition = namedType.OriginalDefinition;
-            if (originalDefinition == null
-                || originalDefinition.SpecialType == SpecialType.System_Nullable_T
-                || originalDefinition.SpecialType == SpecialType.System_ValueType
-                || originalDefinition.SpecialType == SpecialType.System_Enum)
-            {
-                // don't report the diagnostic for "special" and nullable value types
-                return;
-            }
-
-            string typeName = namedType.ToMinimalDisplayString(context.SemanticModel, argumentExpression.SpanStart, SymbolDisplayFormat.CSharpErrorMessageFormat);
+            string typeName = typeInfo.Type.ToMinimalDisplayString(context.SemanticModel, argumentExpression.SpanStart, SymbolDisplayFormat.CSharpErrorMessageFormat);
             context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation(), methodSymbol.Name, typeName));
         }
     }

OpenStackNetAnalyzers/OpenStackNetAnalyzers/DocumentDelegatingApiCallAnalyzer.cs

@@ -1,6 +1,5 @@
 namespace OpenStackNetAnalyzers
 {
-    using System;
     using System.Collections.Immutable;
     using System.Linq;
     using Microsoft.CodeAnalysis;
@@ -40,7 +39,7 @@ private void HandleNamedType(SymbolAnalysisContext context)
             if (symbol.TypeKind != TypeKind.Class)
                 return;
 
-            if (!IsDelegatingHttpApiCall(context, symbol))
+            if (!symbol.IsDelegatingHttpApiCall())
                 return;
 
             if (!string.IsNullOrEmpty(symbol.GetDocumentationCommentXml(cancellationToken: context.CancellationToken)))
@@ -49,23 +48,5 @@ private void HandleNamedType(SymbolAnalysisContext context)
             var locations = symbol.Locations;
             context.ReportDiagnostic(Diagnostic.Create(Descriptor, locations.FirstOrDefault(), locations.Skip(1)));
         }
-
-        private bool IsDelegatingHttpApiCall(SymbolAnalysisContext context, INamedTypeSymbol symbol)
-        {
-            while (symbol != null && symbol.SpecialType != SpecialType.System_Object)
-            {
-                if (symbol.IsGenericType)
-                {
-                    var originalDefinition = symbol.OriginalDefinition;
-                    string fullyQualifiedName = originalDefinition.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
-                    if (string.Equals("global::OpenStack.Net.DelegatingHttpApiCall<T>", fullyQualifiedName, StringComparison.Ordinal))
-                        return true;
-                }
-
-                symbol = symbol.BaseType;
-            }
-
-            return false;
-        }
     }
 }

OpenStackNetAnalyzers/OpenStackNetAnalyzers/DocumentDelegatingApiCallCodeFix.cs

@@ -252,23 +252,5 @@ private async Task<INamedTypeSymbol> GetServiceInterfaceAsync(CodeFixContext con
 
             return null;
         }
-
-        private bool IsServiceInterface(SemanticModel semanticModel, INamedTypeSymbol symbol)
-        {
-            while (symbol != null && symbol.SpecialType != SpecialType.System_Object)
-            {
-                if (symbol.IsGenericType)
-                {
-                    var originalDefinition = symbol.OriginalDefinition;
-                    string fullyQualifiedName = originalDefinition.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
-                    if (string.Equals("global::OpenStack.Net.DelegatingHttpApiCall<T>", fullyQualifiedName, StringComparison.Ordinal))
-                        return true;
-                }
-
-                symbol = symbol.BaseType;
-            }
-
-            return false;
-        }
     }
 }

OpenStackNetAnalyzers/OpenStackNetAnalyzers/DocumentValueFromSummaryAnalyzer.cs

@@ -51,69 +51,17 @@ private void HandlePropertyDeclaration(SyntaxNodeAnalysisContext context)
                 return;
 
             INamedTypeSymbol declaringType = propertySymbol.ContainingType;
-            if (!IsExtensibleJsonObject(declaringType))
+            if (!declaringType.IsExtensibleJsonObject())
                 return;
 
-            DocumentationCommentTriviaSyntax documentationTriviaSyntax = GetDocumentationCommentTriviaSyntax(syntax);
+            DocumentationCommentTriviaSyntax documentationTriviaSyntax = syntax.GetDocumentationCommentTriviaSyntax();
             if (documentationTriviaSyntax == null)
                 return;
 
-            XmlNodeSyntax valueNode = GetXmlElement(documentationTriviaSyntax.Content, "value");
-            if (valueNode != null)
+            if (documentationTriviaSyntax.Content.GetXmlElements("value").Any())
                 return;
 
             context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.Identifier.GetLocation()));
         }
-
-        private bool IsExtensibleJsonObject(INamedTypeSymbol symbol)
-        {
-            while (symbol != null && symbol.SpecialType != SpecialType.System_Object)
-            {
-                if (string.Equals("global::OpenStack.ObjectModel.ExtensibleJsonObject", symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), StringComparison.Ordinal))
-                    return true;
-
-                symbol = symbol.BaseType;
-            }
-
-            return false;
-        }
-
-        internal static DocumentationCommentTriviaSyntax GetDocumentationCommentTriviaSyntax(SyntaxNode node)
-        {
-            if (node == null)
-                return null;
-
-            return node
-                .GetLeadingTrivia()
-                .Select(i => i.GetStructure())
-                .OfType<DocumentationCommentTriviaSyntax>()
-                .FirstOrDefault();
-        }
-
-        internal static XmlNodeSyntax GetXmlElement(SyntaxList<XmlNodeSyntax> content, string elementName)
-        {
-            foreach (XmlNodeSyntax syntax in content)
-            {
-                XmlEmptyElementSyntax emptyElement = syntax as XmlEmptyElementSyntax;
-                if (emptyElement != null)
-                {
-                    if (string.Equals(elementName, emptyElement.Name.ToString(), StringComparison.Ordinal))
-                        return emptyElement;
-
-                    continue;
-                }
-
-                XmlElementSyntax elementSyntax = syntax as XmlElementSyntax;
-                if (elementSyntax != null)
-                {
-                    if (string.Equals(elementName, elementSyntax.StartTag?.Name?.ToString(), StringComparison.Ordinal))
-                        return elementSyntax;
-
-                    continue;
-                }
-            }
-
-            return null;
-        }
     }
 }

OpenStackNetAnalyzers/OpenStackNetAnalyzers/DocumentValueFromSummaryCodeFix.cs

@@ -52,11 +52,11 @@ public override async Task ComputeFixesAsync(CodeFixContext context)
 
         private async Task<Document> CreateChangedDocument(CodeFixContext context, PropertyDeclarationSyntax propertyDeclarationSyntax, CancellationToken cancellationToken)
         {
-            DocumentationCommentTriviaSyntax documentationComment = DocumentValueFromSummaryAnalyzer.GetDocumentationCommentTriviaSyntax(propertyDeclarationSyntax);
+            DocumentationCommentTriviaSyntax documentationComment = propertyDeclarationSyntax.GetDocumentationCommentTriviaSyntax();
             if (documentationComment == null)
                 return context.Document;
 
-            XmlElementSyntax summaryElement = (XmlElementSyntax)DocumentValueFromSummaryAnalyzer.GetXmlElement(documentationComment.Content, "summary");
+            XmlElementSyntax summaryElement = (XmlElementSyntax)documentationComment.Content.GetFirstXmlElement("summary");
             if (summaryElement == null)
                 return context.Document;
 
@@ -111,15 +111,15 @@ private async Task<Document> CreateChangedDocument(CodeFixContext context, Prope
             if (propertySymbol != null)
             {
                 ITypeSymbol propertyType = propertySymbol.Type;
-                if (string.Equals("ImmutableArray`1", propertyType?.MetadataName, StringComparison.Ordinal))
+                if (propertyType.IsImmutableArray())
                     defaultValueToken = "DefaultArrayIfNotIncluded";
             }
 
             XmlElementSyntax valueElement =
                 XmlSyntaxFactory.MultiLineElement(
                     "value",
                     XmlSyntaxFactory.List(
-                        XmlSyntaxFactory.ParaElement(XmlSyntaxFactory.PlaceholderElement(RemoveFirstAndListNewlines(summaryContent))),
+                        XmlSyntaxFactory.ParaElement(XmlSyntaxFactory.PlaceholderElement(summaryContent.WithoutFirstAndLastNewlines())),
                         XmlSyntaxFactory.NewLine(),
                         XmlSyntaxFactory.TokenElement(defaultValueToken)));
 
@@ -131,8 +131,8 @@ private async Task<Document> CreateChangedDocument(CodeFixContext context, Prope
             SyntaxTrivia exteriorTrivia = GetLastDocumentationCommentExteriorTrivia(documentationComment);
             if (!exteriorTrivia.Token.IsMissing)
             {
-                leadingNewLine = ReplaceExteriorTrivia(leadingNewLine, exteriorTrivia);
-                valueElement = ReplaceExteriorTrivia(valueElement, exteriorTrivia);
+                leadingNewLine = leadingNewLine.ReplaceExteriorTrivia(exteriorTrivia);
+                valueElement = valueElement.ReplaceExteriorTrivia(exteriorTrivia);
             }
 
             DocumentationCommentTriviaSyntax newDocumentationComment = documentationComment.WithContent(
@@ -168,142 +168,5 @@ private SyntaxTrivia GetLastDocumentationCommentExteriorTrivia(SyntaxNode node)
                 .Where(trivia => trivia.IsKind(SyntaxKind.DocumentationCommentExteriorTrivia))
                 .LastOrDefault();
         }
-
-        private T ReplaceExteriorTrivia<T>(T node, SyntaxTrivia trivia)
-            where T : SyntaxNode
-        {
-            // Make sure to include a space after the '///' characters.
-            SyntaxTrivia triviaWithSpace = SyntaxFactory.DocumentationCommentExterior(trivia.ToString() + " ");
-
-            return node.ReplaceTrivia(
-                node.DescendantTrivia(descendIntoTrivia: true).Where(i => i.IsKind(SyntaxKind.DocumentationCommentExteriorTrivia)),
-                (originalTrivia, rewrittenTrivia) => SelectExteriorTrivia(rewrittenTrivia, trivia, triviaWithSpace));
-        }
-
-        private SyntaxTrivia SelectExteriorTrivia(SyntaxTrivia rewrittenTrivia, SyntaxTrivia trivia, SyntaxTrivia triviaWithSpace)
-        {
-            // if the trivia had a trailing space, make sure to preserve it
-            if (rewrittenTrivia.ToString().EndsWith(" "))
-                return triviaWithSpace;
-
-            // otherwise the space is part of the leading trivia of the following token, so don't add an extra one to
-            // the exterior trivia
-            return trivia;
-        }
-
-        private SyntaxList<XmlNodeSyntax> RemoveFirstAndListNewlines(SyntaxList<XmlNodeSyntax> summaryContent)
-        {
-            if (summaryContent.Count == 0)
-                return summaryContent;
-
-            XmlTextSyntax firstSyntax = summaryContent[0] as XmlTextSyntax;
-            if (firstSyntax == null)
-                return summaryContent;
-
-            XmlTextSyntax lastSyntax = summaryContent[summaryContent.Count - 1] as XmlTextSyntax;
-            if (lastSyntax == null)
-                return summaryContent;
-
-            SyntaxTokenList firstSyntaxTokens = firstSyntax.TextTokens;
-
-            int removeFromStart;
-            if (IsNewLine(firstSyntaxTokens[0]))
-            {
-                removeFromStart = 1;
-            }
-            else
-            {
-                if (!IsWhitespace(firstSyntaxTokens[0]))
-                    return summaryContent;
-
-                if (!IsNewLine(firstSyntaxTokens[1]))
-                    return summaryContent;
-
-                removeFromStart = 2;
-            }
-
-            SyntaxTokenList lastSyntaxTokens = lastSyntax.TextTokens;
-
-            int removeFromEnd;
-            if (IsNewLine(lastSyntaxTokens[lastSyntaxTokens.Count - 1]))
-            {
-                removeFromEnd = 1;
-            }
-            else
-            {
-                if (!IsWhitespace(lastSyntaxTokens[lastSyntaxTokens.Count - 1]))
-                    return summaryContent;
-
-                if (!IsNewLine(lastSyntaxTokens[lastSyntaxTokens.Count - 2]))
-                    return summaryContent;
-
-                removeFromEnd = 2;
-            }
-
-            for (int i = 0; i < removeFromStart; i++)
-            {
-                firstSyntaxTokens = firstSyntaxTokens.RemoveAt(0);
-            }
-
-            if (firstSyntax == lastSyntax)
-            {
-                lastSyntaxTokens = firstSyntaxTokens;
-            }
-
-            for (int i = 0; i < removeFromEnd; i++)
-            {
-                lastSyntaxTokens = lastSyntaxTokens.RemoveAt(lastSyntaxTokens.Count - 1);
-            }
-
-            summaryContent = summaryContent.RemoveAt(summaryContent.Count - 1);
-            if (lastSyntaxTokens.Count != 0)
-                summaryContent = summaryContent.Add(lastSyntax.WithTextTokens(lastSyntaxTokens));
-
-            if (firstSyntax != lastSyntax)
-            {
-                summaryContent = summaryContent.RemoveAt(0);
-                if (firstSyntaxTokens.Count != 0)
-                    summaryContent = summaryContent.Insert(0, firstSyntax.WithTextTokens(firstSyntaxTokens));
-            }
-
-            if (summaryContent.Count > 0)
-            {
-                // Make sure to remove the leading trivia
-                summaryContent = summaryContent.Replace(summaryContent[0], summaryContent[0].WithLeadingTrivia());
-
-                // Remove leading spaces (between the <para> start tag and the start of the paragraph content)
-                XmlTextSyntax firstTextSyntax = summaryContent[0] as XmlTextSyntax;
-                if (firstTextSyntax != null && firstTextSyntax.TextTokens.Count > 0)
-                {
-                    SyntaxToken firstTextToken = firstTextSyntax.TextTokens[0];
-                    string firstTokenText = firstTextToken.Text;
-                    string trimmed = firstTokenText.TrimStart();
-                    if (trimmed != firstTokenText)
-                    {
-                        SyntaxToken newFirstToken = SyntaxFactory.Token(
-                            firstTextToken.LeadingTrivia,
-                            firstTextToken.CSharpKind(),
-                            trimmed,
-                            firstTextToken.ValueText.TrimStart(),
-                            firstTextToken.TrailingTrivia);
-
-                        summaryContent = summaryContent.Replace(firstTextSyntax, firstTextSyntax.ReplaceToken(firstTextToken, newFirstToken));
-                    }
-                }
-            }
-
-            return summaryContent;
-        }
-
-        private bool IsNewLine(SyntaxToken node)
-        {
-            return node.IsKind(SyntaxKind.XmlTextLiteralNewLineToken);
-        }
-
-        private bool IsWhitespace(SyntaxToken node)
-        {
-            return node.IsKind(SyntaxKind.XmlTextLiteralToken)
-                && string.IsNullOrWhiteSpace(node.Text);
-        }
     }
 }