public static SyntaxToken WithoutTrivia(this SyntaxToken token) { var trivia = token.GetAllTrivia(); var newToken = token.ReplaceTrivia(trivia, (o, _) => default(SyntaxTrivia)); return(newToken); }
private void VisitToken(SyntaxToken token) { if (token.HasStructuredTrivia) { foreach (var trivia in token.GetAllTrivia()) { Visit(trivia.GetStructure()); } } }
private static DgmlNode ProcessToken(SyntaxToken token, int indent = 0) { var dgmlNode = DgmlNode.Create(token); PrintNode(dgmlNode, indent); foreach (var trivia in token.GetAllTrivia()) { dgmlNode.AddChild(ProcessTrivia(trivia, indent + 1)); } return(dgmlNode); }
public static bool HasNoneWhitespaceTrivia(this SyntaxToken token, SyntaxKind[] exceptionList = null) { if (token.ContainsDirectives) { return(true); } if (token.HasStructuredTrivia) { return(true); } if (token.GetAllTrivia().HasNoneWhitespaceTrivia()) { return(true); } return(false); }
public static bool HasNoneWhiteSpaceTrivia(this SyntaxToken token, SyntaxKind[] exceptionList = null) { return (token.ContainsDirectives || token.HasStructuredTrivia || token.GetAllTrivia().HasNoneWhiteSpaceTrivia()); }
private static DgmlNode ProcessToken(SyntaxToken token, int indent = 0) { var dgmlNode = DgmlNode.Create(token); PrintNode(dgmlNode, indent); foreach (var trivia in token.GetAllTrivia()) { dgmlNode.AddChild(ProcessTrivia(trivia, indent + 1)); } return dgmlNode; }
private static Func <CancellationToken, Task <Document> > GetCreateChangedDocument(CodeFixContext context, SyntaxNode node) { switch (node.Kind()) { case SyntaxKind.MethodDeclaration: { var methodDeclaration = (MethodDeclarationSyntax)node; SyntaxToken semicolonToken = methodDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = methodDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { MethodDeclarationSyntax newNode = methodDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.ConstructorDeclaration: { var constructorDeclaration = (ConstructorDeclarationSyntax)node; SyntaxToken semicolonToken = constructorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = constructorDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { ConstructorDeclarationSyntax newNode = constructorDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.DestructorDeclaration: { var destructorDeclaration = (DestructorDeclarationSyntax)node; SyntaxToken semicolonToken = destructorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = destructorDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { DestructorDeclarationSyntax newNode = destructorDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.OperatorDeclaration: { var operatorDeclaration = (OperatorDeclarationSyntax)node; SyntaxToken semicolonToken = operatorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = operatorDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { OperatorDeclarationSyntax newNode = operatorDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.ConversionOperatorDeclaration: { var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)node; SyntaxToken semicolonToken = conversionOperatorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = conversionOperatorDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { ConversionOperatorDeclarationSyntax newNode = conversionOperatorDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.GetAccessorDeclaration: case SyntaxKind.SetAccessorDeclaration: { var accessorDeclaration = (AccessorDeclarationSyntax)node; SyntaxToken semicolonToken = accessorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } return(cancellationToken => { AccessorDeclarationSyntax newNode = accessorDeclaration .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block( Token(default(SyntaxTriviaList), SyntaxKind.OpenBraceToken, TriviaList(ElasticSpace)), default(SyntaxList <StatementSyntax>), Token(default(SyntaxTriviaList), SyntaxKind.CloseBraceToken, semicolonToken.LeadingAndTrailingTrivia()))); SyntaxToken keyword = newNode.Keyword; if (!keyword.HasTrailingTrivia) { newNode = newNode.WithKeyword(keyword.WithTrailingTrivia(ElasticSpace)); } return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.LocalFunctionStatement: { var localFunction = (LocalFunctionStatementSyntax)node; SyntaxToken semicolonToken = localFunction.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = localFunction.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { LocalFunctionStatementSyntax newNode = localFunction .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } } Debug.Fail(node.Kind().ToString()); return(null); }
/// <summary> /// Analyzes class comments. /// </summary> /// <param name="context">Context.</param> private static void AnalyzeSummaryComments(SyntaxNodeAnalysisContext context) { // Get declaration node SyntaxNode declarationNode = context.Node; if (null == declarationNode) { return; } // Check all trivia under the first token SyntaxToken?firstToken = declarationNode?.DescendantTokens().FirstOrDefault(); // No single line comment IEnumerable <SyntaxTrivia> singleLineCommentTrivias = firstToken?.GetAllTrivia().Where(trivia => SyntaxKind.SingleLineCommentTrivia == trivia.Kind()); if (0 < singleLineCommentTrivias.Count()) { BTAnalyzer.ReportDiagnostic(context, singleLineCommentTrivias.First().GetLocation(), ErrorCode.ClassCommentStart); return; } // Only 1 single documentation line comment IEnumerable <SyntaxTrivia> singleDocumentationCommentTrivias = firstToken?.GetAllTrivia().Where(trivia => SyntaxKind.SingleLineDocumentationCommentTrivia == trivia.Kind()); if (0 == singleDocumentationCommentTrivias.Count()) { BTAnalyzer.ReportDiagnostic(context, declarationNode.GetFirstToken().GetLocation(), ErrorCode.MissingComment); return; } else if (1 < singleDocumentationCommentTrivias.Count()) { BTAnalyzer.ReportDiagnostic(context, declarationNode.GetFirstToken().GetLocation(), ErrorCode.ErrorsInComment); return; } // Get the only single line documentation comment trivia SyntaxTrivia singleDocCommentTrivia = singleDocumentationCommentTrivias.First(); List <string> messageList = new List <string>(); List <Location> locationList = new List <Location>(); List <string> paramCommentNameList = new List <string>(); int returnCount = 0; if (!BTAnalyzer.CheckDocumentationCommentTrivia(singleDocCommentTrivia, declarationNode.Kind(), ref messageList, ref locationList, ref paramCommentNameList, ref returnCount)) { for (int i = 0; i < messageList.Count(); i++) { BTAnalyzer.ReportDiagnostic(context, locationList[i], messageList[i]); } } // Check method declaration // Check parameter comments MethodDeclarationSyntax methodDeclarationSyntax = declarationNode as MethodDeclarationSyntax; if (null == methodDeclarationSyntax) { return; } // Check parameter comment count IEnumerable <ParameterSyntax> parameters = methodDeclarationSyntax.ParameterList.Parameters; if (paramCommentNameList.Count() != parameters.Count()) { BTAnalyzer.ReportDiagnostic(context, methodDeclarationSyntax.ParameterList.GetLocation(), ErrorCode.IncompatibleParamComments); } // Check that all parameters have comment foreach (ParameterSyntax parameter in parameters) { if (!paramCommentNameList.Any(p => p == parameter.Identifier.Text)) { BTAnalyzer.ReportDiagnostic(context, parameter.GetLocation(), ErrorCode.MissingParamComment); break; } } // Check number of returns comments if ("void" == methodDeclarationSyntax.ReturnType.ToString()) { if (0 < returnCount) { BTAnalyzer.ReportDiagnostic(context, methodDeclarationSyntax.ReturnType.GetLocation(), ErrorCode.IncorrectReturnComment); return; } } else { if (1 != returnCount) { BTAnalyzer.ReportDiagnostic(context, methodDeclarationSyntax.ReturnType.GetLocation(), ErrorCode.IncorrectReturnComment); return; } } }