C# MethodDeclarationSyntax.GetLeadingTrivia方法代码示例

        private async Task<Document> ReturnVoidAsync(Document document, MethodDeclarationSyntax method, CancellationToken cancellationToken)
        {
            var newStatements = new List<StatementSyntax>();
            foreach (var s in method.Body.Statements)
            {
                if (s is ReturnStatementSyntax)
                {
                    continue;
                }
                else
                    newStatements.Add(s);
            }

            var newMethodDeclaration =
                SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName("void").WithLeadingTrivia(method.ReturnType.GetLeadingTrivia()).WithTrailingTrivia(method.ReturnType.GetTrailingTrivia()), method.Identifier)
                .AddModifiers(method.Modifiers.ToArray())
                .WithLeadingTrivia(method.GetLeadingTrivia())
                .WithBody(SyntaxFactory.Block(newStatements))
                ;

            var root = await document.GetSyntaxRootAsync();
            var newRoot = root.ReplaceNode(method, newMethodDeclaration);

            return document.WithSyntaxRoot(newRoot);
        }

        private async Task<Document> RepairXmlCommentAsync(Document document, MethodDeclarationSyntax methodSyntax, CancellationToken cancellationToken)
        {
            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            var methodSymbol = model.GetDeclaredSymbol(methodSyntax);

            var xml = methodSymbol.GetDocumentationCommentXml();

            var documentTrivia = methodSyntax.GetLeadingTrivia().Where(n => n.Kind() == SyntaxKind.SingleLineDocumentationCommentTrivia).Last();

            var documentText = documentTrivia.ToFullString().TrimEnd();
            var invalidXml = Regex.Replace(documentText, @"^\s*///", "", RegexOptions.Multiline);

            var newXml = RpairXml(invalidXml);

            var newDocumentCommentText = Regex.Replace(newXml, @"^", "///", RegexOptions.Multiline) + "\r\n";

            var newDocumentTrivia = SyntaxFactory.ParseLeadingTrivia(newDocumentCommentText)[0];

            var newRoot = root.ReplaceTrivia(documentTrivia, newDocumentTrivia.WithAdditionalAnnotations(Formatter.Annotation));

            var newDocument = document.WithSyntaxRoot(newRoot);

            return newDocument;
        }

        public override SyntaxNode FixParameters(MethodDeclarationSyntax method, SyntaxNode root)
        {
            var documentationNode = method.GetLeadingTrivia().Select(x => x.GetStructure()).OfType<DocumentationCommentTriviaSyntax>().First();

            var allNodesToRemove = GetAllNodesToRemove(GetMethodParametersWithDocParameters(method, documentationNode), documentationNode);

            var newDocumentationNode = documentationNode.RemoveNodes(allNodesToRemove, SyntaxRemoveOptions.KeepNoTrivia);

            return root.ReplaceNode(documentationNode, newDocumentationNode);
        }

 private async Task<Document> EnableQueryAsync(Document document, MethodDeclarationSyntax node,
                      CancellationToken cancellationToken)
 {
     var root = await document.GetSyntaxRootAsync();
     var newMethod = node.WithoutLeadingTrivia().WithAttributeLists(node.AttributeLists.Add(SyntaxFactory.AttributeList(
     SyntaxFactory.SingletonSeparatedList<AttributeSyntax>(
         SyntaxFactory.Attribute(
             SyntaxFactory.IdentifierName("EnableQuery")))))).WithLeadingTrivia(node.GetLeadingTrivia());
     var newRoot = root.ReplaceNode(node, newMethod);
     var newDocument = document.WithSyntaxRoot(newRoot);
     return newDocument;
 }

        /// <summary>
        /// Détermine si le inheritDoc du symbole méthode est présent et correct.
        /// </summary>
        /// <param name="racine">Le nœud racine de l'arbre syntaxtique courant.</param>
        /// <param name="modèleSémantique">Le modèle sémantique lié.</param>
        /// <param name="méthode">La méthode concernée.</param>
        /// <returns>La ligne inheritDoc correcte dans le cas où l'actuelle est manquante/incorrecte, sinon null.</returns>
        public static string InheritDocEstCorrect(SyntaxNode racine, SemanticModel modèleSémantique, MethodDeclarationSyntax méthode)
        {
            var classe = méthode?.Parent as ClassDeclarationSyntax;

            // Si on est bien dans une méthode de classe.
            if (méthode != null && classe != null)
            {
                // On récupère la version sémantique de la méthode pour identifier ses paramètres.
                var méthodeSémantique = modèleSémantique.GetDeclaredSymbol(méthode);

                // On liste toutes les méthodes des interfaces de la classe puis on cherche l'unique méthode avec la même signature.
                var méthodeCorrespondantes = modèleSémantique.GetDeclaredSymbol(classe).Interfaces
                    .SelectMany(contrat => contrat.GetMembers())
                    .Where(méthodeInterface => méthodeInterface.Name == méthode.Identifier.Text
                        && ((méthodeInterface as IMethodSymbol)?.Parameters.SequenceEqual(méthodeSémantique.Parameters, (p1, p2) => p1.Name == p2.Name) ?? false));

                var méthodeCorrespondante = (méthodeCorrespondantes.Count() == 1 ? méthodeCorrespondantes.Single() : null) as IMethodSymbol;

                // S'il y a bien une méthode correspondante, on continue.
                if (méthodeCorrespondante != null)
                {
                    // On récupère le nombre de méthode du même nom dans l'interface pour savoir s'il faut spécifier les paramètres ou non.
                    var nombreMéthodesSurchargées = (méthodeCorrespondante.ContainingSymbol as INamedTypeSymbol).GetMembers()
                        .Count(méthodeInterface => méthodeInterface.Name == méthode.Identifier.Text);

#pragma warning disable SA1013, SA1513

                    // On génère la ligne de documentation.
                    var inheritDoc = [email protected]"/// <inheritdoc cref=""{
                        RécupérerNomType(méthode, méthodeCorrespondante, modèleSémantique)
                    }.{
                        RécupérerNomMéthode(méthode, méthodeCorrespondante)
                      + RécupérerParamètres(méthode, méthodeCorrespondante, modèleSémantique, nombreMéthodesSurchargées)
                    }"" />";

#pragma warning restore SA1013, SA1513

                    // On récupère la documentation actuelle de la classe.
                    var documentationActuelle = méthode.GetLeadingTrivia().ToString().Replace("\n", string.Empty).Replace("\r", string.Empty).Replace(" ", string.Empty);

                    // On la compare avec la ligne existante de façon bien crade, parce qu'en vrai elle n'est pas générée correctement.
                    // Désolé. J'ai vraiment essayé de faire proprement mais la génération propre de commentaires XML est odieuse.
                    // Si la ligne est différente et ne contient pas le mot "summary", on retourne la ligne de commentaire attendue.
                    if (!inheritDoc.Replace("\n", string.Empty).Replace("\r", string.Empty).Replace(" ", string.Empty)
                            .Equals(documentationActuelle) && !documentationActuelle.Contains("summary"))
                        return inheritDoc;
                }
            }

            // Sinon on renvoie null, pour affirmer au diagnostic que tout va bien.
            return null;
        }

        static bool DoesContainingMethodDeclareExceptionType(MethodDeclarationSyntax containingMethod, string expectedExceptionTypeToDeclare)
        {
            var documentationTrivias = containingMethod.GetLeadingTrivia().Where(x => x.CSharpKind() == SyntaxKind.SingleLineDocumentationCommentTrivia);
            foreach (var documentationTrivia in documentationTrivias)
            {
                var documentationTriviaStructure = (DocumentationCommentTriviaSyntax)documentationTrivia.GetStructure();
                var xmlElements = documentationTriviaStructure.Content.OfType<XmlElementSyntax>();
                var exceptionDeclarations = xmlElements.Where(x => x.StartTag.Name.ToFullString().ToLowerInvariant() == "exception");

                return exceptionDeclarations.Any(x => x.StartTag.Attributes.Any(y => y.CSharpKind() == SyntaxKind.XmlCrefAttribute
                                                                                && ((XmlCrefAttributeSyntax)y).Cref.ToString() == expectedExceptionTypeToDeclare));
            }
            return false;
        }

        private async Task<Document> ReplacePropertyModifierAsync(Document document, MethodDeclarationSyntax method, SyntaxKind methodModifier, CancellationToken cancellationToken)
        {
            var previousWhiteSpacesToken = SyntaxFactory.Token(method.GetLeadingTrivia(), SyntaxKind.StringLiteralToken, SyntaxTriviaList.Empty);

            var newProperty = method.WithModifiers(SyntaxTokenList.Create(previousWhiteSpacesToken)
            .Add(SyntaxFactory.Token(methodModifier))
            .Add(_whitespaceToken));

            if (method.Modifiers.Any(m => m.Kind() == SyntaxKind.VirtualKeyword))
            {
                newProperty = newProperty.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword), _whitespaceToken);
            }

            return await ReplacePropertyInDocumentAsync(document, method, newProperty, cancellationToken);
        }

        public override SyntaxNode FixParameters(MethodDeclarationSyntax method, SyntaxNode root)
        {
            var documentationNode = method.GetLeadingTrivia().Select(x => x.GetStructure()).OfType<DocumentationCommentTriviaSyntax>().First();
            var newDocumentationNode = documentationNode;
            var methodParameterWithDocParameter = GetMethodParametersWithDocParameters(method, documentationNode);

            var xmlText = documentationNode.Content.OfType<XmlTextSyntax>().Skip(1).First();

            var nodesToAdd = methodParameterWithDocParameter.Where(p => p.Item2 == null)
                                .SelectMany(x => CreateParamenterXmlDocumentation(xmlText, x.Item1.Identifier.ValueText, method.Identifier.ValueText))
                                .ToList();
            var newFormation = newDocumentationNode.Content.OfType<XmlElementSyntax>().ToList();
            var node = newFormation.LastOrDefault(xEle => xEle.StartTag.Name.LocalName.ValueText == "param") ?? newFormation.LastOrDefault(xEle => xEle.StartTag.Name.LocalName.ValueText == "summary");
            var nodeInList = documentationNode.Content.OfType<XmlTextSyntax>().FirstOrDefault(x => x.FullSpan.Start == node.FullSpan.End);

            newDocumentationNode = newDocumentationNode.InsertNodesAfter(node, nodesToAdd.Cast<SyntaxNode>());

            return root.ReplaceNode(documentationNode, newDocumentationNode);
        }

        private static async Task<Document> ReplaceWithExpressionBodiedMember(Document document, MethodDeclarationSyntax declaration, CancellationToken cancellationToken)
        {
            SyntaxTriviaList leadingTrivia;
            var expression = GetExpressionAndLeadingTrivia(declaration.Body, out leadingTrivia);

            var declarationTrivia = declaration.GetLeadingTrivia();
            declarationTrivia = declarationTrivia.AddRange(leadingTrivia);

            var newDeclaration = declaration
                .WithLeadingTrivia(declarationTrivia)
                .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(expression))
                .WithBody(null)
                .WithSemicolonToken(GetSemicolon(declaration.Body))
                .WithAdditionalAnnotations(Formatter.Annotation);

            var root = await document.GetSyntaxRootAsync(cancellationToken);
            var newRoot = root.ReplaceNode(declaration, newDeclaration);

            return document.WithSyntaxRoot(newRoot);
        }

        public override SyntaxNode FixParameters(MethodDeclarationSyntax method, SyntaxNode root)
        {
            var documentationNode = method.GetLeadingTrivia().Select(x => x.GetStructure()).OfType<DocumentationCommentTriviaSyntax>().First();
            var newDocumentationNode = documentationNode;
            var methodParameterWithDocParameter = GetMethodParametersWithDocParameters(method, documentationNode);

            var newFormation = newDocumentationNode.Content.OfType<XmlElementSyntax>();
            
            var nodesToAdd = methodParameterWithDocParameter.Where(p => p.Item2 == null)
                                .Select(x => CreateParamenterXmlDocumentation(x.Item1.Identifier.ValueText, method.Identifier.ValueText))
                                .Union(newFormation)
                                .OrderByDescending(xEle => xEle.StartTag.Name.LocalName.ValueText == "summary")
                                .ThenByDescending(xEle => xEle.StartTag.Name.LocalName.ValueText == "param")
                                .SelectMany(EnvolveXmlDocSyntaxWithNewLine)
                                .ToList();

            newDocumentationNode = newDocumentationNode.WithContent(SyntaxFactory.List(nodesToAdd));

            return root.ReplaceNode(documentationNode, newDocumentationNode);
        }

        /// <summary>
        /// Add documentation for the property.
        /// </summary>
        /// <param name="context">the code fix context.</param>
        /// <param name="root">the root syntax node.</param>
        /// <param name="methodDeclaration">the property declaration containing invalid documentation.</param>
        /// <param name="documentComment">the existing comment.</param>
        /// <returns>the correct code.</returns>
        private Task<Document> AddDocumentationAsync(
            CodeFixContext context,
            SyntaxNode root,
            MethodDeclarationSyntax methodDeclaration,
            DocumentationCommentTriviaSyntax documentComment)
        {
            var summary = this._commentNodeFactory.GetExistingSummaryCommentText(documentComment)
                          ?? this._commentNodeFactory.CreateCommentSummaryText(methodDeclaration);
            var @class = methodDeclaration.Parent as ClassDeclarationSyntax;
            var first = @class?.DescendantNodes().FirstOrDefault() == methodDeclaration;

            var parameters = this._commentNodeFactory.CreateParameters(methodDeclaration, documentComment);
            var typeParameters = this._commentNodeFactory.CreateTypeParameters(methodDeclaration, documentComment);

            var @return = this._commentNodeFactory.CreateReturnValueDocumentation(methodDeclaration, documentComment);
            var returns = @return == null
                ? new XmlElementSyntax[] { }
                : new[] { @return };
            var summaryPlusParameters = new XmlNodeSyntax[] { summary }
                .Concat(parameters)
                .Concat(returns)
                .Concat(typeParameters)
                .ToArray();

            var comment = this._commentNodeFactory
                .CreateDocumentComment(summaryPlusParameters)
                .AddLeadingEndOfLineTriviaFrom(methodDeclaration.GetLeadingTrivia());

            var trivia = SyntaxFactory.Trivia(comment);
            var methodTrivia = first
                   ? methodDeclaration.WithLeadingTrivia(trivia)
                   : methodDeclaration.WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed, trivia);
            var result = documentComment != null
                ? root.ReplaceNode(documentComment, comment.AdjustDocumentationCommentNewLineTrivia())
                : root.ReplaceNode(methodDeclaration, methodTrivia);

            var newDocument = context.Document.WithSyntaxRoot(result);
            return Task.FromResult(newDocument);
        }

 public static MethodDeclarationSyntax Trivia(this MethodDeclarationSyntax node, MethodDeclarationSyntax that)
 {
     return node.WithLeadingTrivia(that.GetLeadingTrivia()).WithTrailingTrivia(that.GetTrailingTrivia());
 }

        //private object TransverseClassTypes(object classType)
        //{
        //    object retObj;
        //    if (classType is ClassDeclarationSyntax)
        //    {
        //        retObj = new Class();
        //        classType = classType as ClassDeclarationSyntax;
        //    }
        //    else if (classType is StructDeclarationSyntax)
        //    {
        //        retObj = new Struct();
        //        classType = classType as StructDeclarationSyntax;
        //    }
        //        //Class retObj = new Class();
        //        //Name
        //        (retObj is Class ? retObj as Class : retObj as Struct).Name = (classType is ClassDeclarationSyntax ? (ClassDeclarationSyntax)classType : (StructDeclarationSyntax)classType).Identifier.ValueText;
        //        //encapsulation
        //        foreach (SyntaxToken st in classType.Modifiers)
        //        {
        //            string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
        //            retObj.Encapsulation.Add((Encapsulation)System.Enum.Parse(typeof(Encapsulation), modifier));
        //        }
        //        var enums = from aEnu in classType.ChildNodes().OfType<EnumDeclarationSyntax>() select aEnu;
        //        foreach (EnumDeclarationSyntax eds in enums)
        //        {
        //            retObj.Enums.Add(TraverseEnums(eds));
        //        }
        //        var structs = from aStruct in classType.ChildNodes().OfType<StructDeclarationSyntax>() select aStruct;
        //        foreach (StructDeclarationSyntax sds in structs)
        //        {
        //            retObj.Structs.Add(TransverseStructs(sds));
        //        }
        //        var methods = from aMethod in classType.ChildNodes().OfType<MethodDeclarationSyntax>() select aMethod;
        //        foreach (MethodDeclarationSyntax mds in methods)
        //        {
        //            retObj.Methods.Add(TransverseMethods(mds));
        //        }
        //        var fields = from aField in classType.ChildNodes().OfType<FieldDeclarationSyntax>() select aField;
        //        foreach (FieldDeclarationSyntax fds in fields)
        //        {
        //            retObj.Attributes.Add(TransverseVariables(fds));
        //        }
        //        //var properties = from aProperty in classType.ChildNodes().OfType<PropertyDeclarationSyntax>() select aProperty;
        //        //foreach (PropertyDeclarationSyntax pds in properties)
        //        //{
        //        //    //traverse attributes
        //        //}
        //        var constructors = from aConstructor in classType.ChildNodes().OfType<ConstructorDeclarationSyntax>() select aConstructor;
        //        foreach (ConstructorDeclarationSyntax cods in constructors)
        //        {
        //            retObj.Constructors.Add(TransverseConstructors(cods));
        //        }
        //        var destructors = from aDestructor in classType.ChildNodes().OfType<DestructorDeclarationSyntax>() select aDestructor;
        //        foreach (DestructorDeclarationSyntax dds in destructors)
        //        {
        //            retObj.Destructors.Add(TransverseDestructors(dds));
        //        }
        //        var classes = from aClass in classType.ChildNodes().OfType<ClassDeclarationSyntax>() select aClass;
        //        foreach (ClassDeclarationSyntax classType2 in classes)
        //        {
        //            retObj.Classes.Add(TraverseClass(classType2));
        //        }
        //        return retObj;
        //}
        private Method TransverseMethods(MethodDeclarationSyntax mds)
        {
            Method retMethod = new Method();
            //public int DecisionsCount { get; }
            //public int ExitPoints { get; set; }
            //public bool IsFriend { get; }
            //public bool IsPolymophic { get; }
            //public bool IsPublic { get; }
            //public bool IsStatic { get; }
            //public List<Preprocessor> Preprocessors { get; set; }
            retMethod.Name = mds.Identifier.ValueText;

            if (mds.HasLeadingTrivia)
            {
                SetOuterComments(retMethod, mds.GetLeadingTrivia().ToFullString());
            }

            if (mds.HasTrailingTrivia)
            {
                SetInnerComments(retMethod, mds.GetTrailingTrivia().ToFullString());
            }

            foreach (SyntaxToken st in mds.Modifiers)
            {
                string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
                Encapsulation encap;
                Qualifiers qual;
                if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
                {
                    retMethod.Encapsulation.Add(encap);
                }
                else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
                {
                    retMethod.Qualifiers.Add(qual);
                }
            }
//.........这里部分代码省略.........