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