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); }
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 = Borrow(scope, search, semanticModel, cancellationToken)) { foreach (var candidate in pooledAssignments.Assignments) { if (candidate.Right is ConditionalExpressionSyntax conditional) { if (SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(conditional.WhenTrue, cancellationToken)) || SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(conditional.WhenFalse, cancellationToken))) { assignment = candidate; return(true); } } 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); }
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 ParameterSyntax 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 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); }
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); }
private bool TryHandleInvocation(MemberAccessExpressionSyntax 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 (symbol is IParameterSymbol parameter && parameter.IsThis) { this.values[i] = invocation.Expression; } } this.values.PurgeDuplicates(); return(true); }
internal static bool IsDisposing(InvocationExpressionSyntax invocation, ISymbol member, SemanticModel semanticModel, CancellationToken cancellationToken) { if (invocation.Expression is MemberAccessExpressionSyntax memberAccess && memberAccess.Name is IdentifierNameSyntax methodName && methodName.Identifier.ValueText != "Dispose") { return(false); } if (semanticModel.GetSymbolSafe(invocation, cancellationToken) is IMethodSymbol method && method.Parameters.Length == 0 && method == KnownSymbol.RefCounter.Dispose && TryGetDisposedRootMember(invocation, semanticModel, cancellationToken, out var disposed)) { if (SymbolComparer.Equals(member, semanticModel.GetSymbolSafe(disposed, cancellationToken))) { return(true); } } return(false); }
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); }
internal static bool FirstForSymbol(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 = Borrow(scope, search, semanticModel, cancellationToken)) { foreach (var candidate in pooledAssignments.Assignments) { var assignedSymbol = semanticModel.GetSymbolSafe(candidate.Left, cancellationToken); if (SymbolComparer.Equals(symbol, assignedSymbol)) { assignment = candidate; return(true); } } } return(false); }
internal static bool IsDisposedBefore(ISymbol symbol, ExpressionSyntax assignment, SemanticModel semanticModel, CancellationToken cancellationToken) { bool IsDisposing(InvocationExpressionSyntax invocation, ISymbol current) { if (invocation.TryGetInvokedMethodName(out var name) && name != "Dispose") { return(false); } var invokedSymbol = semanticModel.GetSymbolSafe(invocation, cancellationToken); if (invokedSymbol?.Name != "Dispose") { return(false); } var statement = invocation.FirstAncestorOrSelf <StatementSyntax>(); if (statement != null) { using (var names = IdentifierNameWalker.Borrow(statement)) { foreach (var identifierName in names.IdentifierNames) { if (identifierName.Identifier.ValueText == current.Name && SymbolComparer.Equals(current, semanticModel.GetSymbolSafe(identifierName, cancellationToken))) { return(true); } } } } return(false); } bool TryGetScope(SyntaxNode node, out BlockSyntax result) { result = null; if (node.FirstAncestor <AnonymousFunctionExpressionSyntax>() is AnonymousFunctionExpressionSyntax lambda) { result = lambda.Body as BlockSyntax; } else if (node.FirstAncestor <AccessorDeclarationSyntax>() is AccessorDeclarationSyntax accessor) { result = accessor.Body; } else if (node.FirstAncestor <BaseMethodDeclarationSyntax>() is BaseMethodDeclarationSyntax method) { result = method.Body; } return(result != null); } if (TryGetScope(assignment, out var block)) { using (var walker = InvocationWalker.Borrow(block)) { foreach (var invocation in walker.Invocations) { if (invocation.IsBeforeInScope(assignment) != Result.Yes) { continue; } if (IsDisposing(invocation, symbol)) { return(true); } } } } if (assignment is AssignmentExpressionSyntax assignmentExpression && semanticModel.GetSymbolSafe(assignmentExpression.Left, cancellationToken) is IPropertySymbol property && property.TryGetSetter(cancellationToken, out var setter)) { using (var pooled = InvocationWalker.Borrow(setter)) { foreach (var invocation in pooled.Invocations) { if (IsDisposing(invocation, symbol) || IsDisposing(invocation, property)) { return(true); } } } } return(false); }
private static bool IsReturned(ILocalSymbol symbol, BlockSyntax block, SemanticModel semanticModel, CancellationToken cancellationToken) { using (var walker = ReturnValueWalker.Borrow(block, Search.TopLevel, semanticModel, cancellationToken)) { foreach (var value in walker) { 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) && argument.Expression is ParenthesizedLambdaExpressionSyntax lambda) { var body = lambda.Body; using (var pooledInvocations = InvocationWalker.Borrow(body)) { foreach (var candidate in pooledInvocations.Invocations) { if (Disposable.IsDisposing(candidate, symbol, semanticModel, cancellationToken)) { return(true); } } } } } } } return(false); }
private void HandleAssignedValue(SyntaxNode assignee, ExpressionSyntax value) { if (value == null) { return; } var assignedSymbol = this.semanticModel.GetSymbolSafe(assignee, this.cancellationToken) ?? this.semanticModel.GetDeclaredSymbolSafe(assignee, this.cancellationToken); if (assignedSymbol == null) { 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 property = assignedSymbol as IPropertySymbol; if (!SymbolComparer.Equals(this.CurrentSymbol, property) && (this.CurrentSymbol is IFieldSymbol || this.CurrentSymbol is IPropertySymbol) && property != null && 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.TryGetSetAccessorDeclaration(out AccessorDeclarationSyntax 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; } } } else { if (SymbolComparer.Equals(this.CurrentSymbol, assignedSymbol) || this.refParameters.Contains(assignedSymbol as IParameterSymbol)) { this.values.Add(value); } } }
internal static void AllWith(ISymbol symbol, SyntaxNode scope, Search search, SemanticModel semanticModel, CancellationToken cancellationToken, List <AssignmentExpressionSyntax> assignments) { if (symbol == null || scope == null) { return; } using (var walker = Borrow(scope, Search.TopLevel, semanticModel, cancellationToken)) { foreach (var candidate in walker.Assignments) { if (candidate.Right is ConditionalExpressionSyntax conditional) { if (SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(conditional.WhenTrue, cancellationToken)) || SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(conditional.WhenFalse, cancellationToken))) { assignments.Add(candidate); } } if (candidate.Right is BinaryExpressionSyntax binary && binary.IsKind(SyntaxKind.CoalesceExpression)) { if (SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(binary.Left, cancellationToken)) || SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(binary.Right, cancellationToken))) { assignments.Add(candidate); } } var assignedSymbol = semanticModel.GetSymbolSafe(candidate.Right, cancellationToken); if (SymbolComparer.Equals(symbol, assignedSymbol)) { assignments.Add(candidate); } if (candidate.Right is ObjectCreationExpressionSyntax objectCreation && objectCreation.ArgumentList != null && objectCreation.ArgumentList.Arguments.TryFirst(x => SymbolComparer.Equals(symbol, semanticModel.GetSymbolSafe(x.Expression, cancellationToken)), out ArgumentSyntax _)) { assignments.Add(candidate); } } if (search == Search.Recursive) { foreach (var argument in walker.arguments) { if (argument.Expression is IdentifierNameSyntax identifierName && identifierName.Identifier.ValueText == symbol.Name && semanticModel.GetSymbolSafe(argument.Parent?.Parent, cancellationToken) is IMethodSymbol method && method.TrySingleDeclaration(cancellationToken, out BaseMethodDeclarationSyntax methodDeclaration) && methodDeclaration.TryGetMatchingParameter(argument, out var parameter)) { AllWith(semanticModel.GetDeclaredSymbolSafe(parameter, cancellationToken), methodDeclaration, search, semanticModel, cancellationToken, assignments); } } } } }