private static bool?EnumeratorTypeMatchesTheVariableType(SyntaxNodeAnalysisContext context, ForEachStatementSyntax forEachStatement)
{
var enumerableType = context.SemanticModel.GetTypeInfoSafe(forEachStatement.Expression, context.CancellationToken);
if (enumerableType.Type == KnownSymbol.IEnumerable &&
enumerableType.ConvertedType == KnownSymbol.IEnumerable)
{
return(true);
}
if (enumerableType.Type.Is(KnownSymbol.IEnumerable))
{
if (enumerableType.ConvertedType is INamedTypeSymbol namedType &&
namedType.TypeArguments.TrySingle(out var enumerableTypeArg))
{
var variableType = context.SemanticModel.GetTypeInfoSafe(forEachStatement.Type, context.CancellationToken).Type;
return(SymbolComparer.Equals(variableType, enumerableTypeArg));
}
return(enumerableType.ConvertedType != KnownSymbol.IEnumerable);
}
if (enumerableType.ConvertedType.TryFirstMethod("GetEnumerator", out var method) &&
method.ReturnType is INamedTypeSymbol returnType &&
returnType.TypeArguments.TrySingle(out var enumeratorTypeArg))
{
var variableType = context.SemanticModel.GetTypeInfoSafe(forEachStatement.Type, context.CancellationToken).Type;
return(SymbolComparer.Equals(variableType, enumeratorTypeArg));
}
return(null);
}
internal static bool FirstWith(ISymbol symbol, SyntaxNode scope, Search search, SemanticModel semanticModel, CancellationToken cancellationToken, out AssignmentExpressionSyntax assignment)
{
assignment = null;
if (symbol == null ||
scope == null)
{
return(false);
}
using (var pooledAssignments = Create(scope, search, semanticModel, cancellationToken))
{
foreach (var candidate in pooledAssignments.Item.Assignments)
{
var assignedSymbol = semanticModel.GetSymbolSafe(candidate.Right, cancellationToken);
if (SymbolComparer.Equals(symbol, assignedSymbol))
{
assignment = candidate;
return(true);
}
if (candidate.Right is ObjectCreationExpressionSyntax objectCreation &&
objectCreation.ArgumentList != null &&
objectCreation.ArgumentList.Arguments.TryGetFirst(x => SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(x.Expression, cancellationToken)), out ArgumentSyntax _))
{
assignment = candidate;
return(true);
}
}
}
return(false);
}
internal static bool SingleForSymbol(ISymbol symbol, SyntaxNode scope, Search search, SemanticModel semanticModel, CancellationToken cancellationToken, out AssignmentExpressionSyntax assignment)
{
assignment = null;
if (symbol == null ||
scope == null)
{
return(false);
}
using (var pooledAssignments = Create(scope, search, semanticModel, cancellationToken))
{
foreach (var candidate in pooledAssignments.Item.Assignments)
{
var assignedSymbol = semanticModel.GetSymbolSafe(candidate.Left, cancellationToken);
if (SymbolComparer.Equals(symbol, assignedSymbol))
{
if (assignment != null)
{
assignment = null;
return(false);
}
assignment = candidate;
}
}
}
return(assignment != null);
}
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
if (this.visitedLocations.Add(node))
{
base.VisitInvocationExpression(node);
var method = this.semanticModel.GetSymbolSafe(node, this.cancellationToken);
if (method == null)
{
return;
}
if (this.context is ElementAccessExpressionSyntax &&
node.Expression is MemberAccessExpressionSyntax memberAccess &&
SymbolComparer.Equals(this.CurrentSymbol, this.semanticModel.GetSymbolSafe(memberAccess.Expression, this.cancellationToken)))
{
if (method.Name == "Add")
{
if (method.ContainingType.Is(KnownSymbol.IDictionary) &&
node.ArgumentList?.Arguments.Count == 2)
{
this.values.Add(node.ArgumentList.Arguments[1].Expression);
}
else if (node.ArgumentList?.Arguments.Count == 1)
{
this.values.Add(node.ArgumentList.Arguments[0].Expression);
}
}
}
this.HandleInvoke(method, node.ArgumentList);
}
}
private static bool IsMatch(ISymbol symbol, ExpressionSyntax expression, SemanticModel semanticModel, CancellationToken cancellationToken)
{
switch (expression)
{
case ConditionalExpressionSyntax conditional:
return(IsMatch(symbol, conditional.WhenTrue, semanticModel, cancellationToken) ||
IsMatch(symbol, conditional.WhenFalse, semanticModel, cancellationToken));
case BinaryExpressionSyntax binary when binary.IsKind(SyntaxKind.CoalesceExpression):
return(IsMatch(symbol, binary.Left, semanticModel, cancellationToken) ||
IsMatch(symbol, binary.Right, semanticModel, cancellationToken));
case BinaryExpressionSyntax binary when binary.IsKind(SyntaxKind.AsExpression):
return(IsMatch(symbol, binary.Left, semanticModel, cancellationToken));
case CastExpressionSyntax cast:
return(IsMatch(symbol, cast.Expression, semanticModel, cancellationToken));
case ObjectCreationExpressionSyntax objectCreation when objectCreation.ArgumentList != null && objectCreation.ArgumentList.Arguments.TryFirst(x => SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(x.Expression, cancellationToken)), out ArgumentSyntax _):
return(true);
default:
if (symbol.IsEither <ILocalSymbol, IParameterSymbol>())
{
return(expression is IdentifierNameSyntax identifierName &&
identifierName.Identifier.ValueText == symbol.Name &&
SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(expression, cancellationToken)));
}
return(SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(expression, cancellationToken)));
}
}
public override void VisitConstructorInitializer(ConstructorInitializerSyntax node)
{
if (this.method.MethodKind == MethodKind.Constructor)
{
var calledCtor = this.semanticModel.GetSymbolSafe(node, this.cancellationToken);
if (this.IsValidCtor(calledCtor))
{
var callingCtor = this.semanticModel.GetDeclaredSymbolSafe(node.Parent, this.cancellationToken) as IMethodSymbol;
if (SymbolComparer.Equals(calledCtor.ContainingType, callingCtor?.ContainingType))
{
this.initializers.Add(node);
}
else if (this.ctors.Contains(callingCtor))
{
this.initializers.Add(node);
}
}
}
else
{
this.initializers.Add(node);
}
base.VisitConstructorInitializer(node);
}
public override void VisitElementAccessExpression(ElementAccessExpressionSyntax node)
{
if (node.Parent is AssignmentExpressionSyntax assignment &&
this.context is ElementAccessExpressionSyntax &&
SymbolComparer.Equals(this.CurrentSymbol, this.semanticModel.GetSymbolSafe(node.Expression, this.cancellationToken)))
{
this.values.Add(assignment.Right);
base.VisitElementAccessExpression(node);
}
}
private static void HandleDisposeMethod(SyntaxNodeAnalysisContext context)
{
if (context.IsExcludedFromAnalysis())
{
return;
}
if (context.ContainingSymbol is IMethodSymbol method &&
method.IsOverride &&
method.Name == "Dispose")
{
var overridden = method.OverriddenMethod;
if (overridden == null)
{
return;
}
using (var invocations = InvocationWalker.Create(context.Node))
{
foreach (var invocation in invocations.Item)
{
if (
SymbolComparer.Equals(
context.SemanticModel.GetSymbolSafe(invocation, context.CancellationToken), overridden))
{
return;
}
}
}
if (overridden.DeclaringSyntaxReferences.Length == 0)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, context.Node.GetLocation()));
return;
}
using (
var disposeWalker = Disposable.DisposeWalker.Create(overridden, context.SemanticModel, context.CancellationToken))
{
foreach (var disposeCall in disposeWalker.Item)
{
if (Disposable.TryGetDisposedRootMember(disposeCall, context.SemanticModel, context.CancellationToken, out ExpressionSyntax disposed))
{
var member = context.SemanticModel.GetSymbolSafe(disposed, context.CancellationToken);
if (
!Disposable.IsMemberDisposed(member, method, context.SemanticModel, context.CancellationToken))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, context.Node.GetLocation()));
return;
}
}
}
}
}
}
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
var invokedMethod = this.semanticModel.GetSymbolSafe(node, this.cancellationToken) as IMethodSymbol;
if (SymbolComparer.Equals(this.method, invokedMethod))
{
this.invocations.Add(node);
}
base.VisitInvocationExpression(node);
}
public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
{
var ctor = this.semanticModel.GetSymbolSafe(node, this.cancellationToken) as IMethodSymbol;
if (SymbolComparer.Equals(this.type, ctor?.ContainingType))
{
this.objectCreations.Add(node);
}
base.VisitObjectCreationExpression(node);
}
public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
{
if (node.Type is SimpleNameSyntax typeName &&
typeName.Identifier.ValueText == this.context.Identifier.ValueText)
{
if (this.semanticModel.GetSymbolSafe(node, this.cancellationToken) is IMethodSymbol ctor &&
SymbolComparer.Equals(this.Type, ctor.ContainingType))
{
this.objectCreations.Add(node);
}
}
internal static bool Creates(this ObjectCreationExpressionSyntax creation, ConstructorDeclarationSyntax ctor, Search search, SemanticModel semanticModel, CancellationToken cancellationToken)
{
var created = semanticModel.GetSymbolSafe(creation, cancellationToken) as IMethodSymbol;
var ctorSymbol = semanticModel.GetDeclaredSymbolSafe(ctor, cancellationToken);
if (SymbolComparer.Equals(ctorSymbol, created))
{
return(true);
}
return(search == Search.Recursive &&
IsRunBefore(created, ctorSymbol, semanticModel, cancellationToken));
}
internal static bool IsRunBefore(IMethodSymbol first, IMethodSymbol other, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (first == null ||
other == null)
{
return(false);
}
if (TryGetInitializer(other, cancellationToken, out ConstructorInitializerSyntax initializer))
{
if (SymbolComparer.Equals(first.ContainingType, other.ContainingType) &&
!initializer.ThisOrBaseKeyword.IsKind(SyntaxKind.ThisKeyword))
{
return(false);
}
if (!other.ContainingType.Is(first.ContainingType) &&
initializer.ThisOrBaseKeyword.IsKind(SyntaxKind.BaseKeyword))
{
return(false);
}
}
else
{
if (SymbolComparer.Equals(first.ContainingType, other.ContainingType) ||
!other.ContainingType.Is(first.ContainingType))
{
return(false);
}
}
var next = semanticModel.GetSymbolSafe(initializer, cancellationToken);
if (SymbolComparer.Equals(first, next))
{
return(true);
}
if (next == null)
{
if (TryGetDefault(other.ContainingType?.BaseType, out next))
{
return(SymbolComparer.Equals(first, next));
}
return(false);
}
return(IsRunBefore(first, next, semanticModel, cancellationToken));
}
private bool IsValidCtor(IMethodSymbol ctor)
{
if (!SymbolComparer.Equals(this.method, ctor))
{
return(false);
}
if (SymbolComparer.Equals(this.contextType, ctor?.ContainingType))
{
return(true);
}
return(this.ctors.Contains(ctor));
}
public override void VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
{
var ctor = this.semanticModel.GetDeclaredSymbolSafe(node, this.cancellationToken);
if (SymbolComparer.Equals(this.type, ctor.ContainingType))
{
if (ctor.DeclaredAccessibility != Accessibility.Private)
{
this.nonPrivateCtors.Add(node);
}
if (ctor.Parameters.Length == 0)
{
this.Default = node;
}
}
base.VisitConstructorDeclaration(node);
}
public override void VisitArgument(ArgumentSyntax node)
{
if (this.visitedLocations.Add(node) &&
(node.RefOrOutKeyword.IsKind(SyntaxKind.RefKeyword) ||
node.RefOrOutKeyword.IsKind(SyntaxKind.OutKeyword)))
{
var invocation = node.FirstAncestorOrSelf <InvocationExpressionSyntax>();
var argSymbol = this.semanticModel.GetSymbolSafe(node.Expression, this.cancellationToken);
if (invocation != null &&
(SymbolComparer.Equals(this.CurrentSymbol, argSymbol) ||
this.refParameters.Contains(argSymbol as IParameterSymbol)))
{
var method = this.semanticModel.GetSymbolSafe(invocation, this.cancellationToken);
if (method != null &&
method.DeclaringSyntaxReferences.Length > 0)
{
foreach (var reference in method.DeclaringSyntaxReferences)
{
var methodDeclaration = reference.GetSyntax(this.cancellationToken) as MethodDeclarationSyntax;
if (methodDeclaration.TryGetMatchingParameter(node, out var parameterSyntax))
{
var parameterSymbol = this.semanticModel.GetDeclaredSymbolSafe(parameterSyntax, this.cancellationToken);
if (parameterSymbol != null)
{
if (node.RefOrOutKeyword.IsKind(SyntaxKind.RefKeyword))
{
this.refParameters.Add(parameterSymbol).IgnoreReturnValue();
}
if (node.RefOrOutKeyword.IsKind(SyntaxKind.OutKeyword))
{
this.values.Add(node.Expression);
}
}
}
}
}
}
}
base.VisitArgument(node);
}
internal Result IsMemberDisposed(ISymbol member)
{
foreach (var invocation in this.invocations)
{
if (TryGetDisposedRootMember(invocation, this.SemanticModel, this.CancellationToken, out ExpressionSyntax disposed) &&
SymbolComparer.Equals(member, this.SemanticModel.GetSymbolSafe(disposed, this.CancellationToken)))
{
return(Result.Yes);
}
}
foreach (var name in this.identifiers)
{
if (SymbolComparer.Equals(member, this.SemanticModel.GetSymbolSafe(name, this.CancellationToken)))
{
return(Result.Maybe);
}
}
return(Result.No);
}
internal static bool IsDisposing(InvocationExpressionSyntax invocation, ISymbol member, SemanticModel semanticModel, CancellationToken cancellationToken)
{
var method = semanticModel.GetSymbolSafe(invocation, cancellationToken) as IMethodSymbol;
if (method == null ||
method.Parameters.Length != 0 ||
method != KnownSymbol.IDisposable.Dispose)
{
return(false);
}
if (TryGetDisposedRootMember(invocation, semanticModel, cancellationToken, out ExpressionSyntax disposed))
{
if (SymbolComparer.Equals(member, semanticModel.GetSymbolSafe(disposed, cancellationToken)))
{
return(true);
}
}
return(false);
}
private bool TryHandleInvocation(InvocationExpressionSyntax invocation)
{
if (invocation == null)
{
return(false);
}
var method = this.semanticModel.GetSymbolSafe(invocation, this.cancellationToken);
if (method == null ||
method.DeclaringSyntaxReferences.Length == 0)
{
return(true);
}
foreach (var reference in method.DeclaringSyntaxReferences)
{
base.Visit(reference.GetSyntax(this.cancellationToken));
}
for (var i = this.values.Count - 1; i >= 0; i--)
{
var symbol = this.semanticModel.GetSymbolSafe(this.values[i], this.cancellationToken);
if (this.search == Search.Recursive &&
SymbolComparer.Equals(symbol, method))
{
this.values.RemoveAt(i);
continue;
}
if (invocation.TryGetArgumentValue(symbol as IParameterSymbol, this.cancellationToken, out ExpressionSyntax arg))
{
this.values[i] = arg;
}
}
this.values.PurgeDuplicates();
return(true);
}
private bool TryHandlePropertyGet(ExpressionSyntax propertyGet)
{
if (propertyGet == null)
{
return(false);
}
var property = this.semanticModel.GetSymbolSafe(propertyGet, this.cancellationToken) as IPropertySymbol;
var getter = property?.GetMethod;
if (getter == null)
{
return(false);
}
if (getter.DeclaringSyntaxReferences.Length == 0)
{
return(true);
}
foreach (var reference in getter.DeclaringSyntaxReferences)
{
base.Visit(reference.GetSyntax(this.cancellationToken));
}
for (var i = this.values.Count - 1; i >= 0; i--)
{
var symbol = this.semanticModel.GetSymbolSafe(this.values[i], this.cancellationToken);
if (this.search == Search.Recursive &&
SymbolComparer.Equals(symbol, property))
{
this.values.RemoveAt(i);
}
}
this.values.PurgeDuplicates();
return(true);
}
private void HandleAssignedValue(SyntaxNode assignee, ExpressionSyntax value)
{
if (value == null)
{
return;
}
if (assignee is VariableDeclaratorSyntax declarator &&
declarator.Identifier.ValueText != this.CurrentSymbol.Name)
{
return;
}
if (this.CurrentSymbol.IsEither <ILocalSymbol, IParameterSymbol>() &&
assignee is MemberAccessExpressionSyntax)
{
return;
}
if (this.context is ElementAccessExpressionSyntax)
{
switch (value)
{
case ArrayCreationExpressionSyntax arrayCreation:
{
if (arrayCreation.Initializer == null)
{
return;
}
foreach (var item in arrayCreation.Initializer.Expressions)
{
this.values.Add(item);
}
}
break;
case ObjectCreationExpressionSyntax objectCreation:
{
if (objectCreation.Initializer == null)
{
return;
}
foreach (var item in objectCreation.Initializer.Expressions)
{
if (item is InitializerExpressionSyntax kvp)
{
if (kvp.Expressions.Count == 2)
{
this.values.Add(kvp.Expressions[1]);
}
}
else if (item is AssignmentExpressionSyntax assignment)
{
this.values.Add(assignment.Right);
}
else
{
this.values.Add(item);
}
}
}
break;
case InitializerExpressionSyntax initializer:
{
foreach (var item in initializer.Expressions)
{
this.values.Add(item);
}
}
break;
default:
return;
}
return;
}
var assignedSymbol = this.semanticModel.GetSymbolSafe(assignee, this.cancellationToken) ??
this.semanticModel.GetDeclaredSymbolSafe(assignee, this.cancellationToken);
if (assignedSymbol == null)
{
return;
}
if (this.CurrentSymbol.IsEither <IFieldSymbol, IPropertySymbol>() &&
assignedSymbol is IPropertySymbol property &&
!SymbolComparer.Equals(this.CurrentSymbol, property) &&
Property.AssignsSymbolInSetter(property, this.CurrentSymbol, this.semanticModel, this.cancellationToken))
{
var before = this.values.Count;
foreach (var reference in property.DeclaringSyntaxReferences)
{
var declaration = (PropertyDeclarationSyntax)reference.GetSyntax(this.cancellationToken);
if (declaration.TryGetSetter(out var setter))
{
this.Visit(setter);
}
}
for (var i = before; i < this.values.Count; i++)
{
var parameter = this.semanticModel.GetSymbolSafe(this.values[i], this.cancellationToken) as IParameterSymbol;
if (Equals(parameter?.ContainingSymbol, property.SetMethod))
{
this.values[i] = value;
}
}
}
private static bool IsReturned(ILocalSymbol symbol, BlockSyntax block, SemanticModel semanticModel, CancellationToken cancellationToken)
{
using (var pooled = ReturnValueWalker.Create(block, Search.TopLevel, semanticModel, cancellationToken))
{
foreach (var value in pooled.Item)
{
var returnedSymbol = semanticModel.GetSymbolSafe(value, cancellationToken);
if (SymbolComparer.Equals(symbol, returnedSymbol))
{
return(true);
}
if (value is ObjectCreationExpressionSyntax objectCreation)
{
if (objectCreation.ArgumentList != null)
{
foreach (var argument in objectCreation.ArgumentList.Arguments)
{
var arg = semanticModel.GetSymbolSafe(argument.Expression, cancellationToken);
if (SymbolComparer.Equals(symbol, arg))
{
return(true);
}
}
}
if (objectCreation.Initializer != null)
{
foreach (var argument in objectCreation.Initializer.Expressions)
{
var arg = semanticModel.GetSymbolSafe(argument, cancellationToken);
if (SymbolComparer.Equals(symbol, arg))
{
return(true);
}
}
}
}
if (value is InvocationExpressionSyntax invocation)
{
if (returnedSymbol == KnownSymbol.RxDisposable.Create &&
invocation.ArgumentList != null &&
invocation.ArgumentList.Arguments.TryGetSingle(out ArgumentSyntax argument))
{
var body = (argument.Expression as ParenthesizedLambdaExpressionSyntax)?.Body;
using (var pooledInvocations = InvocationWalker.Create(body))
{
foreach (var candidate in pooledInvocations.Item.Invocations)
{
if (Disposable.IsDisposing(candidate, symbol, semanticModel, cancellationToken))
{
return(true);
}
}
}
}
}
}
}
return(false);
}
internal void HandleInvoke(IMethodSymbol method, ArgumentListSyntax argumentList)
{
if (method != null &&
(method.Parameters.TryFirst(x => x.RefKind != RefKind.None, out _) ||
this.CurrentSymbol.ContainingType.Is(method.ContainingType)))
{
if (TryGetWalker(out var walker))
{
foreach (var value in walker.values)
{
this.values.Add(GetArgumentValue(value));
}
foreach (var outValue in walker.outValues)
{
this.values.Add(GetArgumentValue(outValue));
}
}
}
bool TryGetWalker(out AssignedValueWalker result)
{
result = null;
if (TryGetKey(out var key))
{
if (this.memberWalkers.TryGetValue(key, out result))
{
return(false);
}
if (method.TrySingleDeclaration(this.cancellationToken, out var declaration))
{
result = Borrow(() => new AssignedValueWalker());
this.memberWalkers.Add(key, result);
result.CurrentSymbol = this.CurrentSymbol;
result.semanticModel = this.semanticModel;
result.cancellationToken = this.cancellationToken;
result.context = this.context.FirstAncestorOrSelf <ConstructorDeclarationSyntax>() != null ? this.context : declaration;
result.memberWalkers.Parent = this.memberWalkers;
if (argumentList != null)
{
foreach (var argument in argumentList.Arguments)
{
if (argument.RefOrOutKeyword.IsKind(SyntaxKind.RefKeyword) &&
TryGetMatchingParameter(argument, out var parameter))
{
result.refParameters.Add(parameter);
}
else if (argument.RefOrOutKeyword.IsKind(SyntaxKind.OutKeyword) &&
TryGetMatchingParameter(argument, out parameter))
{
result.outParameters.Add(parameter);
}
}
}
result.Visit(declaration);
}
}
return(result != null);
bool TryGetMatchingParameter(ArgumentSyntax argument, out IParameterSymbol parameter)
{
parameter = null;
if (this.semanticModel.GetSymbolSafe(argument.Expression, this.cancellationToken) is ISymbol symbol)
{
if (SymbolComparer.Equals(this.CurrentSymbol, symbol) ||
this.refParameters.Contains(symbol as IParameterSymbol) ||
this.outParameters.Contains(symbol as IParameterSymbol))
{
return(method.TryGetMatchingParameter(argument, out parameter));
}
}
return(false);
}
bool TryGetKey(out SyntaxNode node)
{
if (argumentList != null)
{
node = argumentList;
return(true);
}
return(method.TrySingleDeclaration(this.cancellationToken, out node));
}
}
ExpressionSyntax GetArgumentValue(ExpressionSyntax value)
{
if (value is IdentifierNameSyntax identifierName &&
method.Parameters.TryFirst(x => x.Name == identifierName.Identifier.ValueText, out var parameter))
{
if (argumentList.TryGetMatchingArgument(parameter, out var argument))
{
return(argument.Expression);
}
if (parameter.HasExplicitDefaultValue &&
parameter.TrySingleDeclaration(this.cancellationToken, out var parameterDeclaration))
{
return(parameterDeclaration.Default?.Value);
}
}
return(value);
}
}