private static void CheckStatement(SyntaxNodeAnalysisContext context, StatementSyntax statement,
string executed, string execute)
{
if (statement.IsKind(SyntaxKind.Block))
{
return;
}
var nextStatement = context.Node.GetLastToken().GetNextToken().Parent;
// This algorithm to get the next statement can sometimes return a parent statement (for example a BlockSyntax)
// so we need to filter this case by returning if the nextStatement happens to be one ancestor of statement.
if (nextStatement == null ||
statement.Ancestors().Contains(nextStatement))
{
return;
}
var statementPosition = statement.GetLocation().GetLineSpan().StartLinePosition;
var nextStatementPosition = nextStatement.GetLocation().GetLineSpan().StartLinePosition;
if (statementPosition.Character == nextStatementPosition.Character)
{
var lineSpan = context.Node.SyntaxTree.GetText().Lines[nextStatementPosition.Line].Span;
var location = Location.Create(context.Node.SyntaxTree, TextSpan.FromBounds(nextStatement.SpanStart, lineSpan.End));
context.ReportDiagnosticWhenActive(Diagnostic.Create(rule, location,
additionalLocations: new[] { statement.GetLocation() },
messageArgs: new object[] { executed, execute, nextStatementPosition.Line - statementPosition.Line + 1 }));
}
}
private static void AnalyzeEmbeddedStatement(SyntaxNodeAnalysisContext context)
{
SyntaxToken token = GetToken(context.Node);
if (token.IsMissing)
{
return;
}
StatementSyntax statement = GetStatement(context.Node);
if (statement.IsKind(SyntaxKind.Block))
{
return;
}
if (statement.IsKind(SyntaxKind.EmptyStatement))
{
return;
}
if (token.GetSpanStartLine() == statement.GetSpanStartLine())
{
context.ReportDiagnostic(
DiagnosticDescriptors.FormatEmbeddedStatementOnSeparateLine,
statement.GetLocation());
}
else
{
var parentStatement = (StatementSyntax)context.Node;
var block = parentStatement.Parent as BlockSyntax;
if (block == null)
{
return;
}
int index = block.Statements.IndexOf(parentStatement);
if (index == block.Statements.Count - 1)
{
return;
}
int diff = block.Statements[index + 1].GetSpanStartLine() - statement.GetSpanEndLine();
if (diff < 2)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddEmptyLineAfterEmbeddedStatement,
statement.GetLocation());
}
}
}
private void AnalyzeStatement(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
AnalyzeEmbeddedStatement(context);
if (context.Node.IsKind(SyntaxKind.IfStatement) &&
!IfElseAnalysis.IsIsolatedIf((IfStatementSyntax)context.Node))
{
return;
}
StatementSyntax statement = EmbeddedStatementAnalysis.GetEmbeddedStatementThatShouldBeInsideBlock(context.Node);
if (statement != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddBraces,
statement.GetLocation(),
SyntaxHelper.GetNodeTitle(context.Node));
}
}
private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
var elseClause = (ElseClauseSyntax)context.Node;
StatementSyntax statement = elseClause.Statement;
if (statement != null)
{
if (!statement.IsKind(SyntaxKind.Block) &&
!statement.IsKind(SyntaxKind.IfStatement) &&
elseClause.ElseKeyword.GetSpanStartLine() == statement.GetSpanStartLine())
{
context.ReportDiagnostic(
DiagnosticDescriptors.FormatEmbeddedStatementOnSeparateLine,
statement.GetLocation());
}
if (statement.IsKind(SyntaxKind.Block))
{
var block = (BlockSyntax)statement;
if (block.Statements.Count == 0)
{
if (elseClause.ElseKeyword.TrailingTrivia.IsWhitespaceOrEndOfLine() &&
block.OpenBraceToken.LeadingTrivia.IsWhitespaceOrEndOfLine() &&
block.OpenBraceToken.TrailingTrivia.IsWhitespaceOrEndOfLine() &&
block.CloseBraceToken.LeadingTrivia.IsWhitespaceOrEndOfLine())
{
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveEmptyElseClause,
elseClause.GetLocation());
}
}
else if (block.Statements.Count == 1)
{
if (block.Statements[0].IsKind(SyntaxKind.IfStatement))
{
var ifStatement = (IfStatementSyntax)block.Statements[0];
if (ifStatement.Else == null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.SimplifyElseClauseContainingIfStatement,
block.GetLocation());
DiagnosticHelper.FadeOutBraces(
context,
block,
DiagnosticDescriptors.SimplifyElseClauseContainingIfStatementFadeOut);
}
}
}
}
}
}
private static void CheckStatement(SyntaxNodeAnalysisContext context, StatementSyntax statement,
string executed, string execute)
{
if (statement is BlockSyntax)
{
return;
}
var nextStatement = context.Node.GetLastToken().GetNextToken().Parent;
if (nextStatement == null)
{
return;
}
var statementPosition = statement.GetLocation().GetLineSpan().StartLinePosition;
var nextStatementPosition = nextStatement.GetLocation().GetLineSpan().StartLinePosition;
if (statementPosition.Character == nextStatementPosition.Character)
{
var lineSpan = context.Node.SyntaxTree.GetText().Lines[nextStatementPosition.Line].Span;
var location = Location.Create(context.Node.SyntaxTree, TextSpan.FromBounds(nextStatement.SpanStart, lineSpan.End));
context.ReportDiagnostic(Diagnostic.Create(rule, location,
additionalLocations: new [] { statement.GetLocation() },
messageArgs: new object[] { executed, execute, nextStatementPosition.Line - statementPosition.Line + 1 }));
}
}
private void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
{
if (!(childStatement is BlockSyntax))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}
}
private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
var elseClause = (ElseClauseSyntax)context.Node;
StatementSyntax statement = elseClause.Statement;
if (statement != null)
{
if (!statement.IsKind(SyntaxKind.Block) &&
!statement.IsKind(SyntaxKind.IfStatement) &&
elseClause.ElseKeyword.GetSpanStartLine() == statement.GetSpanStartLine())
{
context.ReportDiagnostic(
DiagnosticDescriptors.FormatEmbeddedStatementOnSeparateLine,
statement.GetLocation());
}
if (statement.IsKind(SyntaxKind.Block))
{
var block = (BlockSyntax)statement;
if (block.Statements.Count == 0)
{
if (elseClause
.DescendantTrivia(elseClause.Span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveEmptyElseClause,
elseClause.GetLocation());
}
}
else if (block.Statements.Count == 1)
{
if (block.Statements[0].IsKind(SyntaxKind.IfStatement))
{
var ifStatement = (IfStatementSyntax)block.Statements[0];
if (ifStatement.Else == null &&
CheckTrivia(elseClause, ifStatement))
{
context.ReportDiagnostic(
DiagnosticDescriptors.MergeElseClauseWithNestedIfStatement,
block.GetLocation());
context.FadeOutBraces(
DiagnosticDescriptors.MergeElseClauseWithNestedIfStatementFadeOut,
block);
}
}
}
}
}
}
protected static bool HasNoBlankLinesAfter(FileLinePositionSpan callLineSpan, StatementSyntax other)
{
var otherLineSpan = other.GetLocation().GetLineSpan();
var differenceAfter = otherLineSpan.StartLinePosition.Line - callLineSpan.EndLinePosition.Line;
return(differenceAfter == 1);
}
private static void AnalyzeStatement(SyntaxNodeAnalysisContext context, StatementSyntax statement)
{
var missingBrackets = !statement.IsKind(SyntaxKind.Block);
if (missingBrackets)
{
context.ReportDiagnostic(Diagnostic.Create(Rule, statement.GetLocation()));
}
}
internal void Init(StatementSyntax syntax)
{
IsLoop = true;
IsIgnoreBreak = false;
ContinueAnalysis cont = new ContinueAnalysis();
cont.Visit(syntax);
HaveContinue = cont.ContinueCount > 0;
HaveBreak = cont.BreakCount > 0;
BreakFlagVarName = string.Format("__compiler_continue_{0}", syntax.GetLocation().GetLineSpan().StartLinePosition.Line);
}
private void AnalyzeStatement(SyntaxNodeAnalysisContext context)
{
StatementSyntax statement = EmbeddedStatement.GetEmbeddedStatement(context.Node);
if (statement != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AvoidEmbeddedStatement,
statement.GetLocation(),
GetName(context.Node));
}
}
private void DetectInLoopBlock(StatementSyntax statement, string scopeVariableName)
{
foreach (var invocation in FindChildrenOfType <InvocationExpressionSyntax>(statement))
{
var str = invocation.ToString();
if (str.Contains(scopeVariableName) && (str.Contains(".Fetch") || str.Contains(".TryFetch") || str.Contains(".Exists")))
{
var info = statement.GetLocation().GetLineSpan();
Console.WriteLine($"{ info.Path }\nat line { info.StartLinePosition.Line }");
Console.WriteLine();
break;
}
}
}
private static bool CheckStatementSyntax(SyntaxTreeAnalysisContext context, StatementSyntax statement)
{
if (!StatementNeedsWrapping(statement))
{
return(false);
}
var additionalLocations = ImmutableArray.Create(statement.GetLocation());
context.ReportDiagnostic(Diagnostic.Create(
Rule,
statement.GetFirstToken().GetLocation(),
additionalLocations: additionalLocations));
return(true);
}
public static void Analyze(SyntaxNodeAnalysisContext context, StatementSyntax statement)
{
if (!statement.IsKind(SyntaxKind.IfStatement) ||
!IfElseChain.IsPartOfChain((IfStatementSyntax)statement))
{
StatementSyntax embeddedStatement = GetEmbeddedStatementThatShouldBeInsideBlock(statement);
if (embeddedStatement != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddBraces,
embeddedStatement.GetLocation(),
GetName(statement));
}
}
}
private void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
{
if (childStatement is BlockSyntax)
{
return;
}
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line == lineSpan.EndLinePosition.Line)
{
return;
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}
private bool CheckStatementSyntax(SyntaxTreeAnalysisContext context, ReportDiagnostic severity, StatementSyntax statement)
{
if (!StatementNeedsWrapping(statement))
{
return(false);
}
var additionalLocations = ImmutableArray.Create(statement.GetLocation());
context.ReportDiagnostic(DiagnosticHelper.Create(
this.Descriptor,
statement.GetFirstToken().GetLocation(),
severity,
additionalLocations,
properties: null));
return(true);
}
private void AnalyzeStatement(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
StatementSyntax statement = EmbeddedStatementAnalysis.GetEmbeddedStatement(context.Node);
if (statement != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AvoidEmbeddedStatement,
statement.GetLocation(),
SyntaxHelper.GetNodeTitle(context.Node));
}
}
private static void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
{
if (childStatement is BlockSyntax)
{
return;
}
if (context.SemanticModel.Compilation.Options.SpecificDiagnosticOptions.GetValueOrDefault(SA1519BracesMustNotBeOmittedFromMultiLineChildStatement.DiagnosticId, ReportDiagnostic.Default) != ReportDiagnostic.Suppress)
{
// diagnostics for multi-line statements is handled by SA1519, as long as it's not suppressed
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line != lineSpan.EndLinePosition.Line)
{
return;
}
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}
private static void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
{
if (childStatement is BlockSyntax)
{
return;
}
if (!context.IsAnalyzerSuppressed(SA1519BracesMustNotBeOmittedFromMultiLineChildStatement.Descriptor))
{
// diagnostics for multi-line statements is handled by SA1519, as long as it's not suppressed
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line != lineSpan.EndLinePosition.Line)
{
return;
}
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}
public static void Analyze(SyntaxNodeAnalysisContext context, SwitchSectionSyntax switchSection)
{
SyntaxList <StatementSyntax> statements = switchSection.Statements;
if (statements.Any())
{
SyntaxList <SwitchLabelSyntax> labels = switchSection.Labels;
if (labels.Any())
{
StatementSyntax statement = statements.First();
if (switchSection.SyntaxTree.IsSingleLineSpan(TextSpan.FromBounds(labels.Last().Span.End, statement.SpanStart)))
{
context.ReportDiagnostic(
DiagnosticDescriptors.FormatSwitchSectionStatementOnSeparateLine,
statement.GetLocation());
}
}
}
}
private static void CheckChildStatement(SyntaxNodeAnalysisContext context, SyntaxNode node, StatementSyntax childStatement)
{
if (childStatement == null || childStatement.IsMissing)
{
return;
}
if (childStatement is BlockSyntax)
{
// BlockSyntax child statements are handled by HandleBlock
return;
}
// We are only interested in the first instance of this violation on a line.
if (!node.GetFirstToken().IsFirstInLine())
{
return;
}
// We are only interested in the case where statement and childStatement start on the same line. Use
// IsFirstInLine to detect this condition easily.
SyntaxToken firstChildToken = childStatement.GetFirstToken();
if (firstChildToken.IsMissingOrDefault() || firstChildToken.IsFirstInLine())
{
return;
}
if (!context.IsAnalyzerSuppressed(SA1519CurlyBracketsMustNotBeOmittedFromMultiLineChildStatement.DiagnosticId))
{
// diagnostics for multi-line statements is handled by SA1519, as long as it's not suppressed
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line != lineSpan.EndLinePosition.Line)
{
return;
}
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}
private static void CheckStatement(SyntaxNodeAnalysisContext c, StatementSyntax statement,
string executed, string execute)
{
if (statement is BlockSyntax)
{
return;
}
var nextStatement = c.Node.GetLastToken().GetNextToken().Parent;
if (nextStatement == null)
{
return;
}
var charPositionWithinLine1 = statement.GetLocation().GetLineSpan().StartLinePosition.Character;
var charPositionWithinLine2 = nextStatement.GetLocation().GetLineSpan().StartLinePosition.Character;
if (charPositionWithinLine1 == charPositionWithinLine2)
{
c.ReportDiagnostic(Diagnostic.Create(Rule, nextStatement.GetLocation(), executed, execute));
}
}
private static void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
{
bool reportAsHidden = false;
if (childStatement == null || childStatement.IsMissing)
{
return;
}
if (childStatement is BlockSyntax)
{
// BlockSyntax child statements are handled by HandleBlock
return;
}
// We are only interested in the case where statement and childStatement start on the same line. Use
// IsFirstInLine to detect this condition easily.
SyntaxToken firstChildToken = childStatement.GetFirstToken();
if (firstChildToken.IsMissingOrDefault() || firstChildToken.IsFirstInLine())
{
return;
}
if (!context.IsAnalyzerSuppressed(SA1519BracesMustNotBeOmittedFromMultiLineChildStatement.Descriptor))
{
// diagnostics for multi-line statements is handled by SA1519, as long as it's not suppressed
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line != lineSpan.EndLinePosition.Line)
{
reportAsHidden = true;
}
}
ReportDiagnostic(context, childStatement.GetLocation(), reportAsHidden);
}
// Checks if the incorrect statement is an if-statement, reports the diagnostic
private void IfDiagnostic(CompilationAnalysisContext context, StatementSyntax statement, DiagnosticDescriptor diagnostic, params string[] messageArgs)
{
if (statement.Kind() == SyntaxKind.IfStatement)
{
var ifStatement = statement as IfStatementSyntax;
var startDiagnosticSpan = ifStatement.SpanStart;
var endDiagnosticSpan = ifStatement.CloseParenToken.SpanStart;
var diagnosticSpan = TextSpan.FromBounds(startDiagnosticSpan, endDiagnosticSpan);
var diagnosticLocation = Location.Create(ifStatement.SyntaxTree, diagnosticSpan);
ReportDiagnostic(context, diagnostic, diagnosticLocation, messageArgs);
}
else
{
ReportDiagnostic(context, diagnostic, statement.GetLocation(), messageArgs);
}
}
private static void CheckStatement(SyntaxNodeAnalysisContext c, StatementSyntax statement,
string executed, string execute)
{
if (statement is BlockSyntax)
{
return;
}
var nextStatement = c.Node.GetLastToken().GetNextToken().Parent;
if (nextStatement == null)
{
return;
}
var charPositionWithinLine1 = statement.GetLocation().GetLineSpan().StartLinePosition.Character;
var charPositionWithinLine2 = nextStatement.GetLocation().GetLineSpan().StartLinePosition.Character;
if (charPositionWithinLine1 == charPositionWithinLine2)
{
c.ReportDiagnostic(Diagnostic.Create(Rule, nextStatement.GetLocation(), executed, execute));
}
}
private static void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
{
if (childStatement is BlockSyntax)
{
return;
}
if (context.SemanticModel.Compilation.Options.SpecificDiagnosticOptions.GetValueOrDefault(SA1519CurlyBracketsMustNotBeOmittedFromMultiLineChildStatement.DiagnosticId, ReportDiagnostic.Default) != ReportDiagnostic.Suppress)
{
// diagnostics for multi-line statements is handled by SA1519, as long as it's not suppressed
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line != lineSpan.EndLinePosition.Line)
{
return;
}
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}
public CodeActionEdit GetEdit(CancellationToken cancellationToken)
{
SyntaxNode root = (SyntaxNode)this.document.GetSyntaxRoot(cancellationToken);
ISemanticModel model = this.document.GetSemanticModel(cancellationToken);
// New variable's name
const string magicNumberName = "MAGIC_NUMBER";
// Get resultant type of literal
TypeSymbol typeSymbol = model.GetTypeInfo(this.literalExpression, cancellationToken).Type as TypeSymbol;
if (typeSymbol == null)
{
return(null);
}
StatementSyntax closestStatement = this.literalExpression.FirstAncestorOrSelf <StatementSyntax>();
// TODO: handle for-loops and if statements
BlockSyntax closestBlock = this.literalExpression.FirstAncestorOrSelf <BlockSyntax>();
// Parse type name
TypeSyntax variableType = Syntax.ParseTypeName(typeSymbol.ToMinimalDisplayString(closestStatement.GetLocation(), model));
// Create new variable definition with expression as initializer
VariableDeclaratorSyntax variableDeclarator = Syntax.VariableDeclarator(magicNumberName)
.WithInitializer(Syntax.EqualsValueClause(this.literalExpression));
VariableDeclarationSyntax variableDeclaration = Syntax.VariableDeclaration(variableType)
.AddVariables(variableDeclarator);
// Create declaration statement with `const' modifier
LocalDeclarationStatementSyntax declarationStatement = Syntax.LocalDeclarationStatement(variableDeclaration)
.WithModifiers(Syntax.TokenList(Syntax.Token(SyntaxKind.ConstKeyword)))
.WithAdditionalAnnotations(CodeAnnotations.Formatting);
ReplaceMagicNumberRewriter visitor = new ReplaceMagicNumberRewriter(this.literalExpression, magicNumberName, model, cancellationToken);
BlockSyntax newBlock = (BlockSyntax)visitor.Visit(closestBlock);
// Insert variable's declaration statement at proper position
newBlock = newBlock.WithStatements(newBlock.Statements.Insert(0, declarationStatement));
SyntaxNode newRoot = root.ReplaceNode(closestBlock, newBlock);
return(new CodeActionEdit(document.UpdateSyntaxRoot(newRoot)));
}
public CodeActionEdit GetEdit(CancellationToken cancellationToken)
{
SyntaxNode root = (SyntaxNode)this.document.GetSyntaxRoot(cancellationToken);
ISemanticModel model = this.document.GetSemanticModel(cancellationToken);
// New variable's name
const string variableName = "newVariable";
// Get resultant type of expresison
ITypeSymbol typeSymbol = model.GetTypeInfo(this.expression, cancellationToken).Type;
if (typeSymbol == null)
{
return(null);
}
StatementSyntax expressionStatement = this.expression.FirstAncestorOrSelf <StatementSyntax>();
if (expressionStatement == null)
{
return(null);
}
// Parse type name
TypeSyntax variableType = Syntax.ParseTypeName(typeSymbol.ToMinimalDisplayString(expressionStatement.GetLocation(), model));
// Create new variable definition with expression as initializer
VariableDeclaratorSyntax variableDeclarator = Syntax.VariableDeclarator(variableName)
.WithInitializer(Syntax.EqualsValueClause(this.expression));
VariableDeclarationSyntax variableDeclaration = Syntax.VariableDeclaration(variableType)
.AddVariables(variableDeclarator);
LocalDeclarationStatementSyntax declarationStatement = Syntax.LocalDeclarationStatement(variableDeclaration)
.WithAdditionalAnnotations(CodeAnnotations.Formatting);
// Replace expression with reference to new variable
IdentifierNameSyntax variableReference = Syntax.IdentifierName(variableName)
.WithLeadingTrivia(this.expression.GetLeadingTrivia())
.WithTrailingTrivia(this.expression.GetTrailingTrivia());
// Get parent statement (hopefully BlockSyntax)
StatementSyntax parentStatement = expressionStatement.Parent as StatementSyntax;
if (parentStatement == null)
{
return(null);
}
StatementSyntax updatedStatement = null;
// If expression's parent is ExpressionStatement, it means there is no need to put there new variable's reference again.
// Considers:
// foo(); -> int newVariable = foo(); , not int newVariable = foo(); newVariable;
// new A(); -> A newVariable = new A(); , not A newVariable = new A(); newVariable;
if (this.expression.Parent.Kind != SyntaxKind.ExpressionStatement)
{
updatedStatement = expressionStatement.ReplaceNode(this.expression, variableReference);
}
else
{
// Otherwise updatedStatement will be null, so original expression will be wiped out :)
}
// If statement is not contained within block, block should be created to store variable declaration and its original statement
if (parentStatement.Kind != SyntaxKind.Block)
{
StatementSyntax newStatement = Syntax.Block(Syntax.List <StatementSyntax>(declarationStatement, updatedStatement))
.WithAdditionalAnnotations(CodeAnnotations.Formatting);
SyntaxNode newRoot = root.ReplaceNode(expressionStatement, newStatement);
return(new CodeActionEdit(document.UpdateSyntaxRoot(newRoot)));
}
else
{
// Insert variable's declaration statement at proper position right before old statement
BlockSyntax block = parentStatement as BlockSyntax;
int index = block.Statements.IndexOf(expressionStatement);
BlockSyntax newBlock = block.ReplaceNode(expressionStatement, updatedStatement);
newBlock = newBlock.WithStatements(newBlock.Statements.Insert(index, declarationStatement));
SyntaxNode newRoot = root.ReplaceNode(block, newBlock);
return(new CodeActionEdit(document.UpdateSyntaxRoot(newRoot)));
}
}
private static void ReportDiagnostic(SyntaxNodeAnalysisContext context, StatementSyntax statement)
{
context.ReportDiagnostic(
DiagnosticDescriptors.FormatEmbeddedStatementOnSeparateLine,
statement.GetLocation());
}
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxList <StatementSyntax> statements)
{
if (statements.Count > 1)
{
int previousEndLine = statements[0].GetSpanEndLine();
for (int i = 1; i < statements.Count; i++)
{
StatementSyntax statement = statements[i];
if (!statement.IsKind(SyntaxKind.Block, SyntaxKind.EmptyStatement) &&
statement.GetSpanStartLine() == previousEndLine)
{
context.ReportDiagnostic(DiagnosticDescriptors.FormatEachStatementOnSeparateLine, statement.GetLocation());
}
previousEndLine = statement.GetSpanEndLine();
}
}
}
private static void CheckStatement(SyntaxNodeAnalysisContext context, StatementSyntax statement,
string executed, string execute)
{
if (statement is BlockSyntax)
{
return;
}
var nextStatement = context.Node.GetLastToken().GetNextToken().Parent;
if (nextStatement == null)
{
return;
}
var statementPosition = statement.GetLocation().GetLineSpan().StartLinePosition;
var nextStatementPosition = nextStatement.GetLocation().GetLineSpan().StartLinePosition;
if (statementPosition.Character == nextStatementPosition.Character)
{
var lineSpan = context.Node.SyntaxTree.GetText().Lines[nextStatementPosition.Line].Span;
var location = Location.Create(context.Node.SyntaxTree, TextSpan.FromBounds(nextStatement.SpanStart, lineSpan.End));
context.ReportDiagnostic(Diagnostic.Create(Rule, location, executed, execute,
nextStatementPosition.Line - statementPosition.Line + 1));
}
}
private static void CheckChildStatement(SyntaxNodeAnalysisContext context, SyntaxNode node, StatementSyntax childStatement)
{
if (childStatement == null || childStatement.IsMissing)
{
return;
}
if (childStatement is BlockSyntax)
{
// BlockSyntax child statements are handled by HandleBlock
return;
}
// We are only interested in the first instance of this violation on a line.
if (!node.GetFirstToken().IsFirstInLine())
{
return;
}
// We are only interested in the case where statement and childStatement start on the same line. Use
// IsFirstInLine to detect this condition easily.
SyntaxToken firstChildToken = childStatement.GetFirstToken();
if (firstChildToken.IsMissingOrDefault() || firstChildToken.IsFirstInLine())
{
return;
}
if (!context.IsAnalyzerSuppressed(SA1519CurlyBracketsMustNotBeOmittedFromMultiLineChildStatement.DiagnosticId))
{
// diagnostics for multi-line statements is handled by SA1519, as long as it's not suppressed
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line != lineSpan.EndLinePosition.Line)
{
return;
}
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}
private static void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
{
if (childStatement is BlockSyntax)
{
return;
}
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line == lineSpan.EndLinePosition.Line)
{
return;
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}