private static bool TryGetParameterName(ISymbol member, TypeDeclarationSyntax typeDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken, out string parameterName) { parameterName = null; using (var walker = AssignmentExecutionWalker.For(member, typeDeclaration, Scope.Member, semanticModel, cancellationToken)) { foreach (var assignment in walker.Assignments) { if (assignment.Right is IdentifierNameSyntax identifierName && assignment.TryFirstAncestor <ConstructorDeclarationSyntax>(out var ctor) && ctor.TryFindParameter(identifierName.Identifier.ValueText, out _)) { if (parameterName == null) { parameterName = identifierName.Identifier.ValueText; } else if (parameterName != identifierName.Identifier.ValueText) { parameterName = null; return(false); } } } } return(parameterName != null); }
public static void FieldPrivateCtorCalledByInitializer(SearchScope scope) { var code = @" namespace N { internal class C { public static readonly C Default = new C(); private readonly int value; private C() { this.value = 1; } } }"; var syntaxTree = CSharpSyntaxTree.ParseText(code); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var field = semanticModel.GetDeclaredSymbolSafe(syntaxTree.FindFieldDeclaration("private readonly int value"), CancellationToken.None); var bar = syntaxTree.FindTypeDeclaration("C"); Assert.AreEqual(true, AssignmentExecutionWalker.FirstFor(field, bar, scope, semanticModel, CancellationToken.None, out var result)); Assert.AreEqual("this.value = 1", result.ToString()); Assert.AreEqual(true, AssignmentExecutionWalker.SingleFor(field, bar, scope, semanticModel, CancellationToken.None, out result)); Assert.AreEqual("this.value = 1", result.ToString()); using (var walker = AssignmentExecutionWalker.For(field, bar, scope, semanticModel, CancellationToken.None)) { Assert.AreEqual("this.value = 1", walker.Assignments.Single().ToString()); } }
public static void FieldWithCtorArg(SearchScope scope) { var code = @" namespace N { internal class C { private readonly int value; internal C(int arg) { this.value = arg; } } }"; var syntaxTree = CSharpSyntaxTree.ParseText(code); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindMemberAccessExpression("this.value"); var ctor = syntaxTree.FindConstructorDeclaration("C(int arg)"); var field = semanticModel.GetSymbolSafe(value, CancellationToken.None); Assert.AreEqual(true, AssignmentExecutionWalker.FirstFor(field, ctor, scope, semanticModel, CancellationToken.None, out var result)); Assert.AreEqual("this.value = arg", result.ToString()); Assert.AreEqual(true, AssignmentExecutionWalker.SingleFor(field, ctor, scope, semanticModel, CancellationToken.None, out result)); Assert.AreEqual("this.value = arg", result.ToString()); using (var walker = AssignmentExecutionWalker.For(field, ctor, scope, semanticModel, CancellationToken.None)) { Assert.AreEqual("this.value = arg", walker.Assignments.Single().ToString()); } }
private static bool TryGetParameterName(ISymbol member, TypeDeclarationSyntax typeDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken, [NotNullWhen(true)] out string?parameterName) { using (var walker = AssignmentExecutionWalker.For(member, typeDeclaration, SearchScope.Member, semanticModel, cancellationToken)) { foreach (var assignment in walker.Assignments) { if (assignment.Right is IdentifierNameSyntax { Identifier: { } identifier } &&
public void FieldWithCtorArgViaProperty(Scope scope) { var testCode = @" namespace RoslynSandbox { internal class Foo { private int number; internal Foo(int arg) { this.Number = arg; } public int Number { get { return this.number; } set { this.number = value; } } } }"; var syntaxTree = CSharpSyntaxTree.ParseText(testCode); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindMemberAccessExpression("this.number"); var ctor = syntaxTree.FindConstructorDeclaration("Foo(int arg)"); AssignmentExpressionSyntax result; var field = semanticModel.GetSymbolSafe(value, CancellationToken.None); if (scope != Scope.Member) { Assert.AreEqual(true, AssignmentExecutionWalker.FirstFor(field, ctor, scope, semanticModel, CancellationToken.None, out result)); Assert.AreEqual("this.number = value", result.ToString()); Assert.AreEqual(true, AssignmentExecutionWalker.SingleFor(field, ctor, scope, semanticModel, CancellationToken.None, out result)); Assert.AreEqual("this.number = value", result.ToString()); using (var walker = AssignmentExecutionWalker.For(field, ctor, scope, semanticModel, CancellationToken.None)) { Assert.AreEqual("this.number = value", walker.Assignments.Single().ToString()); } } else { Assert.AreEqual(false, AssignmentExecutionWalker.FirstFor(field, ctor, scope, semanticModel, CancellationToken.None, out result)); } }
public static void FieldInPropertyExpressionBody(SearchScope scope) { var code = @" namespace N { internal class C { private int number; internal C() { var i = this.Number; } public int Number => this.number = 3; } }"; var syntaxTree = CSharpSyntaxTree.ParseText(code); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindMemberAccessExpression("this.number"); var ctor = syntaxTree.FindConstructorDeclaration("C()"); AssignmentExpressionSyntax result; var field = semanticModel.GetSymbolSafe(value, CancellationToken.None); if (scope != SearchScope.Member) { Assert.AreEqual(true, AssignmentExecutionWalker.FirstFor(field, ctor, scope, semanticModel, CancellationToken.None, out result)); Assert.AreEqual("this.number = 3", result.ToString()); Assert.AreEqual(true, AssignmentExecutionWalker.SingleFor(field, ctor, scope, semanticModel, CancellationToken.None, out result)); Assert.AreEqual("this.number = 3", result.ToString()); using (var walker = AssignmentExecutionWalker.For(field, ctor, scope, semanticModel, CancellationToken.None)) { Assert.AreEqual("this.number = 3", walker.Assignments.Single().ToString()); } } else { Assert.AreEqual(false, AssignmentExecutionWalker.FirstFor(field, ctor, scope, semanticModel, CancellationToken.None, out _)); } }
internal static bool IsValueValidForRegisteredType(ExpressionSyntax value, ITypeSymbol registeredType, SemanticModel semanticModel, CancellationToken cancellationToken, PooledSet <SyntaxNode>?visited = null) { switch (value) { case ConditionalExpressionSyntax conditional: return(IsValueValidForRegisteredType(conditional.WhenTrue, registeredType, semanticModel, cancellationToken, visited) && IsValueValidForRegisteredType(conditional.WhenFalse, registeredType, semanticModel, cancellationToken, visited)); case BinaryExpressionSyntax binary when binary.IsKind(SyntaxKind.CoalesceExpression): return(IsValueValidForRegisteredType(binary.Left, registeredType, semanticModel, cancellationToken, visited) && IsValueValidForRegisteredType(binary.Right, registeredType, semanticModel, cancellationToken, visited)); } if (registeredType.TypeKind == TypeKind.Enum) { return(semanticModel.TryGetType(value, cancellationToken, out var valueType) && valueType.MetadataName == registeredType.MetadataName && Equals(valueType.ContainingType, registeredType.ContainingType) && NamespaceSymbolComparer.Equals(valueType.ContainingNamespace, registeredType.ContainingNamespace)); } if (semanticModel.IsRepresentationPreservingConversion(value, registeredType)) { return(true); } if (semanticModel.TryGetSymbol(value, cancellationToken, out var symbol)) { if (symbol is IFieldSymbol field) { if (field.TrySingleDeclaration(cancellationToken, out var fieldDeclaration)) { if (fieldDeclaration.Declaration is { } variableDeclaration&& variableDeclaration.Variables.TryLast(out var variable) && variable.Initializer is { } initializer&& !IsValueValidForRegisteredType(initializer.Value, registeredType, semanticModel, cancellationToken, visited)) { return(false); } return(IsAssignedValueOfRegisteredType(symbol, fieldDeclaration)); } return(field.Type == KnownSymbols.Object); } if (symbol is IPropertySymbol property) { if (property.TrySingleDeclaration(cancellationToken, out PropertyDeclarationSyntax? propertyDeclaration)) { if (propertyDeclaration.Initializer is { } initializer&& !IsValueValidForRegisteredType(initializer.Value, registeredType, semanticModel, cancellationToken, visited)) { return(false); } if (property.SetMethod == null && property.GetMethod is { } getMethod) { return(IsReturnValueOfRegisteredType(getMethod)); } return(IsAssignedValueOfRegisteredType(symbol, propertyDeclaration)); } return(property.Type == KnownSymbols.Object); } if (symbol is IMethodSymbol method) { return(IsReturnValueOfRegisteredType(method)); } } return(false); bool IsAssignedValueOfRegisteredType(ISymbol memberSymbol, MemberDeclarationSyntax declaration) { if (declaration.TryFirstAncestor(out TypeDeclarationSyntax? typeDeclaration)) { using (var walker = AssignmentExecutionWalker.For(memberSymbol, typeDeclaration, SearchScope.Type, semanticModel, cancellationToken)) { foreach (var assignment in walker.Assignments) { if (!IsValueValidForRegisteredType(assignment.Right, registeredType, semanticModel, cancellationToken, visited)) { return(false); } } } } return(true); } bool IsReturnValueOfRegisteredType(IMethodSymbol method) { if (method.TrySingleMethodDeclaration(cancellationToken, out var target)) { #pragma warning disable IDISP003 // Dispose previous before re-assigning. using (visited = visited.IncrementUsage()) #pragma warning restore IDISP003 // Dispose previous before re-assigning. { if (visited.Add(target)) { using (var walker = ReturnValueWalker.Borrow(target)) { foreach (var returnValue in walker.ReturnValues) { if (!IsValueValidForRegisteredType(returnValue, registeredType, semanticModel, cancellationToken, visited)) { return(false); } } } } return(true); } } return(method.ReturnType == KnownSymbols.Object); } }