public override CSharpNewLineBeforeCatchStyle Update(NodeInformation <CatchClauseSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var parentStatement = node.FindParent <TryStatementSyntax>();
var parentChildren = parentStatement.ChildNodes().ToArray();
var nodeIndex = Array.IndexOf(parentChildren, node);
var previousNode = parentChildren[nodeIndex - 1];
if (!(previousNode is BlockSyntax block))
{
block = (BlockSyntax)((CatchClauseSyntax)previousNode).ChildNodes().Last();
}
var closeToken = block.ChildTokens().Single(_ => _.RawKind == (int)SyntaxKind.CloseBraceToken);
var containsEol = closeToken.HasTrailingTrivia &&
closeToken.TrailingTrivia.Any(_ => _.Kind() == SyntaxKind.EndOfLineTrivia);
return(new CSharpNewLineBeforeCatchStyle(this.Data.Update(containsEol), this.Severity));
}
return(new CSharpNewLineBeforeCatchStyle(this.Data, this.Severity));
}
public override CSharpSpaceBetweenParenthesesStyle Update(NodeInformation <SyntaxNode> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
if (node is ForStatementSyntax || node is ForEachStatementSyntax || node is IfStatementSyntax ||
node is SwitchStatementSyntax || node is WhileStatementSyntax)
{
return(new CSharpSpaceBetweenParenthesesStyle(this.Data.UpdateControlFlow(node.HasParenthesisSpacing())));
}
else if (node is ParenthesizedExpressionSyntax)
{
return(new CSharpSpaceBetweenParenthesesStyle(this.Data.UpdateExpression(node.HasParenthesisSpacing())));
}
else if (node is CastExpressionSyntax)
{
return(new CSharpSpaceBetweenParenthesesStyle(this.Data.UpdateTypeCast(node.HasParenthesisSpacing())));
}
}
return(new CSharpSpaceBetweenParenthesesStyle(this.Data));
}
public override CSharpPreferBracesStyle Update(NodeInformation <SyntaxNode> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
if (node is IfStatementSyntax || node is ElseClauseSyntax ||
node is ForStatementSyntax || node is ForEachStatementSyntax ||
node is WhileStatementSyntax)
{
if (node.ChildNodes().SingleOrDefault(_ => _.Kind() == SyntaxKind.Block) is BlockSyntax block)
{
return(block.ChildNodes().Count() == 1 ?
new CSharpPreferBracesStyle(this.Data.Update(true), this.Severity) :
new CSharpPreferBracesStyle(this.Data, this.Severity));
}
else
{
return(new CSharpPreferBracesStyle(this.Data.Update(false), this.Severity));
}
}
}
return(new CSharpPreferBracesStyle(this.Data, this.Severity));
}
public override CSharpStyleExpressionBodiedConstructorsStyle Update(NodeInformation <ConstructorDeclarationSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
return(new CSharpStyleExpressionBodiedConstructorsStyle(information.Node.Examine(this.Data), this.Severity));
}
public override DotnetSortSystemDirectivesFirstStyle Update(NodeInformation <CompilationUnitSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var usingNodes = node.DescendantNodes().Where(_ => _.IsKind(SyntaxKind.UsingDirective))
.Select(_ => (UsingDirectiveSyntax)_).ToImmutableArray();
if (usingNodes.Length > 1)
{
var foundBreakIndex = false;
for (var i = 0; i < usingNodes.Length; i++)
{
var usingNode = usingNodes[i];
if (!usingNode.Name.ToString().StartsWith("System"))
{
foundBreakIndex = true;
}
else if (foundBreakIndex)
{
return(new DotnetSortSystemDirectivesFirstStyle(this.Data.Update(false), this.Severity));
}
}
var systemUsingNodes = usingNodes.Where(_ => _.Name.ToString().StartsWith("System")).ToImmutableArray();
if (systemUsingNodes.Length > 1)
{
for (var i = 1; i < systemUsingNodes.Length; i++)
{
if (systemUsingNodes[i - 1].Name.ToString().CompareTo(
systemUsingNodes[i].Name.ToString()) > 0)
{
return(new DotnetSortSystemDirectivesFirstStyle(this.Data.Update(false), this.Severity));
}
}
return(new DotnetSortSystemDirectivesFirstStyle(this.Data.Update(true), this.Severity));
}
else if (systemUsingNodes.Length == 1)
{
return(new DotnetSortSystemDirectivesFirstStyle(this.Data.Update(true), this.Severity));
}
}
}
return(new DotnetSortSystemDirectivesFirstStyle(this.Data, this.Severity));
}
public override CSharpSpaceAfterCastStyle Update(NodeInformation <CastExpressionSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var closeParen = node.ChildTokens().Single(_ => _.RawKind == (int)SyntaxKind.CloseParenToken);
return(new CSharpSpaceAfterCastStyle(this.Data.Update(closeParen.HasTrailingTrivia), this.Severity));
}
return(new CSharpSpaceAfterCastStyle(this.Data, this.Severity));
}
public override CSharpStyleVarElsewhereStyle Update(NodeInformation <LocalDeclarationStatementSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var variableDeclaration = node.ChildNodes()
.Single(_ => _.Kind() == SyntaxKind.VariableDeclaration);
var identifierName = variableDeclaration.ChildNodes()
.SingleOrDefault(_ => _.Kind() == SyntaxKind.IdentifierName);
return(identifierName is { } ?
public override CSharpNewLineBetweenQueryExpressionClausesStyle Update(NodeInformation <QueryExpressionSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var clauseCount = node.DescendantNodes().Count(_ => _ is QueryClauseSyntax || _ is SelectOrGroupClauseSyntax);
var eolCount = node.DescendantTrivia().Count(_ => _.IsKind(SyntaxKind.EndOfLineTrivia));
return(new CSharpNewLineBetweenQueryExpressionClausesStyle(this.Data.Update(eolCount >= clauseCount - 1), this.Severity));
}
return(new CSharpNewLineBetweenQueryExpressionClausesStyle(this.Data, this.Severity));
}
public override CSharpPreferredModifierOrderStyle Update(NodeInformation <MemberDeclarationSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
return(new CSharpPreferredModifierOrderStyle(
this.Data.Update(node.ChildTokens()
.Where(_ => ((SyntaxKind)_.RawKind).ToString().Contains("Keyword"))
.Select(_ => _.ValueText).ToImmutableList())));
}
return(new CSharpPreferredModifierOrderStyle(this.Data));
}
public override DotnetStyleRequireAccessibilityModifiersStyle Update(NodeInformation <MemberDeclarationSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var modifiers = node.ChildTokens().Where(
_ => DotnetStyleRequireAccessibilityModifiersStyle.AccessibilityModifiers.Contains(_.Text)).ToList();
var(occurence, isFromPublicInterfaceMember) = DotnetStyleRequireAccessibilityModifiersStyle.GetOccurence(node, modifiers);
return(new DotnetStyleRequireAccessibilityModifiersStyle(this.Data.Update(occurence, isFromPublicInterfaceMember), this.Severity));
}
return(new DotnetStyleRequireAccessibilityModifiersStyle(this.Data, this.Severity));
}
public override IndentStyleStyle Update(NodeInformation <SyntaxNode> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
var leadingTrivia = node.GetLeadingTrivia().Where(_ => _.IsKind(SyntaxKind.WhitespaceTrivia)).ToArray();
if (leadingTrivia.Length == 1)
{
var content = leadingTrivia[0].ToFullString();
return(new IndentStyleStyle(this.Data.Update(content.Contains("\t"))));
}
return(new IndentStyleStyle(this.Data));
}
public override CSharpStyleExpressionBodiedPropertiesStyle Update(NodeInformation <PropertyDeclarationSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
if (information.Node.DescendantNodes()
.SingleOrDefault(_ => _.Kind() == SyntaxKind.GetAccessorDeclaration) is AccessorDeclarationSyntax getAccessor)
{
var accessorStyle = new CSharpStyleExpressionBodiedAccessorsStyle(this.Data, this.Severity);
return(new CSharpStyleExpressionBodiedPropertiesStyle(accessorStyle.Update(
new NodeInformation <AccessorDeclarationSyntax>(getAccessor)).Data, this.Severity));
}
else
{
return(new CSharpStyleExpressionBodiedPropertiesStyle(information.Node.Examine(this.Data), this.Severity));
}
}
public override CSharpPreserveSingleLineBlocksStyle Update(NodeInformation <AccessorListSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var openBrace = node.ChildTokens().First(_ => _.IsKind(SyntaxKind.OpenBraceToken));
return(new CSharpPreserveSingleLineBlocksStyle(
this.Data.Update(!(openBrace.HasTrailingTrivia &&
openBrace.TrailingTrivia.Any(_ => _.IsKind(SyntaxKind.EndOfLineTrivia)))), this.Severity));
}
return(new CSharpPreserveSingleLineBlocksStyle(this.Data, this.Severity));
}
public override CSharpStyleVarWhenTypeIsApparentStyle Update(NodeInformation <LocalDeclarationStatementSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
if (node.DescendantNodes()
.Any(_ => _.Kind() == SyntaxKind.ObjectCreationExpression))
{
var variableDeclaration = node.ChildNodes()
.Single(_ => _.Kind() == SyntaxKind.VariableDeclaration);
var identifierName = variableDeclaration.ChildNodes()
.SingleOrDefault(_ => _.Kind() == SyntaxKind.IdentifierName);
return(identifierName is { } ?
public override CSharpStyleInlinedVariableDeclarationStyle Update(NodeInformation <ArgumentSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var isOut = node.DescendantTokens().Any(_ => _.RawKind == (int)SyntaxKind.OutKeyword);
if (isOut)
{
return(new CSharpStyleInlinedVariableDeclarationStyle(this.Data.Update(
node.DescendantNodes().Any(_ => _.Kind() == SyntaxKind.DeclarationExpression)), this.Severity));
}
}
return(new CSharpStyleInlinedVariableDeclarationStyle(this.Data, this.Severity));
}
public override CSharpNewLineBeforeMembersInObjectInitializersStyle Update(NodeInformation <InitializerExpressionSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var commas = node.ChildTokens().Where(_ => _.Kind() == SyntaxKind.CommaToken).ToArray();
if (commas.Length > 0)
{
return(new CSharpNewLineBeforeMembersInObjectInitializersStyle(
this.Data.Update(commas.Any(_ => _.HasTrailingTrivia && _.TrailingTrivia.Any(t => t.Kind() == SyntaxKind.EndOfLineTrivia))),
this.Severity));
}
}
return(new CSharpNewLineBeforeMembersInObjectInitializersStyle(this.Data, this.Severity));
}
public override DotnetStylePreferInferredTupleNamesStyle Update(NodeInformation <TupleExpressionSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var data = this.Data;
foreach (var argument in node.ChildNodes().OfType <ArgumentSyntax>())
{
data = data.Update(!argument.ChildNodes().Any(_ => _.Kind() == SyntaxKind.NameColon));
}
return(new DotnetStylePreferInferredTupleNamesStyle(data, this.Severity));
}
return(new DotnetStylePreferInferredTupleNamesStyle(this.Data, this.Severity));
}
public override CSharpPreferSimpleDefaultExpressionStyle Update(NodeInformation <ExpressionSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
if (node is LiteralExpressionSyntax)
{
return(new CSharpPreferSimpleDefaultExpressionStyle(this.Data.Update(true), this.Severity));
}
else if (node is DefaultExpressionSyntax)
{
return(new CSharpPreferSimpleDefaultExpressionStyle(this.Data.Update(false), this.Severity));
}
}
return(new CSharpPreferSimpleDefaultExpressionStyle(this.Data, this.Severity));
}
public override CSharpNewLineBeforeElseStyle Update(NodeInformation <ElseClauseSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
var parentStatement = node.FindParent <IfStatementSyntax>();
var parentChildren = parentStatement.ChildNodes().ToArray();
var nodeIndex = Array.IndexOf(parentChildren, node);
var previousNode = parentChildren[nodeIndex - 1];
var lastToken = previousNode.ChildTokens().Last();
var containsEol = lastToken.HasTrailingTrivia &&
lastToken.TrailingTrivia.Any(_ => _.Kind() == SyntaxKind.EndOfLineTrivia);
return(new CSharpNewLineBeforeElseStyle(this.Data.Update(containsEol), this.Severity));
}
return(new CSharpNewLineBeforeElseStyle(this.Data, this.Severity));
}
public override CSharpSpaceBetweenMethodDeclarationParameterListParenthesesStyle Update(NodeInformation <ParameterListSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
return(new CSharpSpaceBetweenMethodDeclarationParameterListParenthesesStyle(
this.Data.Update(node.HasParenthesisSpacing())));
}
return(new CSharpSpaceBetweenMethodDeclarationParameterListParenthesesStyle(this.Data));
}
public override DotnetStylePreferInferredAnonymousTypeMemberNamesStyle Update(NodeInformation <AnonymousObjectMemberDeclaratorSyntax> information)
{
if (information is null)
{
throw new ArgumentNullException(nameof(information));
}
var node = information.Node;
if (!node.ContainsDiagnostics)
{
return(new DotnetStylePreferInferredAnonymousTypeMemberNamesStyle(
this.Data.Update(!node.ChildNodes().Any(_ => _.Kind() == SyntaxKind.NameEquals)), this.Severity));
}
return(new DotnetStylePreferInferredAnonymousTypeMemberNamesStyle(this.Data, this.Severity));
}
