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); }
/// <summary> /// Ajoute/corrige la ligne de documentation à/de la méthode. /// </summary> /// <param name="document">Le document du contexte.</param> /// <param name="méthode">La méthode à documenter.</param> /// <param name="jetonAnnulation">Le jeton d'annulation.</param> /// <returns>Le document mis à jour.</returns> private static async Task<Document> AjouterInheritDoc(Document document, MethodDeclarationSyntax méthode, CancellationToken jetonAnnulation) { // On récupère la recine et le modèle sémantique. var racine = await document .GetSyntaxRootAsync(jetonAnnulation) .ConfigureAwait(false); var modèleSémantique = await document.GetSemanticModelAsync(jetonAnnulation); // On a déjà trouvé le inheritDoc dans le diagnostic mais on ne peut pas vraiment le passer au correctif... var inheritDoc = Partagé.InheritDocEstCorrect(racine, modèleSémantique, méthode); // Ajoute la ligne de commentaire à la méthode. var méthodeCommentée = méthode .WithLeadingTrivia(SyntaxFactory.LineFeed, SyntaxFactory.Comment(inheritDoc), SyntaxFactory.LineFeed) .WithAdditionalAnnotations(Formatter.Annotation); // Met à jour la racine. var nouvelleRacine = racine.ReplaceNode(méthode, méthodeCommentée); return document.WithSyntaxRoot(nouvelleRacine); }
/// <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); }