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;
}
}
}
