public override DotnetStyleQualificationForMethodStyle Update(ModelNodeInformation <InvocationExpressionSyntax> information)
{
var(node, model) = information ?? throw new ArgumentNullException(nameof(information));
if (!node.ContainsDiagnostics)
{
if (model.GetSymbolInfo(node).Symbol is IMethodSymbol methodSymbol)
{
if (node.DescendantNodes().Any(_ => _.Kind() == SyntaxKind.ThisExpression))
{
return(new DotnetStyleQualificationForMethodStyle(this.Data.Update(true), this.Severity));
}
else
{
var classNode = node.FindParent <ClassDeclarationSyntax>();
if (!methodSymbol.IsStatic && classNode is not null &&
object.ReferenceEquals(model.GetDeclaredSymbol(classNode), methodSymbol.ContainingType) &&
!methodSymbol.IsExtensionMethod)
{
return(new DotnetStyleQualificationForMethodStyle(this.Data.Update(false), this.Severity));
}
return(new DotnetStyleQualificationForMethodStyle(this.Data, this.Severity));
}
}
}
return(new DotnetStyleQualificationForMethodStyle(this.Data, this.Severity));
}
public override DotnetStylePredefinedTypeForLocalsParametersMembersStyle Update(ModelNodeInformation <SyntaxNode> information)
{
var(node, model) = information ?? throw new ArgumentNullException(nameof(information));
if (!node.ContainsDiagnostics)
{
if (node is ParameterSyntax || node is LocalDeclarationStatementSyntax ||
node is FieldDeclarationSyntax || node is PropertyDeclarationSyntax)
{
if (node.DescendantNodes().Any(_ => _.Kind() == SyntaxKind.PredefinedType))
{
return(new DotnetStylePredefinedTypeForLocalsParametersMembersStyle(
this.Data.Update(true), this.Severity));
}
else
{
if (node.DescendantNodes().FirstOrDefault(_ => _.Kind() == SyntaxKind.IdentifierName) is IdentifierNameSyntax identifierNode)
{
if (model.GetSymbolInfo(identifierNode).Symbol is ITypeSymbol identifierType &&
identifierType.SpecialType.IsPredefinedType())
{
return(new DotnetStylePredefinedTypeForLocalsParametersMembersStyle(
this.Data.Update(false), this.Severity));
}
}
}
}
}
return(new DotnetStylePredefinedTypeForLocalsParametersMembersStyle(this.Data, this.Severity));
}
public override DotnetStyleQualificationForPropertyStyle Update(ModelNodeInformation <SyntaxNode> information)
{
var(node, model) = information ?? throw new ArgumentNullException(nameof(information));
if (!node.ContainsDiagnostics)
{
if (node is MemberAccessExpressionSyntax || node is IdentifierNameSyntax)
{
if (model.GetSymbolInfo(node).Symbol is IPropertySymbol propertySymbol)
{
if (node.DescendantNodes().Any(_ => _.Kind() == SyntaxKind.ThisExpression))
{
return(new DotnetStyleQualificationForPropertyStyle(this.Data.Update(true), this.Severity));
}
else
{
var classNode = node.FindParent <ClassDeclarationSyntax>();
if (!propertySymbol.IsStatic && classNode is not null &&
object.ReferenceEquals(model.GetDeclaredSymbol(classNode), propertySymbol.ContainingType))
{
return(new DotnetStyleQualificationForPropertyStyle(this.Data.Update(false), this.Severity));
}
return(new DotnetStyleQualificationForPropertyStyle(this.Data, this.Severity));
}
}
}
}
return(new DotnetStyleQualificationForPropertyStyle(this.Data, this.Severity));
}
public static void Create()
{
var tree = ModelNodeInformationTests.unit.SyntaxTree;
var compilation = CSharpCompilation.Create(Guid.NewGuid().ToString("N"),
new[] { tree },
new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) });
var model = compilation.GetSemanticModel(tree);
var information = new ModelNodeInformation <CompilationUnitSyntax>(
ModelNodeInformationTests.unit, model);
Assert.That(information.Node, Is.SameAs(ModelNodeInformationTests.unit), nameof(information.Node));
Assert.That(information.Model, Is.SameAs(model), nameof(information.Model));
}
public override CSharpStylePatternMatchingOverAsWithNullCheckStyle Update(ModelNodeInformation <SyntaxNode> information)
{
var(node, model) = information ?? throw new ArgumentNullException(nameof(information));
if (!node.ContainsDiagnostics)
{
if (node is IsPatternExpressionSyntax && node.FindParent <IfStatementSyntax>() is not null)
{
return(new CSharpStylePatternMatchingOverAsWithNullCheckStyle(this.Data.Update(true), this.Severity));
}
else if (node is IfStatementSyntax)
{
foreach (var binary in node.ChildNodes().Where(_ => _ is BinaryExpressionSyntax))
{
if (binary.ChildNodes().Any(_ => _.IsKind(SyntaxKind.NullLiteralExpression)))
{
// harder than this thought. The "thing" being compared to null
// has to have an IdentifierName that resolves to a symbol, and
// it had to have some kind of assignment via an AsExpression before the IfStatement.
if (binary.DescendantNodes().FirstOrDefault(_ => _.IsKind(SyntaxKind.IdentifierName)) is IdentifierNameSyntax identifier)
{
if (CSharpStylePatternMatchingOverAsWithNullCheckStyle.IsIdentifierUsedWithAsExpression(
identifier, node, model))
{
return(new CSharpStylePatternMatchingOverAsWithNullCheckStyle(this.Data.Update(false), this.Severity));
}
}
}
}
foreach (var recursive in node.DescendantNodes().Where(_ => _ is RecursivePatternSyntax))
{
foreach (var recursiveProperty in recursive.DescendantNodes().Where(_ => _ is PropertyPatternClauseSyntax))
{
if (!recursiveProperty.DescendantNodes().Any())
{
return(new CSharpStylePatternMatchingOverAsWithNullCheckStyle(this.Data.Update(false), this.Severity));
}
}
}
}
}
return(new CSharpStylePatternMatchingOverAsWithNullCheckStyle(this.Data, this.Severity));
}
public override DotnetStyleExplicitTupleNamesStyle Update(ModelNodeInformation <MemberAccessExpressionSyntax> information)
{
var(node, model) = information ?? throw new ArgumentNullException(nameof(information));
if (!node.ContainsDiagnostics)
{
if (model.GetSymbolInfo(node).Symbol is IFieldSymbol field)
{
var correspondingTupleField = field.CorrespondingTupleField;
if (correspondingTupleField is not null)
{
return(new DotnetStyleExplicitTupleNamesStyle(this.Data.Update(
correspondingTupleField.Name != field.Name), this.Severity));
}
}
}
return(new DotnetStyleExplicitTupleNamesStyle(this.Data, this.Severity));
}
public override CSharpStylePatternLocalOverAnonymousFunctionStyle Update(ModelNodeInformation <SyntaxNode> information)
{
var(node, model) = information ?? throw new ArgumentNullException(nameof(information));
if (!node.ContainsDiagnostics)
{
if (node is LocalFunctionStatementSyntax function)
{
return(new CSharpStylePatternLocalOverAnonymousFunctionStyle(this.Data.Update(true), this.Severity));
}
else if (node is VariableDeclarationSyntax variable)
{
ISymbol?variableSymbol = default;
if (node.ChildNodes().SingleOrDefault(_ => _ is GenericNameSyntax) is GenericNameSyntax genericVariable)
{
variableSymbol = model.GetSymbolInfo(genericVariable).Symbol;
}
else if (node.ChildNodes().SingleOrDefault(_ => _ is IdentifierNameSyntax) is IdentifierNameSyntax identifierVariable)
{
variableSymbol = model.GetSymbolInfo(identifierVariable).Symbol;
}
if (variableSymbol is INamedTypeSymbol namedVariableSymbol &&
namedVariableSymbol.TypeKind == TypeKind.Delegate)
{
var original = namedVariableSymbol.OriginalDefinition;
if ((original.Name.StartsWith("Action", StringComparison.InvariantCulture) ||
original.Name.StartsWith("Func", StringComparison.InvariantCulture)) &&
original.ContainingNamespace?.Name == "System")
{
return(new CSharpStylePatternLocalOverAnonymousFunctionStyle(
this.Data.Update(false), this.Severity));
}
}
}
}
return(new CSharpStylePatternLocalOverAnonymousFunctionStyle(this.Data, this.Severity));
}
public override DotnetStyleObjectInitializerStyle Update(ModelNodeInformation <ObjectCreationExpressionSyntax> information)
{
var(node, model) = information ?? throw new ArgumentNullException(nameof(information));
if (!node.ContainsDiagnostics)
{
if (node.ChildNodes().Any(_ => _.IsKind(SyntaxKind.ObjectInitializerExpression)))
{
return(new DotnetStyleObjectInitializerStyle(this.Data.Update(true), this.Severity));
}
else
{
var assignment = node.FindParent <VariableDeclaratorSyntax>() ??
node.FindParent <AssignmentExpressionSyntax>()?.ChildNodes()
.FirstOrDefault(_ => _.IsKind(SyntaxKind.SimpleMemberAccessExpression));
if (assignment is not null)
{
var assignmentSymbol = model.GetDeclaredSymbol(assignment);
if (assignmentSymbol is not null)
{
var statement = assignment.FindParent <StatementSyntax>();
if (statement is not null)
{
var parentStatement = statement.Parent;
if (parentStatement is not null)
{
var siblings = parentStatement.ChildNodes().ToArray();
if (siblings.Length > 1)
{
var statementIndex = Array.IndexOf(siblings, statement);
if (statementIndex < siblings.Length - 1)
{
var nextNode = siblings[statementIndex + 1];
if (nextNode is ExpressionStatementSyntax &&
nextNode.ChildNodes().Any(_ => _.IsKind(SyntaxKind.SimpleAssignmentExpression)))
{
var name = nextNode.DescendantNodes().FirstOrDefault(_ => _.IsKind(SyntaxKind.IdentifierName));
if (name is not null)
{
var isSameSymbol = object.ReferenceEquals(model.GetSymbolInfo(name).Symbol, assignmentSymbol);
if (isSameSymbol)
{
return(new DotnetStyleObjectInitializerStyle(this.Data.Update(false), this.Severity));
}
}
}
}
}
}
}
}
}
}
return(new DotnetStyleObjectInitializerStyle(this.Data, this.Severity));
}
return(new DotnetStyleObjectInitializerStyle(this.Data, this.Severity));
}
