private static bool TryGetTypeFromArgumentMappedToFloatType(BinaryExpressionSyntax division, SemanticModel semanticModel,
out ITypeSymbol type)
{
if (!(division.Parent is ArgumentSyntax argument))
{
type = null;
return(false);
}
if (!(argument.Parent.Parent is InvocationExpressionSyntax invocation))
{
type = null;
return(false);
}
var lookup = new CSharpMethodParameterLookup(invocation, semanticModel);
if (!lookup.TryGetParameterSymbol(argument, out var parameter))
{
type = null;
return(false);
}
type = parameter.Type;
return(type.IsAny(KnownType.NonIntegralNumbers));
}
private static bool IsInvocationWithExplicitArray(ArgumentListSyntax argumentList, IMethodSymbol invokedMethodSymbol,
SemanticModel semanticModel)
{
var methodParameterLookup = new CSharpMethodParameterLookup(argumentList, invokedMethodSymbol);
var allParameterMatches = new List <IParameterSymbol>();
foreach (var argument in argumentList.Arguments)
{
if (!methodParameterLookup.TryGetSymbol(argument, out var parameter))
{
return(false);
}
allParameterMatches.Add(parameter);
if (!parameter.IsParams)
{
continue;
}
var argType = semanticModel.GetTypeInfo(argument.Expression).Type;
if (!(argType is IArrayTypeSymbol))
{
return(false);
}
}
return(allParameterMatches.Count(p => p.IsParams) == 1);
}
protected override void Initialize(SonarAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
// Can't use optional arguments in expression trees (CS0584), so skip those
if (c.Node.IsInExpressionTree(c.SemanticModel))
{
return;
}
var methodCall = (InvocationExpressionSyntax)c.Node;
var methodParameterLookup = new CSharpMethodParameterLookup(methodCall, c.SemanticModel);
var argumentMappings = methodParameterLookup.GetAllArgumentParameterMappings()
.ToList();
var methodSymbol = methodParameterLookup.MethodSymbol;
if (methodSymbol == null)
{
return;
}
foreach (var argumentMapping in argumentMappings.Where(argumentMapping => ArgumentHasDefaultValue(argumentMapping, c.SemanticModel)))
{
var argument = argumentMapping.Argument;
var parameter = argumentMapping.Parameter;
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, argument.GetLocation(), parameter.Name));
}
},
SyntaxKind.InvocationExpression);
}
private void AnalyzeArguments(SyntaxNodeAnalysisContext analysisContext, ArgumentListSyntax argumentList,
Func <Location> getLocation)
{
if (argumentList == null)
{
return;
}
var methodParameterLookup = new CSharpMethodParameterLookup(argumentList, analysisContext.SemanticModel);
ReportIncorrectlyOrderedParameters(analysisContext, methodParameterLookup, argumentList.Arguments, getLocation);
}
private void RaiseOnArrayCovarianceInInvocationExpression(SyntaxNodeAnalysisContext context)
{
var invocation = (InvocationExpressionSyntax)context.Node;
var methodParameterLookup = new CSharpMethodParameterLookup(invocation, context.SemanticModel);
foreach (var argument in invocation.ArgumentList.Arguments)
{
if (!methodParameterLookup.TryGetParameterSymbol(argument, out var parameter) ||
parameter.IsParams)
{
continue;
}
var typeDerived = context.SemanticModel.GetTypeInfo(argument.Expression).Type;
if (AreCovariantArrayTypes(typeDerived, parameter.Type))
{
context.ReportDiagnosticWhenActive(Diagnostic.Create(rule, argument.GetLocation()));
}
}
}
private static void CheckToStringInvocationsOnStringAndInStringFormat(SonarAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var invocation = (InvocationExpressionSyntax)c.Node;
if (!IsArgumentlessToStringCallNotOnBaseExpression(invocation, c.SemanticModel, out var location, out var methodSymbol))
{
return;
}
if (methodSymbol.IsInType(KnownType.System_String))
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, location, MessageCallOnString));
return;
}
if (!TryGetExpressionTypeOfOwner(invocation, c.SemanticModel, out var subExpressionType) ||
subExpressionType.IsValueType)
{
return;
}
var stringFormatArgument = invocation?.Parent as ArgumentSyntax;
if (!(stringFormatArgument?.Parent?.Parent is InvocationExpressionSyntax stringFormatInvocation) ||
!IsStringFormatCall(c.SemanticModel.GetSymbolInfo(stringFormatInvocation).Symbol as IMethodSymbol))
{
return;
}
var parameterLookup = new CSharpMethodParameterLookup(stringFormatInvocation, c.SemanticModel);
if (parameterLookup.TryGetParameterSymbol(stringFormatArgument, out var argParameter) &&
argParameter.Name.StartsWith("arg", StringComparison.Ordinal))
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, location, MessageCompiler));
}
},
SyntaxKind.InvocationExpression);
}
private static bool ArgumentsMatchParameters(ArgumentListSyntax argumentList, List <INamedTypeSymbol> argumentTypes,
IMethodSymbol possibleOtherMethod, SemanticModel semanticModel)
{
var methodParameterLookup = new CSharpMethodParameterLookup(argumentList, possibleOtherMethod);
var matchedParameters = new List <IParameterSymbol>();
for (var i = 0; i < argumentList.Arguments.Count; i++)
{
var argument = argumentList.Arguments[i];
var argumentType = argumentTypes[i];
if (!methodParameterLookup.TryGetSymbol(argument, out var parameter))
{
return(false);
}
if (argumentType == null)
{
if (!parameter.Type.IsReferenceType)
{
return(false);
}
}
else
{
var conversion = semanticModel.ClassifyConversion(argument.Expression, parameter.Type);
if (!conversion.IsImplicit)
{
return(false);
}
}
matchedParameters.Add(parameter);
}
var nonMatchedParameters = possibleOtherMethod.Parameters.Except(matchedParameters);
return(nonMatchedParameters.All(p => p.HasExplicitDefaultValue));
}
protected override void Initialize(SonarAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var methodCall = (InvocationExpressionSyntax)c.Node;
var methodParameterLookup = new CSharpMethodParameterLookup(methodCall, c.SemanticModel);
var methodSymbol = methodParameterLookup.MethodSymbol;
if (methodSymbol == null)
{
return;
}
var argumentMappings = methodParameterLookup.GetAllArgumentParameterMappings();
foreach (var argumentMapping in argumentMappings)
{
var parameter = argumentMapping.Symbol;
var argument = argumentMapping.SyntaxNode;
var callerInfoAttributeDataOnCall = GetCallerInfoAttribute(parameter);
if (callerInfoAttributeDataOnCall == null)
{
continue;
}
if (c.SemanticModel.GetSymbolInfo(argument.Expression).Symbol is IParameterSymbol symbolForArgument &&
Equals(callerInfoAttributeDataOnCall.AttributeClass, GetCallerInfoAttribute(symbolForArgument)?.AttributeClass))
{
continue;
}
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, argument.GetLocation()));
}
},
SyntaxKind.InvocationExpression);
}
private static void AnalyzeArguments(SyntaxNodeAnalysisContext analysisContext, ArgumentListSyntax argumentList,
Func <Location> getLocation)
{
if (argumentList == null)
{
return;
}
var methodParameterLookup = new CSharpMethodParameterLookup(argumentList, analysisContext.SemanticModel);
var argumentParameterMappings = methodParameterLookup.GetAllArgumentParameterMappings()
.ToDictionary(pair => pair.Argument, pair => pair.Parameter);
var methodSymbol = methodParameterLookup.MethodSymbol;
if (methodSymbol == null)
{
return;
}
var parameterNames = argumentParameterMappings.Values
.Select(symbol => symbol.Name)
.Distinct()
.ToList();
var identifierArguments = GetIdentifierArguments(argumentList);
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) ||
!IdentifierWithSameNameAndTypeExists(parameter))
{
continue;
}
if (identifierArgument is PositionalIdentifierArgument positional &&
(parameter.IsParams || identifierName == parameterName))
{
continue;
}
if (identifierArgument is NamedIdentifierArgument named &&
(!identifierNames.Contains(named.DeclaredName) || named.DeclaredName == named.IdentifierName))
{
continue;
}
methodCallHasIssue = true;
}
if (methodCallHasIssue)
{
var secondaryLocations = methodSymbol.DeclaringSyntaxReferences
.Select(s => GetIdentifierLocation(s.GetSyntax()))
.WhereNotNull();
analysisContext.ReportDiagnosticWhenActive(Diagnostic.Create(rule, getLocation(),
additionalLocations: secondaryLocations,
messageArgs: methodSymbol.Name));
}
bool IdentifierWithSameNameAndTypeExists(IParameterSymbol parameter) =>
identifierArguments.Any(ia =>
ia.IdentifierName == parameter.Name &&
GetTypeSymbol(ia.ArgumentSyntax.Expression).DerivesOrImplements(parameter.Type));
ITypeSymbol GetTypeSymbol(SyntaxNode syntaxNode) =>
analysisContext.SemanticModel.GetTypeInfo(syntaxNode).ConvertedType;
}
protected override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context)
{
var diagnostic = context.Diagnostics.First();
var invocation = GetInvocation(root, diagnostic.Location.SourceSpan);
if (invocation == null)
{
return;
}
var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
var methodParameterLookup = new CSharpMethodParameterLookup(invocation, semanticModel);
var argumentMappings = methodParameterLookup.GetAllArgumentParameterMappings()
.ToList();
var methodSymbol = methodParameterLookup.MethodSymbol;
if (methodSymbol == null)
{
return;
}
var argumentsWithDefaultValues = new List <ArgumentSyntax>();
var argumentsCanBeRemovedWithoutNamed = new List <ArgumentSyntax>();
var canBeRemovedWithoutNamed = true;
var reversedMappings = new List <SyntaxNodeSymbolSemanticModelTuple <ArgumentSyntax, IParameterSymbol> >(argumentMappings);
reversedMappings.Reverse();
foreach (var argumentMapping in reversedMappings)
{
var argument = argumentMapping.SyntaxNode;
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);
}
}
