public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var methodCall = (InvocationExpressionSyntax)c.Node; var methodParameterLookup = new MethodParameterLookup(methodCall, c.SemanticModel); var argumentMappings = methodCall.ArgumentList.Arguments.Select(argument => new KeyValuePair<ArgumentSyntax, IParameterSymbol>(argument, methodParameterLookup.GetParameterSymbol(argument))) .ToList(); var methodSymbol = methodParameterLookup.MethodSymbol; if (methodSymbol == null) { return; } foreach (var argumentMapping in argumentMappings) { if (ParameterHasCallerInfoAttribute(argumentMapping)) { var argument = argumentMapping.Key; c.ReportDiagnostic(Diagnostic.Create(Rule, argument.GetLocation())); } } }, SyntaxKind.InvocationExpression); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var methodCall = (InvocationExpressionSyntax) c.Node; var methodParameterLookup = new MethodParameterLookup(methodCall, c.SemanticModel); var argumentMappings = methodCall.ArgumentList.Arguments.Select(argument => new ArgumentParameterMapping(argument, methodParameterLookup.GetParameterSymbol(argument))) .ToList(); var methodSymbol = methodParameterLookup.MethodSymbol; if (methodSymbol == null) { return; } foreach (var argumentMapping in argumentMappings) { if (ArgumentHasDefaultValue(argumentMapping, c.SemanticModel)) { var argument = argumentMapping.Argument; var parameter = argumentMapping.Parameter; c.ReportDiagnostic(Diagnostic.Create(Rule, argument.GetLocation(), parameter.Name)); } } }, SyntaxKind.InvocationExpression); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var methodCall = (InvocationExpressionSyntax) c.Node; var methodParameterLookup = new MethodParameterLookup(methodCall, c.SemanticModel); var argumentParameterMappings = methodCall.ArgumentList.Arguments.Select(argument => new KeyValuePair<ArgumentSyntax, IParameterSymbol>(argument, methodParameterLookup.GetParameterSymbol(argument))) .ToDictionary(pair => pair.Key, pair => pair.Value); var methodSymbol = methodParameterLookup.MethodSymbol; if (methodSymbol == null) { return; } var parameterNames = argumentParameterMappings.Values .Select(symbol => symbol.Name) .Distinct() .ToList(); var identifierArguments = GetIdentifierArguments(methodCall); var identifierNames = identifierArguments .Select(p => p.IdentifierName) .ToList(); if (!parameterNames.Intersect(identifierNames).Any()) { return; } var methodCallHasIssue = false; for (var i = 0; !methodCallHasIssue && i < identifierArguments.Count; i++) { var identifierArgument = identifierArguments[i]; var identifierName = identifierArgument.IdentifierName; var parameter = argumentParameterMappings[identifierArgument.ArgumentSyntax]; var parameterName = parameter.Name; if (string.IsNullOrEmpty(identifierName) || !parameterNames.Contains(identifierName)) { continue; } var positional = identifierArgument as PositionalIdentifierArgument; if (positional != null && (parameter.IsParams || !identifierNames.Contains(parameterName) || identifierName == parameterName)) { continue; } var named = identifierArgument as NamedIdentifierArgument; if (named != null && (!identifierNames.Contains(named.DeclaredName) || named.DeclaredName == named.IdentifierName)) { continue; } methodCallHasIssue = true; } if (methodCallHasIssue) { var memberAccess = methodCall.Expression as MemberAccessExpressionSyntax; var reportLocation = memberAccess == null ? methodCall.Expression.GetLocation() : memberAccess.Name.GetLocation(); c.ReportDiagnostic(Diagnostic.Create(Rule, reportLocation, methodSymbol.Name)); } }, SyntaxKind.InvocationExpression); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var assignment = (AssignmentExpressionSyntax) c.Node; var typeDerived = c.SemanticModel.GetTypeInfo(assignment.Right).Type; var typeBase = c.SemanticModel.GetTypeInfo(assignment.Left).Type; if (AreCovariantArrayTypes(typeDerived, typeBase)) { c.ReportDiagnostic(Diagnostic.Create(Rule, assignment.Right.GetLocation())); } }, SyntaxKind.SimpleAssignmentExpression); context.RegisterSyntaxNodeActionInNonGenerated( c => { var variableDeclaration = (VariableDeclarationSyntax)c.Node; var typeBase = c.SemanticModel.GetTypeInfo(variableDeclaration.Type).Type; foreach (var variable in variableDeclaration.Variables .Where(syntax => syntax.Initializer != null)) { var typeDerived = c.SemanticModel.GetTypeInfo(variable.Initializer.Value).Type; if (AreCovariantArrayTypes(typeDerived, typeBase)) { c.ReportDiagnostic(Diagnostic.Create(Rule, variable.Initializer.Value.GetLocation())); } } }, SyntaxKind.VariableDeclaration); context.RegisterSyntaxNodeActionInNonGenerated( c => { var invocation = (InvocationExpressionSyntax)c.Node; var methodParameterLookup = new MethodParameterLookup(invocation, c.SemanticModel); foreach (var argument in invocation.ArgumentList.Arguments) { var parameter = methodParameterLookup.GetParameterSymbol(argument); if (parameter == null) { continue; } if (parameter.IsParams) { continue; } var typeDerived = c.SemanticModel.GetTypeInfo(argument.Expression).Type; if (AreCovariantArrayTypes(typeDerived, parameter.Type)) { c.ReportDiagnostic(Diagnostic.Create(Rule, argument.GetLocation())); } } }, SyntaxKind.InvocationExpression); context.RegisterSyntaxNodeActionInNonGenerated( c => { var castExpression = (CastExpressionSyntax) c.Node; var typeDerived = c.SemanticModel.GetTypeInfo(castExpression.Expression).Type; var typeBase = c.SemanticModel.GetTypeInfo(castExpression.Type).Type; if (AreCovariantArrayTypes(typeDerived, typeBase)) { c.ReportDiagnostic(Diagnostic.Create(Rule, castExpression.Type.GetLocation())); } }, SyntaxKind.CastExpression); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); var diagnostic = context.Diagnostics.First(); var invocation = GetInvocation(root, diagnostic.Location.SourceSpan); if (invocation == null) { return; } var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken); var methodParameterLookup = new MethodParameterLookup(invocation, semanticModel); var argumentMappings = invocation.ArgumentList.Arguments .Select(argument => new RedundantArgument.ArgumentParameterMapping(argument, methodParameterLookup.GetParameterSymbol(argument))); var methodSymbol = methodParameterLookup.MethodSymbol; if (methodSymbol == null) { return; } var argumentsWithDefaultValues = new List<ArgumentSyntax>(); var argumentsCanBeRemovedWithoutNamed = new List<ArgumentSyntax>(); var canBeRemovedWithoutNamed = true; var reversedMappings = argumentMappings.Reverse(); foreach (var argumentMapping in reversedMappings) { var argument = argumentMapping.Argument; if (RedundantArgument.ArgumentHasDefaultValue(argumentMapping, semanticModel)) { argumentsWithDefaultValues.Add(argument); if (canBeRemovedWithoutNamed) { argumentsCanBeRemovedWithoutNamed.Add(argument); } } else { if (argument.NameColon == null) { canBeRemovedWithoutNamed = false; } } } if (argumentsCanBeRemovedWithoutNamed.Any()) { context.RegisterCodeFix( CodeAction.Create( TitleRemove, c => RemoveArgumentsAsync(context.Document, argumentsCanBeRemovedWithoutNamed, c), TitleRemove), context.Diagnostics); } var cannotBeRemoved = argumentsWithDefaultValues.Except(argumentsCanBeRemovedWithoutNamed); if (cannotBeRemoved.Any()) { context.RegisterCodeFix( CodeAction.Create( TitleRemoveWithNameAdditions, c => RemoveArgumentsAndAddNecessaryNamesAsync(context.Document, invocation.ArgumentList, argumentMappings, argumentsWithDefaultValues, semanticModel, c), TitleRemoveWithNameAdditions), context.Diagnostics); } }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var invocation = (InvocationExpressionSyntax)c.Node; var methodSymbol = c.SemanticModel.GetSymbolInfo(invocation).Symbol as IMethodSymbol; if (methodSymbol == null || methodSymbol.ContainingType.SpecialType != SpecialType.System_String || methodSymbol.Name != "Format") { return; } if (invocation.ArgumentList == null || invocation.ArgumentList.Arguments.Count == 0) { return; } var lookup = new MethodParameterLookup(invocation, c.SemanticModel); if (!InvocationHasFormatArgument(invocation, lookup)) { var formatArgument = invocation.ArgumentList.Arguments .FirstOrDefault(arg => lookup.GetParameterSymbol(arg).Name == "format"); if (formatArgument == null) { return; } var constValue = c.SemanticModel.GetConstantValue(formatArgument.Expression); if (!constValue.HasValue) { // we don't report on non-contant format strings return; } var formatString = constValue.Value as string; if (formatString == null) { return; } if (!StringFormatArgumentNumberMismatch.FormatterAcceptsArgumentCount(formatString, 0)) { ///A more severe issue is already reported by <see cref="StringFormatArgumentNumberMismatch"/> return; } c.ReportDiagnostic(Diagnostic.Create(Rule, invocation.Expression.GetLocation(), ImmutableDictionary<string, string>.Empty.Add( FormatStringIndexKey, invocation.ArgumentList.Arguments.IndexOf(formatArgument).ToString()))); } }, SyntaxKind.InvocationExpression); }
private static bool InvocationHasFormatArgument(InvocationExpressionSyntax invocation, MethodParameterLookup lookup) { return invocation.ArgumentList.Arguments.Any(arg => { var param = lookup.GetParameterSymbol(arg); return param != null && param.Name.StartsWith("arg", System.StringComparison.Ordinal); }); }