private static void AnalyzeArrowExpressionClause(SyntaxNodeAnalysisContext context)
{
var arrowExpressionClause = (ArrowExpressionClauseSyntax)context.Node;
SyntaxToken arrowToken = arrowExpressionClause.ArrowToken;
SyntaxToken previousToken = arrowToken.GetPreviousToken();
if (!SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(previousToken.TrailingTrivia))
{
return;
}
if (arrowToken.LeadingTrivia.Any())
{
return;
}
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(arrowToken.TrailingTrivia))
{
return;
}
if (!SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(arrowExpressionClause.Expression.GetLeadingTrivia()))
{
return;
}
context.ReportDiagnostic(DiagnosticDescriptors.AddNewLineBeforeExpressionBodyArrowInsteadOfAfterIt, arrowToken);
}
private static void AnalyzeElseClause(SyntaxNodeAnalysisContext context)
{
var elseClause = (ElseClauseSyntax)context.Node;
StatementSyntax statement = elseClause.Statement;
if (!statement.IsKind(SyntaxKind.IfStatement))
{
return;
}
SyntaxTriviaList trailingTrivia = elseClause.ElseKeyword.TrailingTrivia;
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia))
{
return;
}
if (!statement.GetLeadingTrivia().IsEmptyOrWhitespace())
{
return;
}
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.RemoveNewLineBetweenIfKeywordAndElseKeyword,
Location.Create(elseClause.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0)));
}
private static void AnalyzeCompilationUnit(SyntaxNodeAnalysisContext context)
{
var compilationUnit = (CompilationUnitSyntax)context.Node;
MemberDeclarationSyntax declaration = compilationUnit.Members.FirstOrDefault();
if (declaration == null)
{
return;
}
if (!SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(declaration.GetLeadingTrivia()))
{
return;
}
SyntaxNode node = compilationUnit.AttributeLists.LastOrDefault()
?? (SyntaxNode)compilationUnit.Usings.LastOrDefault()
?? compilationUnit.Externs.LastOrDefault();
if (node == null)
{
return;
}
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(node.GetTrailingTrivia()))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.AddEmptyLineBeforeTopDeclaration,
Location.Create(compilationUnit.SyntaxTree, new TextSpan(node.GetTrailingTrivia().Last().SpanStart, 0)));
}
private static void AnalyzeSwitchStatement(SyntaxNodeAnalysisContext context)
{
var switchStatement = (SwitchStatementSyntax)context.Node;
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
SyntaxList <SwitchSectionSyntax> .Enumerator en = sections.GetEnumerator();
if (!en.MoveNext())
{
return;
}
SwitchSectionSyntax previousSection = en.Current;
while (en.MoveNext())
{
SyntaxTriviaList leadingTrivia = en.Current.Labels[0].GetLeadingTrivia();
if (SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(leadingTrivia))
{
SyntaxTriviaList trailingTrivia = previousSection.GetTrailingTrivia();
if (SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.AddEmptyLineBetweenSwitchSections,
Location.Create(switchStatement.SyntaxTree, trailingTrivia.Last().Span.WithLength(0)));
}
}
previousSection = en.Current;
}
}
private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
{
var binaryExpression = (BinaryExpressionSyntax)context.Node;
ExpressionSyntax left = binaryExpression.Left;
if (left.IsMissing)
{
return;
}
ExpressionSyntax right = binaryExpression.Right;
if (right.IsMissing)
{
return;
}
if (!SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(left, binaryExpression.OperatorToken, right))
{
return;
}
if (CSharpUtility.IsStringConcatenation(binaryExpression, context.SemanticModel, context.CancellationToken))
{
return;
}
context.ReportDiagnostic(
DiagnosticDescriptors.AddNewLineAfterBinaryOperatorInsteadOfBeforeIt,
Location.Create(binaryExpression.SyntaxTree, binaryExpression.OperatorToken.Span.WithLength(0)));
}
private static void AnalyzeConditionalExpression(SyntaxNodeAnalysisContext context)
{
var conditionalExpression = (ConditionalExpressionSyntax)context.Node;
ExpressionSyntax condition = conditionalExpression.Condition;
if (condition.IsMissing)
{
return;
}
ExpressionSyntax whenTrue = conditionalExpression.WhenTrue;
if (whenTrue.IsMissing)
{
return;
}
if (SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(condition, conditionalExpression.QuestionToken, whenTrue))
{
ReportDiagnostic(context, conditionalExpression.QuestionToken);
}
else
{
ExpressionSyntax whenFalse = conditionalExpression.WhenFalse;
if (!whenFalse.IsMissing &&
SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(whenTrue, conditionalExpression.ColonToken, whenFalse))
{
ReportDiagnostic(context, conditionalExpression.ColonToken);
}
}
}
public static FormattingSuggestion AnalyzeNewLineBeforeOrAfter(
SyntaxToken token,
ExpressionSyntax expression,
NewLinePosition newLinePosition)
{
SyntaxToken previousToken = token.GetPreviousToken();
if (newLinePosition == NewLinePosition.Before &&
SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(previousToken.TrailingTrivia))
{
if (!token.LeadingTrivia.Any() &&
SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(token.TrailingTrivia) &&
SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(expression.GetLeadingTrivia()))
{
return(FormattingSuggestion.AddNewLineBefore);
}
}
else if (newLinePosition == NewLinePosition.After &&
SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(previousToken.TrailingTrivia))
{
if (SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(token.LeadingTrivia) &&
SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(token.TrailingTrivia) &&
!expression.GetLeadingTrivia().Any())
{
return(FormattingSuggestion.AddNewLineAfter);
}
}
return(FormattingSuggestion.None);
}
private static void AnalyzeDoStatement(SyntaxNodeAnalysisContext context)
{
var doStatement = (DoStatementSyntax)context.Node;
StatementSyntax statement = doStatement.Statement;
if (!statement.IsKind(SyntaxKind.Block))
{
return;
}
SyntaxTriviaList trailingTrivia = statement.GetTrailingTrivia();
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia))
{
return;
}
if (!doStatement.WhileKeyword.LeadingTrivia.IsEmptyOrWhitespace())
{
return;
}
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveNewLineBetweenClosingBraceAndWhileKeyword,
Location.Create(doStatement.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0)));
}
public static FormattingSuggestion AnalyzeNewLineBeforeOrAfter(
SyntaxNodeAnalysisContext context,
SyntaxToken token,
ExpressionSyntax expression,
AnalyzerOptionDescriptor afterDescriptor)
{
SyntaxToken previousToken = token.GetPreviousToken();
if (SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(previousToken.TrailingTrivia))
{
if (!token.LeadingTrivia.Any() &&
SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(token.TrailingTrivia) &&
SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(expression.GetLeadingTrivia()) &&
!afterDescriptor.IsEnabled(context))
{
return(FormattingSuggestion.AddNewLineBefore);
}
}
else if (SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(previousToken.TrailingTrivia))
{
if (SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(token.LeadingTrivia) &&
SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(token.TrailingTrivia) &&
!expression.GetLeadingTrivia().Any() &&
afterDescriptor.IsEnabled(context))
{
return(FormattingSuggestion.AddNewLineAfter);
}
}
return(FormattingSuggestion.None);
}
private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext context)
{
var initializer = (InitializerExpressionSyntax)context.Node;
SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions;
ExpressionSyntax expression = expressions.SingleOrDefault(shouldThrow: false);
if (expression == null)
{
return;
}
if (initializer.SpanContainsDirectives())
{
return;
}
if (initializer.IsSingleLine(includeExteriorTrivia: false))
{
return;
}
if (!expression.IsSingleLine())
{
return;
}
if (!SyntaxTriviaAnalysis.IsExteriorTriviaEmptyOrWhitespace(expression))
{
return;
}
if (!SyntaxTriviaAnalysis.IsExteriorTriviaEmptyOrWhitespace(initializer.OpenBraceToken))
{
return;
}
if (!initializer.CloseBraceToken.LeadingTrivia.IsEmptyOrWhitespace())
{
return;
}
if (expressions.SeparatorCount == 1 &&
!SyntaxTriviaAnalysis.IsExteriorTriviaEmptyOrWhitespace(expressions.GetSeparator(0)))
{
return;
}
if (!initializer.OpenBraceToken.GetPreviousToken().TrailingTrivia.IsEmptyOrWhitespace())
{
return;
}
context.ReportDiagnostic(DiagnosticDescriptors.RemoveNewlinesFromInitializerWithSingleLineExpression, initializer);
}
private static void AnalyzeAccessorList(SyntaxNodeAnalysisContext context)
{
var accessorList = (AccessorListSyntax)context.Node;
SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors;
if (accessors.Count <= 1)
{
return;
}
Debug.Assert(accessors.Count == 2, accessors.Count.ToString());
AccessorDeclarationSyntax accessor1 = accessors[0];
if (accessor1.BodyOrExpressionBody() == null)
{
return;
}
AccessorDeclarationSyntax accessor2 = accessors[1];
if (accessor2.BodyOrExpressionBody() == null)
{
return;
}
SyntaxTriviaList trailingTrivia = accessor1.GetTrailingTrivia();
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia))
{
return;
}
SyntaxTriviaList leadingTrivia = accessor2.GetLeadingTrivia();
bool isEmptyLine = SyntaxTriviaAnalysis.StartsWithOptionalWhitespaceThenEndOfLineTrivia(leadingTrivia);
if (accessorList.SyntaxTree.IsSingleLineSpan(accessor1.Span, context.CancellationToken) &&
accessorList.SyntaxTree.IsSingleLineSpan(accessor2.Span, context.CancellationToken))
{
if (isEmptyLine)
{
ReportDiagnostic(context, DiagnosticDescriptors.RemoveEmptyLineBetweenSingleLineAccessors, leadingTrivia[0]);
}
else
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenSingleLineAccessors, trailingTrivia.Last());
}
}
else if (!isEmptyLine)
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenAccessors, trailingTrivia.Last());
}
}
private static void AnalyzeCompilationUnit(SyntaxNodeAnalysisContext context)
{
var compilationUnit = (CompilationUnitSyntax)context.Node;
UsingDirectiveSyntax usingDirective = compilationUnit.Usings.FirstOrDefault();
if (usingDirective == null)
{
return;
}
SyntaxTriviaList.Reversed.Enumerator en = usingDirective.GetLeadingTrivia().Reverse().GetEnumerator();
if (en.MoveNext())
{
if (en.Current.IsWhitespaceTrivia() &&
!en.MoveNext())
{
if (IsPrecededWithExternAliasDirective())
{
ReportDiagnostic(usingDirective.SpanStart);
}
}
else if (en.Current.IsEndOfLineTrivia() &&
en.MoveNext() &&
en.Current.IsKind(SyntaxKind.SingleLineCommentTrivia))
{
ReportDiagnostic(usingDirective.SpanStart);
}
}
else if (IsPrecededWithExternAliasDirective())
{
ReportDiagnostic(usingDirective.SpanStart);
}
bool IsPrecededWithExternAliasDirective()
{
ExternAliasDirectiveSyntax externAliasDirective = compilationUnit.Externs.LastOrDefault();
return(externAliasDirective?.FullSpan.End == usingDirective.FullSpan.Start &&
SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(externAliasDirective.GetTrailingTrivia()));
}
void ReportDiagnostic(int position)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.AddEmptyLineBeforeUsingDirectiveList,
Location.Create(compilationUnit.SyntaxTree, new TextSpan(position, 0)));
}
}
private static void AnalyzeConditionalAccess(SyntaxNodeAnalysisContext context)
{
var conditionalAccess = (ConditionalAccessExpressionSyntax)context.Node;
ExpressionSyntax left = conditionalAccess.Expression;
if (left.IsMissing)
{
return;
}
ExpressionSyntax right = conditionalAccess.WhenNotNull;
if (right.IsMissing)
{
return;
}
NewLinePosition newLinePosition = context.GetNullConditionalOperatorNewLinePosition();
if (newLinePosition == NewLinePosition.None)
{
return;
}
SyntaxToken operatorToken = conditionalAccess.OperatorToken;
if (SyntaxTriviaAnalysis.IsTokenFollowedWithNewLineAndNotPrecededWithNewLine(left, operatorToken, right))
{
if (newLinePosition == NewLinePosition.Before)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.PlaceNewLineAfterOrBeforeNullConditionalOperator,
operatorToken,
"before");
}
}
else if (SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(left, operatorToken, right) &&
newLinePosition == NewLinePosition.After)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.PlaceNewLineAfterOrBeforeNullConditionalOperator,
Location.Create(conditionalAccess.SyntaxTree, operatorToken.Span),
DiagnosticProperties.NewLinePosition_After,
"after");
}
}
private static void Analyze(
SyntaxNodeAnalysisContext context,
UsingDirectiveSyntax usingDirective,
SyntaxToken nextToken)
{
SyntaxTriviaList trailingTrivia = usingDirective.GetTrailingTrivia();
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(triviaList: trailingTrivia))
{
return;
}
SyntaxTriviaList.Enumerator en = nextToken.LeadingTrivia.GetEnumerator();
if (en.MoveNext())
{
if (en.Current.IsWhitespaceTrivia() &&
!en.MoveNext())
{
ReportDiagnostic(trailingTrivia.Last().SpanStart);
}
else
{
switch (en.Current.Kind())
{
case SyntaxKind.SingleLineCommentTrivia:
case SyntaxKind.SingleLineDocumentationCommentTrivia:
case SyntaxKind.MultiLineDocumentationCommentTrivia:
{
ReportDiagnostic(trailingTrivia.Last().SpanStart);
break;
}
}
}
}
else
{
ReportDiagnostic(trailingTrivia.Last().SpanStart);
}
void ReportDiagnostic(int position)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.AddBlankLineAfterUsingDirectiveList,
Location.Create(usingDirective.SyntaxTree, new TextSpan(position, 0)));
}
}
private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
{
var binaryExpression = (BinaryExpressionSyntax)context.Node;
ExpressionSyntax left = binaryExpression.Left;
if (left.IsMissing)
{
return;
}
ExpressionSyntax right = binaryExpression.Right;
if (right.IsMissing)
{
return;
}
NewLinePosition newLinePosition = context.GetBinaryExpressionNewLinePosition();
if (newLinePosition == NewLinePosition.None)
{
return;
}
if (SyntaxTriviaAnalysis.IsTokenFollowedWithNewLineAndNotPrecededWithNewLine(left, binaryExpression.OperatorToken, right))
{
if (newLinePosition == NewLinePosition.Before)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.PlaceNewLineAfterOrBeforeBinaryOperator,
Location.Create(binaryExpression.SyntaxTree, binaryExpression.OperatorToken.Span.WithLength(0)),
"before");
}
}
else if (SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(left, binaryExpression.OperatorToken, right) &&
newLinePosition == NewLinePosition.After)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.PlaceNewLineAfterOrBeforeBinaryOperator,
Location.Create(binaryExpression.SyntaxTree, binaryExpression.OperatorToken.Span.WithLength(0)),
properties: DiagnosticProperties.AnalyzerOption_Invert,
"after");
}
}
private static void AnalyzeDoStatement(SyntaxNodeAnalysisContext context)
{
var doStatement = (DoStatementSyntax)context.Node;
StatementSyntax statement = doStatement.Statement;
if (!statement.IsKind(SyntaxKind.Block))
{
return;
}
NewLineStyle newLineStyle = context.GetNewLineBeforeWhileInDoStatement();
if (newLineStyle == NewLineStyle.None)
{
return;
}
SyntaxTriviaList trailingTrivia = statement.GetTrailingTrivia();
if (!trailingTrivia.Any() ||
trailingTrivia.SingleOrDefault(shouldThrow: false).IsWhitespaceTrivia())
{
if (!doStatement.WhileKeyword.LeadingTrivia.Any() &&
newLineStyle == NewLineStyle.Add)
{
context.ReportDiagnostic(
DiagnosticRules.AddOrRemoveNewLineBeforeWhileInDoStatement,
Location.Create(doStatement.SyntaxTree, new TextSpan(statement.FullSpan.End, 0)),
"Add");
}
}
else if (SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia))
{
if (doStatement.WhileKeyword.LeadingTrivia.IsEmptyOrWhitespace() &&
newLineStyle == NewLineStyle.Remove)
{
context.ReportDiagnostic(
DiagnosticRules.AddOrRemoveNewLineBeforeWhileInDoStatement,
Location.Create(doStatement.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0)),
properties: DiagnosticProperties.AnalyzerOption_Invert,
"Remove");
}
}
}
private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
{
var binaryExpression = (BinaryExpressionSyntax)context.Node;
ExpressionSyntax left = binaryExpression.Left;
if (left.IsMissing)
{
return;
}
ExpressionSyntax right = binaryExpression.Right;
if (right.IsMissing)
{
return;
}
if (SyntaxTriviaAnalysis.IsTokenFollowedWithNewLineAndNotPrecededWithNewLine(left, binaryExpression.OperatorToken, right))
{
if (context.IsAnalyzerSuppressed(AnalyzerOptions.AddNewLineAfterBinaryOperatorInsteadOfBeforeIt))
{
ReportDiagnostic(DiagnosticDescriptors.AddNewLineBeforeBinaryOperatorInsteadOfAfterItOrViceVersa, ImmutableDictionary <string, string> .Empty);
}
}
else if (SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(left, binaryExpression.OperatorToken, right) &&
!context.IsAnalyzerSuppressed(AnalyzerOptions.AddNewLineAfterBinaryOperatorInsteadOfBeforeIt))
{
ReportDiagnostic(DiagnosticDescriptors.ReportOnly.AddNewLineAfterBinaryOperatorInsteadOfBeforeIt, DiagnosticProperties.AnalyzerOption_Invert);
}
void ReportDiagnostic(DiagnosticDescriptor descriptor, ImmutableDictionary <string, string> properties)
{
if (CSharpUtility.IsStringConcatenation(binaryExpression, context.SemanticModel, context.CancellationToken))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(
context,
descriptor,
Location.Create(binaryExpression.SyntaxTree, binaryExpression.OperatorToken.Span.WithLength(0)),
properties: properties);
}
}
private static void Analyze(SyntaxNodeAnalysisContext context, BaseListSyntax baseList, SyntaxToken previousToken)
{
SyntaxTriviaList trailingTrivia = previousToken.TrailingTrivia;
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia))
{
return;
}
if (!baseList.ColonToken.LeadingTrivia.IsEmptyOrWhitespace())
{
return;
}
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveNewLineBeforeBaseList,
Location.Create(baseList.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0)));
}
private static void AnalyzeSwitchStatement(SyntaxNodeAnalysisContext context)
{
var switchStatement = (SwitchStatementSyntax)context.Node;
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
SyntaxList <SwitchSectionSyntax> .Enumerator en = sections.GetEnumerator();
if (!en.MoveNext())
{
return;
}
SwitchSectionSyntax previousSection = en.Current;
var previousBlock = previousSection.Statements.SingleOrDefault(shouldThrow: false) as BlockSyntax;
while (en.MoveNext())
{
SyntaxTriviaList leadingTrivia = en.Current.Labels[0].GetLeadingTrivia();
if (SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(leadingTrivia))
{
SyntaxTriviaList trailingTrivia = previousSection.GetTrailingTrivia();
if (SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia) &&
(context.GetBlankLineBetweenClosingBraceAndSwitchSection() != false ||
previousBlock == null))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.AddBlankLineBetweenSwitchSections,
Location.Create(switchStatement.SyntaxTree, trailingTrivia.Last().Span.WithLength(0)));
}
}
previousSection = en.Current;
previousBlock = en.Current.Statements.SingleOrDefault(shouldThrow: false) as BlockSyntax;
}
}
private static void AnalyzeDoStatement(SyntaxNodeAnalysisContext context)
{
var doStatement = (DoStatementSyntax)context.Node;
StatementSyntax statement = doStatement.Statement;
if (!statement.IsKind(SyntaxKind.Block))
{
return;
}
SyntaxTriviaList trailingTrivia = statement.GetTrailingTrivia();
if (!trailingTrivia.Any() ||
trailingTrivia.SingleOrDefault(shouldThrow: false).IsWhitespaceTrivia())
{
if (!doStatement.WhileKeyword.LeadingTrivia.Any() &&
!AnalyzerOptions.RemoveNewLineBetweenClosingBraceAndWhileKeyword.IsEnabled(context))
{
context.ReportDiagnostic(
DiagnosticRules.AddNewLineBetweenClosingBraceAndWhileKeywordOrViceVersa,
Location.Create(doStatement.SyntaxTree, new TextSpan(statement.FullSpan.End, 0)),
AnalyzerOptions.RemoveNewLineBetweenClosingBraceAndWhileKeyword);
}
}
else if (SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia))
{
if (doStatement.WhileKeyword.LeadingTrivia.IsEmptyOrWhitespace() &&
AnalyzerOptions.RemoveNewLineBetweenClosingBraceAndWhileKeyword.IsEnabled(context))
{
context.ReportDiagnostic(
DiagnosticRules.ReportOnly.RemoveNewLineBetweenClosingBraceAndWhileKeyword,
Location.Create(doStatement.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0)),
properties: DiagnosticProperties.AnalyzerOption_Invert,
AnalyzerOptions.RemoveNewLineBetweenClosingBraceAndWhileKeyword);
}
}
}
private static void AnalyzeArrowExpressionClause(SyntaxNodeAnalysisContext context)
{
var arrowExpressionClause = (ArrowExpressionClauseSyntax)context.Node;
SyntaxToken arrowToken = arrowExpressionClause.ArrowToken;
SyntaxToken previousToken = arrowToken.GetPreviousToken();
if (SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(previousToken.TrailingTrivia))
{
if (!arrowToken.LeadingTrivia.Any() &&
SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(arrowToken.TrailingTrivia) &&
SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(arrowExpressionClause.Expression.GetLeadingTrivia()) &&
context.IsAnalyzerSuppressed(AnalyzerOptions.AddNewLineAfterExpressionBodyArrowInsteadOfBeforeIt))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.AddNewLineBeforeExpressionBodyArrowInsteadOfAfterItOrViceVersa,
arrowToken.GetLocation());
}
}
else if (SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(previousToken.TrailingTrivia))
{
if (SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(arrowToken.LeadingTrivia) &&
SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(arrowToken.TrailingTrivia) &&
!arrowExpressionClause.Expression.GetLeadingTrivia().Any() &&
!context.IsAnalyzerSuppressed(AnalyzerOptions.AddNewLineAfterExpressionBodyArrowInsteadOfBeforeIt))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.ReportOnly.AddNewLineAfterExpressionBodyArrowInsteadOfBeforeIt,
arrowToken.GetLocation(),
properties: DiagnosticProperties.AnalyzerOption_Invert);
}
}
}
private static void AnalyzeUsings(SyntaxNodeAnalysisContext context, SyntaxList <UsingDirectiveSyntax> usings)
{
int count = usings.Count;
if (count <= 1)
{
return;
}
UsingDirectiveSyntax usingDirective1 = usings[0];
for (int i = 1; i < count; i++, usingDirective1 = usings[i - 1])
{
if (usingDirective1.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
return;
}
if (usingDirective1.Alias != null)
{
return;
}
UsingDirectiveSyntax usingDirective2 = usings[i];
if (usingDirective2.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
return;
}
if (usingDirective2.Alias != null)
{
return;
}
SyntaxTriviaList trailingTrivia = usingDirective1.GetTrailingTrivia();
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia))
{
continue;
}
IdentifierNameSyntax rootNamespace1 = usingDirective1.GetRootNamespace();
if (rootNamespace1 == null)
{
continue;
}
IdentifierNameSyntax rootNamespace2 = usingDirective2.GetRootNamespace();
if (rootNamespace2 == null)
{
continue;
}
SyntaxTriviaList leadingTrivia = usingDirective2.GetLeadingTrivia();
bool isEmptyLine = SyntaxTriviaAnalysis.StartsWithOptionalWhitespaceThenEndOfLineTrivia(leadingTrivia);
if (string.Equals(rootNamespace1.Identifier.ValueText, rootNamespace2.Identifier.ValueText, StringComparison.Ordinal))
{
if (isEmptyLine)
{
if (DiagnosticRules.RemoveBlankLineBetweenUsingDirectivesWithSameRootNamespace.IsEffective(context))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.RemoveBlankLineBetweenUsingDirectivesWithSameRootNamespace,
Location.Create(context.Node.SyntaxTree, leadingTrivia[0].Span.WithLength(0)));
}
if (DiagnosticRules.BlankLineBetweenUsingDirectives.IsEffective(context) &&
context.GetBlankLineBetweenUsingDirectives() == UsingDirectiveBlankLineStyle.Never)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.BlankLineBetweenUsingDirectives,
Location.Create(context.Node.SyntaxTree, leadingTrivia[0].Span.WithLength(0)),
properties: DiagnosticProperties.AnalyzerOption_Invert,
"Remove");
}
}
}
else if (DiagnosticRules.BlankLineBetweenUsingDirectives.IsEffective(context))
{
UsingDirectiveBlankLineStyle style = context.GetBlankLineBetweenUsingDirectives();
if (isEmptyLine)
{
if (style == UsingDirectiveBlankLineStyle.Never)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.BlankLineBetweenUsingDirectives,
Location.Create(context.Node.SyntaxTree, leadingTrivia[0].Span.WithLength(0)),
properties: DiagnosticProperties.AnalyzerOption_Invert,
"Remove");
}
}
else if (style == UsingDirectiveBlankLineStyle.SeparateGroups)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.BlankLineBetweenUsingDirectives,
Location.Create(context.Node.SyntaxTree, trailingTrivia.Last().Span.WithLength(0)),
"Add");
}
}
}
}
private static void AnalyzeConditionalExpression(SyntaxNodeAnalysisContext context)
{
var conditionalExpression = (ConditionalExpressionSyntax)context.Node;
ExpressionSyntax condition = conditionalExpression.Condition;
if (condition.IsMissing)
{
return;
}
ExpressionSyntax whenTrue = conditionalExpression.WhenTrue;
if (whenTrue.IsMissing)
{
return;
}
NewLinePosition newLinePosition = context.GetConditionalExpressionNewLinePosition();
if (newLinePosition == NewLinePosition.None)
{
return;
}
if (SyntaxTriviaAnalysis.IsTokenFollowedWithNewLineAndNotPrecededWithNewLine(condition, conditionalExpression.QuestionToken, whenTrue))
{
if (newLinePosition == NewLinePosition.Before)
{
ReportDiagnostic(conditionalExpression.QuestionToken, ImmutableDictionary <string, string> .Empty, "before");
return;
}
}
else if (SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(condition, conditionalExpression.QuestionToken, whenTrue))
{
if (newLinePosition == NewLinePosition.After)
{
ReportDiagnostic(conditionalExpression.QuestionToken, DiagnosticProperties.AnalyzerOption_Invert, "after");
return;
}
}
ExpressionSyntax whenFalse = conditionalExpression.WhenFalse;
if (!whenFalse.IsMissing)
{
if (SyntaxTriviaAnalysis.IsTokenFollowedWithNewLineAndNotPrecededWithNewLine(whenTrue, conditionalExpression.ColonToken, whenFalse))
{
if (newLinePosition == NewLinePosition.Before)
{
ReportDiagnostic(conditionalExpression.ColonToken, ImmutableDictionary <string, string> .Empty, "before");
}
}
else if (SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(whenTrue, conditionalExpression.ColonToken, whenFalse))
{
if (newLinePosition == NewLinePosition.After)
{
ReportDiagnostic(conditionalExpression.ColonToken, DiagnosticProperties.AnalyzerOption_Invert, "after");
}
}
}
void ReportDiagnostic(
SyntaxToken token,
ImmutableDictionary <string, string> properties,
string messageArg)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.PlaceNewLineAfterOrBeforeConditionalOperator,
Location.Create(token.SyntaxTree, token.Span.WithLength(0)),
properties: properties,
messageArg);
}
}
private static void AnalyzeConditionalExpression(SyntaxNodeAnalysisContext context)
{
var conditionalExpression = (ConditionalExpressionSyntax)context.Node;
ExpressionSyntax condition = conditionalExpression.Condition;
if (condition.IsMissing)
{
return;
}
ExpressionSyntax whenTrue = conditionalExpression.WhenTrue;
if (whenTrue.IsMissing)
{
return;
}
if (SyntaxTriviaAnalysis.IsTokenFollowedWithNewLineAndNotPrecededWithNewLine(condition, conditionalExpression.QuestionToken, whenTrue))
{
if (!AnalyzerOptions.AddNewLineAfterConditionalOperatorInsteadOfBeforeIt.IsEnabled(context))
{
ReportDiagnostic(DiagnosticRules.AddNewLineBeforeConditionalOperatorInsteadOfAfterItOrViceVersa, conditionalExpression.QuestionToken, ImmutableDictionary <string, string> .Empty);
return;
}
}
else if (SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(condition, conditionalExpression.QuestionToken, whenTrue))
{
if (AnalyzerOptions.AddNewLineAfterConditionalOperatorInsteadOfBeforeIt.IsEnabled(context))
{
ReportDiagnostic(DiagnosticRules.ReportOnly.AddNewLineAfterConditionalOperatorInsteadOfBeforeIt, conditionalExpression.QuestionToken, DiagnosticProperties.AnalyzerOption_Invert);
return;
}
}
ExpressionSyntax whenFalse = conditionalExpression.WhenFalse;
if (!whenFalse.IsMissing)
{
if (SyntaxTriviaAnalysis.IsTokenFollowedWithNewLineAndNotPrecededWithNewLine(whenTrue, conditionalExpression.ColonToken, whenFalse))
{
if (!AnalyzerOptions.AddNewLineAfterConditionalOperatorInsteadOfBeforeIt.IsEnabled(context))
{
ReportDiagnostic(DiagnosticRules.AddNewLineBeforeConditionalOperatorInsteadOfAfterItOrViceVersa, conditionalExpression.ColonToken, ImmutableDictionary <string, string> .Empty);
}
}
else if (SyntaxTriviaAnalysis.IsTokenPrecededWithNewLineAndNotFollowedWithNewLine(whenTrue, conditionalExpression.ColonToken, whenFalse))
{
if (AnalyzerOptions.AddNewLineAfterConditionalOperatorInsteadOfBeforeIt.IsEnabled(context))
{
ReportDiagnostic(DiagnosticRules.ReportOnly.AddNewLineAfterConditionalOperatorInsteadOfBeforeIt, conditionalExpression.ColonToken, DiagnosticProperties.AnalyzerOption_Invert);
}
}
}
void ReportDiagnostic(DiagnosticDescriptor descriptor, SyntaxToken token, ImmutableDictionary <string, string> properties)
{
DiagnosticHelpers.ReportDiagnostic(
context,
descriptor,
Location.Create(token.SyntaxTree, token.Span.WithLength(0)),
properties: properties);
}
}
private static void AnalyzeUsings(SyntaxNodeAnalysisContext context, SyntaxList <UsingDirectiveSyntax> usings)
{
int count = usings.Count;
if (count <= 1)
{
return;
}
UsingDirectiveSyntax usingDirective1 = usings[0];
for (int i = 1; i < count; i++, usingDirective1 = usings[i - 1])
{
if (usingDirective1.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
return;
}
if (usingDirective1.Alias != null)
{
return;
}
UsingDirectiveSyntax usingDirective2 = usings[i];
if (usingDirective2.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
return;
}
if (usingDirective2.Alias != null)
{
return;
}
SyntaxTriviaList trailingTrivia = usingDirective1.GetTrailingTrivia();
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia))
{
continue;
}
IdentifierNameSyntax rootNamespace1 = usingDirective1.GetRootNamespace();
if (rootNamespace1 == null)
{
continue;
}
IdentifierNameSyntax rootNamespace2 = usingDirective2.GetRootNamespace();
if (rootNamespace2 == null)
{
continue;
}
SyntaxTriviaList leadingTrivia = usingDirective2.GetLeadingTrivia();
bool isEmptyLine = SyntaxTriviaAnalysis.StartsWithOptionalWhitespaceThenEndOfLineTrivia(leadingTrivia);
if (string.Equals(rootNamespace1.Identifier.ValueText, rootNamespace2.Identifier.ValueText, StringComparison.Ordinal))
{
if (isEmptyLine)
{
DiagnosticHelpers.ReportDiagnosticIfNotSuppressed(
context,
DiagnosticDescriptors.RemoveEmptyLineBetweenUsingDirectivesWithSameRootNamespace,
Location.Create(context.Node.SyntaxTree, leadingTrivia[0].Span.WithLength(0)));
}
}
else if (!context.IsAnalyzerSuppressed(DiagnosticDescriptors.AddEmptyLineBetweenUsingDirectivesWithDifferentRootNamespaceOrViceVersa))
{
if (isEmptyLine)
{
if (!context.IsAnalyzerSuppressed(AnalyzerOptions.RemoveEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.ReportOnly.RemoveEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace,
Location.Create(context.Node.SyntaxTree, leadingTrivia[0].Span.WithLength(0)),
properties: DiagnosticProperties.AnalyzerOption_Invert);
}
}
else if (context.IsAnalyzerSuppressed(AnalyzerOptions.RemoveEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.AddEmptyLineBetweenUsingDirectivesWithDifferentRootNamespaceOrViceVersa,
Location.Create(context.Node.SyntaxTree, trailingTrivia.Last().Span.WithLength(0)));
}
}
}
}
private static void AnalyzeUsings(SyntaxNodeAnalysisContext context, SyntaxList <UsingDirectiveSyntax> usings)
{
int count = usings.Count;
if (count <= 1)
{
return;
}
UsingDirectiveSyntax usingDirective1 = usings[0];
for (int i = 1; i < count; i++, usingDirective1 = usings[i - 1])
{
if (usingDirective1.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
return;
}
if (usingDirective1.Alias != null)
{
return;
}
UsingDirectiveSyntax usingDirective2 = usings[i];
if (usingDirective2.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
return;
}
if (usingDirective2.Alias != null)
{
return;
}
SyntaxTriviaList trailingTrivia = usingDirective1.GetTrailingTrivia();
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia))
{
continue;
}
IdentifierNameSyntax rootNamespace1 = usingDirective1.GetRootNamespace();
if (rootNamespace1 == null)
{
continue;
}
IdentifierNameSyntax rootNamespace2 = usingDirective2.GetRootNamespace();
if (rootNamespace2 == null)
{
continue;
}
SyntaxTriviaList leadingTrivia = usingDirective2.GetLeadingTrivia();
bool isEmptyLine = SyntaxTriviaAnalysis.StartsWithOptionalWhitespaceThenEndOfLineTrivia(leadingTrivia);
if (string.Equals(rootNamespace1.Identifier.ValueText, rootNamespace2.Identifier.ValueText, StringComparison.Ordinal))
{
if (isEmptyLine)
{
ReportDiagnostic(
context,
DiagnosticDescriptors.RemoveEmptyLineBetweenUsingDirectivesWithSameRootNamespace,
leadingTrivia[0]);
}
}
else if (isEmptyLine)
{
ReportDiagnostic(
context,
DiagnosticDescriptors.RemoveEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace,
leadingTrivia[0]);
}
else
{
ReportDiagnostic(
context,
DiagnosticDescriptors.AddEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace,
trailingTrivia.Last());
}
}
}
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxList <MemberDeclarationSyntax> members)
{
int count = members.Count;
if (count <= 1)
{
return;
}
SyntaxTree tree = context.Node.SyntaxTree;
CancellationToken cancellationToken = context.CancellationToken;
MemberDeclarationSyntax member;
MemberDeclarationSyntax previousMember = members[0];
bool?isSingleLine;
bool?isPreviousSingleLine = null;
for (int i = 1; i < count; i++, previousMember = member, isPreviousSingleLine = isSingleLine)
{
member = members[i];
isSingleLine = null;
SyntaxTriviaList trailingTrivia = previousMember.GetTrailingTrivia();
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia))
{
continue;
}
SyntaxTriviaList leadingTrivia = member.GetLeadingTrivia();
(bool emptyOrWhitespaceTrivia, bool documentationComment, bool emptyLine) = AnalyzeLeadingTrivia(leadingTrivia);
if (documentationComment)
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenDeclarationAndDocumentationComment, trailingTrivia.Last());
continue;
}
if (!emptyOrWhitespaceTrivia &&
!emptyLine)
{
continue;
}
if ((isSingleLine ?? (isSingleLine = tree.IsSingleLineSpan(member.Span, cancellationToken)).Value) &&
(isPreviousSingleLine ?? tree.IsSingleLineSpan(members[i - 1].Span, cancellationToken)))
{
if (emptyLine)
{
if (MemberKindEquals(previousMember, member))
{
ReportDiagnostic(context, DiagnosticDescriptors.RemoveEmptyLineBetweenSingleLineDeclarationsOfSameKind, leadingTrivia[0]);
}
}
else if (emptyOrWhitespaceTrivia)
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenSingleLineDeclarations, trailingTrivia.Last());
if (!MemberKindEquals(previousMember, member))
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenSingleLineDeclarationsOfDifferentKind, trailingTrivia.Last());
}
}
}
else if (emptyOrWhitespaceTrivia)
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenDeclarations, trailingTrivia.Last());
}
}
}
private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
{
var enumDeclaration = (EnumDeclarationSyntax)context.Node;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
int count = members.Count;
if (count <= 1)
{
return;
}
SyntaxTree tree = enumDeclaration.SyntaxTree;
CancellationToken cancellationToken = context.CancellationToken;
EnumMemberDeclarationSyntax member;
bool?isSingleLine;
bool?isPreviousSingleLine = null;
for (int i = 1; i < count; i++, isPreviousSingleLine = isSingleLine)
{
member = members[i];
isSingleLine = null;
SyntaxToken commaToken = members.GetSeparator(i - 1);
SyntaxTriviaList trailingTrivia = commaToken.TrailingTrivia;
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia))
{
continue;
}
SyntaxTriviaList leadingTrivia = member.GetLeadingTrivia();
(bool emptyOrWhitespaceTrivia, bool documentationComment, bool emptyLine) = AnalyzeLeadingTrivia(leadingTrivia);
if (documentationComment)
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenDeclarationAndDocumentationComment, trailingTrivia.Last());
continue;
}
if (!emptyOrWhitespaceTrivia &&
!emptyLine)
{
continue;
}
if ((isSingleLine ?? (isSingleLine = tree.IsSingleLineSpan(member.Span, cancellationToken)).Value) &&
(isPreviousSingleLine ?? tree.IsSingleLineSpan(members[i - 1].Span, cancellationToken)))
{
if (emptyLine)
{
ReportDiagnostic(context, DiagnosticDescriptors.RemoveEmptyLineBetweenSingleLineDeclarationsOfSameKind, leadingTrivia[0]);
}
else if (emptyOrWhitespaceTrivia)
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenSingleLineDeclarations, trailingTrivia.Last());
}
}
else if (emptyOrWhitespaceTrivia)
{
ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenDeclarations, trailingTrivia.Last());
}
}
}
private static void AnalyzeAccessorList(SyntaxNodeAnalysisContext context)
{
var accessorList = (AccessorListSyntax)context.Node;
SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors;
if (accessors.Count <= 1)
{
return;
}
Debug.Assert(accessors.Count == 2, accessors.Count.ToString());
AccessorDeclarationSyntax accessor1 = accessors[0];
if (accessor1.BodyOrExpressionBody() == null)
{
return;
}
AccessorDeclarationSyntax accessor2 = accessors[1];
if (accessor2.BodyOrExpressionBody() == null)
{
return;
}
SyntaxTriviaList trailingTrivia = accessor1.GetTrailingTrivia();
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia))
{
return;
}
SyntaxTriviaList leadingTrivia = accessor2.GetLeadingTrivia();
bool isEmptyLine = SyntaxTriviaAnalysis.StartsWithOptionalWhitespaceThenEndOfLineTrivia(leadingTrivia);
if (accessorList.SyntaxTree.IsSingleLineSpan(accessor1.Span, context.CancellationToken) &&
accessorList.SyntaxTree.IsSingleLineSpan(accessor2.Span, context.CancellationToken))
{
if (DiagnosticRules.BlankLineBetweenSingleLineAccessors.IsEffective(context))
{
BlankLineStyle style = context.GetBlankLineBetweenSingleLineAccessors();
if (isEmptyLine)
{
if (style == BlankLineStyle.Remove)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.BlankLineBetweenSingleLineAccessors,
Location.Create(context.Node.SyntaxTree, leadingTrivia[0].Span.WithLength(0)),
properties: DiagnosticProperties.AnalyzerOption_Invert,
"Remove");
}
}
else if (style == BlankLineStyle.Add)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.BlankLineBetweenSingleLineAccessors,
Location.Create(context.Node.SyntaxTree, trailingTrivia.Last().Span.WithLength(0)),
"Add");
}
}
}
else if (!isEmptyLine)
{
DiagnosticHelpers.ReportDiagnosticIfEffective(
context,
DiagnosticRules.AddBlankLineBetweenAccessors,
Location.Create(context.Node.SyntaxTree, trailingTrivia.Last().Span.WithLength(0)));
}
}