public static void Equals() { var syntaxTree = CSharpSyntaxTree.ParseText( @" namespace N { public class C { public int P1 { get; } public int P2 { get; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node1 = syntaxTree.FindPropertyDeclaration("P1"); var symbol1 = semanticModel.GetDeclaredSymbol(node1, CancellationToken.None); var node2 = syntaxTree.FindPropertyDeclaration("P2"); var symbol2 = semanticModel.GetDeclaredSymbol(node2, CancellationToken.None); Assert.AreEqual(true, SymbolComparer.Equals((ISymbol)symbol1, (ISymbol)symbol1)); Assert.AreEqual(false, SymbolComparer.Equals((ISymbol)symbol1, (ISymbol)symbol2)); Assert.AreEqual(true, PropertySymbolComparer.Equals(symbol1, symbol1)); Assert.AreEqual(false, PropertySymbolComparer.Equals(symbol1, symbol2)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), PropertySymbolComparer.Default.GetHashCode(symbol1)); Assert.AreNotEqual(SymbolComparer.Default.GetHashCode(symbol1), PropertySymbolComparer.Default.GetHashCode(symbol2)); }
public static void Equals() { var syntaxTree = CSharpSyntaxTree.ParseText( @" namespace N { public class C { public C() { var bar1; var bar2; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node1 = syntaxTree.FindVariableDeclaration("bar1"); var symbol1 = semanticModel.GetDeclaredSymbol(node1.Variables[0], CancellationToken.None); var node2 = syntaxTree.FindVariableDeclaration("bar2"); var symbol2 = semanticModel.GetDeclaredSymbol(node2.Variables[0], CancellationToken.None); Assert.AreEqual(true, SymbolComparer.Equals(symbol1, symbol1)); Assert.AreEqual(false, SymbolComparer.Equals(symbol1, symbol2)); Assert.AreEqual(true, LocalSymbolComparer.Equals((ILocalSymbol)symbol1, (ILocalSymbol)symbol1)); Assert.AreEqual(false, LocalSymbolComparer.Equals((ILocalSymbol)symbol1, (ILocalSymbol)symbol2)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), LocalSymbolComparer.Default.GetHashCode((ILocalSymbol)symbol1)); Assert.AreNotEqual(SymbolComparer.Default.GetHashCode(symbol1), LocalSymbolComparer.Default.GetHashCode((ILocalSymbol)symbol2)); }
public void Equals() { var syntaxTree = CSharpSyntaxTree.ParseText( @" namespace RoslynSandbox { using System; public class Foo { public event EventHandler Bar1; public event EventHandler Bar2; } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node1 = syntaxTree.FindEventFieldDeclaration("Bar1"); var symbol1 = semanticModel.GetDeclaredSymbol(node1.Declaration.Variables[0], CancellationToken.None); var node2 = syntaxTree.FindEventFieldDeclaration("Bar2"); var symbol2 = semanticModel.GetDeclaredSymbol(node2.Declaration.Variables[0], CancellationToken.None); Assert.AreEqual(true, SymbolComparer.Equals(symbol1, symbol1)); Assert.AreEqual(false, SymbolComparer.Equals(symbol1, symbol2)); Assert.AreEqual(true, EventSymbolComparer.Equals((IEventSymbol)symbol1, (IEventSymbol)symbol1)); Assert.AreEqual(false, EventSymbolComparer.Equals((IEventSymbol)symbol1, (IEventSymbol)symbol2)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), EventSymbolComparer.Default.GetHashCode((IEventSymbol)symbol1)); Assert.AreNotEqual(SymbolComparer.Default.GetHashCode(symbol1), EventSymbolComparer.Default.GetHashCode((IEventSymbol)symbol2)); }
public void Equals() { var syntaxTree = CSharpSyntaxTree.ParseText( @" namespace RoslynSandbox { public class Foo1 { } public class Foo2 { } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node1 = syntaxTree.FindTypeDeclaration("Foo1"); var symbol1 = semanticModel.GetDeclaredSymbol(node1, CancellationToken.None); var node2 = syntaxTree.FindTypeDeclaration("Foo2"); var symbol2 = semanticModel.GetDeclaredSymbol(node2, CancellationToken.None); Assert.AreEqual(true, SymbolComparer.Equals((ISymbol)symbol1, (ISymbol)symbol1)); Assert.AreEqual(false, SymbolComparer.Equals((ISymbol)symbol1, (ISymbol)symbol2)); Assert.AreEqual(true, TypeSymbolComparer.Equals((ITypeSymbol)symbol1, (ITypeSymbol)symbol1)); Assert.AreEqual(false, TypeSymbolComparer.Equals((ITypeSymbol)symbol1, (ITypeSymbol)symbol2)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), TypeSymbolComparer.GetHashCode(symbol1)); Assert.AreNotEqual(SymbolComparer.Default.GetHashCode(symbol1), TypeSymbolComparer.GetHashCode(symbol2)); }
public void GenericMethodsArgumentTypeParameterEquals() { var syntaxTree = CSharpSyntaxTree.ParseText( @" namespace RoslynSandbox { public class Foo<T> { public int Bar1(T x) => 1; public int Bar2(T x) => 2; } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node1 = syntaxTree.FindMethodDeclaration("Bar1"); var symbol1 = semanticModel.GetDeclaredSymbol(node1, CancellationToken.None).Parameters[0].Type; var node2 = syntaxTree.FindMethodDeclaration("Bar2"); var symbol2 = semanticModel.GetDeclaredSymbol(node2, CancellationToken.None).Parameters[0].Type; Assert.AreEqual(true, SymbolComparer.Equals((ISymbol)symbol1, (ISymbol)symbol1)); Assert.AreEqual(true, SymbolComparer.Equals((ISymbol)symbol1, (ISymbol)symbol2)); Assert.AreEqual(true, TypeSymbolComparer.Equals((ITypeSymbol)symbol1, (ITypeSymbol)symbol1)); Assert.AreEqual(true, TypeSymbolComparer.Equals((ITypeSymbol)symbol1, (ITypeSymbol)symbol2)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), TypeSymbolComparer.GetHashCode(symbol1)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), TypeSymbolComparer.GetHashCode(symbol2)); }
public static int RightSideOfAssignmentCount(ISymbol variable, BlockSyntax block, SemanticModel semanticModel, CancellationToken cancellationToken) { int count = 0; using (var walker = AssignmentWalker.Borrow(block, Search.TopLevel, semanticModel, cancellationToken)) { foreach (AssignmentExpressionSyntax assignment in walker.Assignments) { var right = semanticModel.GetSymbolSafe(CastUtils.UnWrapCast(assignment.Right), cancellationToken); if (right != null && right.Equals(variable)) { count++; } } } using (var walker = VariableDeclarationWalker.Borrow(block, Search.TopLevel, semanticModel, cancellationToken)) { foreach (VariableDeclaratorSyntax delc in walker.Declarations) { var rightSymbol = semanticModel.GetSymbolSafe(CastUtils.UnWrapCast(delc.Initializer.Value), cancellationToken); if (SymbolComparer.Equals(variable, rightSymbol)) { count++; } } } return(count); }
private bool TryGetReplaceNode(MemberAccessExpressionSyntax node, MemberAccessExpressionSyntax expected, out SyntaxNode result) { result = null; if (node == null || expected == null) { return(false); } if (node.Name.Identifier.ValueText != expected.Name.Identifier.ValueText) { return(false); } var nodeSymbol = this.semanticModel.GetSymbolSafe(node, this.cancellationToken); var expectedSymbol = this.semanticModel.GetSymbolSafe(this.identifierName, this.cancellationToken); if (nodeSymbol == null || expectedSymbol == null || !SymbolComparer.Equals(nodeSymbol, expectedSymbol)) { return(false); } if (!GU0007PreferInjecting.IsRootValid(node, this.semanticModel, this.cancellationToken)) { return(false); } result = node; return(true); }
public static void ProcessReturnStatement(ISymbol local, BlockSyntax block, SemanticModel semanticModel, CancellationToken cancellationToken, RefCounterStatus status) { using (var walker = ReturnValueWalker.Borrow(block, Search.TopLevel, semanticModel, cancellationToken)) { foreach (var value in walker) { var returnedSymbol = semanticModel.GetSymbolSafe(value, cancellationToken); if (SymbolComparer.Equals(local, returnedSymbol)) { var method = block.FirstAncestor <MethodDeclarationSyntax>(); var access = block.FirstAncestor <AccessorDeclarationSyntax>(); bool isGet = false; if (method != null) { isGet = KnownSymbol.IsGetMethodName(method.Identifier.ToString()); } else if (access != null) { isGet = true; } if (isGet) { status.RemainRef("return value from get method", value.GetLocation()); } else { status.ReleaseReference("return value from non get", value.GetLocation()); } } } } }
public void Inherited() { var syntaxTree = CSharpSyntaxTree.ParseText( @" namespace RoslynSandbox { public class Foo { protected int Bar; } public class Bar : Foo { public Bar() { var temp = this.Bar; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node1 = syntaxTree.FindFieldDeclaration("Bar"); var symbol1 = semanticModel.GetDeclaredSymbol(node1.Declaration.Variables[0], CancellationToken.None); var node2 = syntaxTree.FindMemberAccessExpression("this.Bar"); var symbol2 = semanticModel.GetSymbolInfo(node2, CancellationToken.None).Symbol; Assert.AreEqual(true, SymbolComparer.Equals(symbol1, symbol1)); Assert.AreEqual(true, SymbolComparer.Equals(symbol1, symbol2)); Assert.AreEqual(true, FieldSymbolComparer.Equals((IFieldSymbol)symbol1, (IFieldSymbol)symbol1)); Assert.AreEqual(true, FieldSymbolComparer.Equals((IFieldSymbol)symbol1, (IFieldSymbol)symbol2)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), FieldSymbolComparer.Default.GetHashCode((IFieldSymbol)symbol1)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), FieldSymbolComparer.Default.GetHashCode((IFieldSymbol)symbol2)); }
public void EqualsTest() { SymbolComparer sc = new SymbolComparer(); AbstractionSyntaxTree a = new AbstractionSyntaxTree(">(a,b)"); AbstractionSyntaxTree b = new AbstractionSyntaxTree(">(a,b)"); Assert.IsTrue(sc.Equals(a.Root, b.Root)); a = new AbstractionSyntaxTree("&(&(a,b), c)"); b = new AbstractionSyntaxTree("&(&(a,b), c)"); Assert.IsTrue(sc.Equals(a.Root, b.Root)); a = new AbstractionSyntaxTree(">(a,b)"); b = new AbstractionSyntaxTree("|(~(a), b)"); Assert.IsFalse(sc.Equals(a.Root, b.Root)); }
public bool Equals(ConstructorModelBindingInvocation?other) { if (other is null) { return(false); } return(base.Equals(other) && SymbolComparer.Equals(Constructor, other.Constructor)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (node.Identifier.ValueText == this.from.Name) { if (SymbolComparer.Equals(this.semanticModel.GetSymbolSafe(node, this.cancellationToken), this.from)) { return(SyntaxFactory.IdentifierName(this.to.Name)); } } return(base.VisitIdentifierName(node)); }
public static void Equals() { var syntaxTree = CSharpSyntaxTree.ParseText( @" namespace N { public class C { public int M(int i1, int i2) => 1; } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }); var semanticModel = compilation.GetSemanticModel(syntaxTree); var parameters = syntaxTree.FindMethodDeclaration("M").ParameterList.Parameters; var symbol1 = semanticModel.GetDeclaredSymbol(parameters[0], CancellationToken.None); var symbol2 = semanticModel.GetDeclaredSymbol(parameters[1], CancellationToken.None); Assert.AreEqual(true, SymbolComparer.Equals((ISymbol)symbol1, (ISymbol)symbol1)); Assert.AreEqual(false, SymbolComparer.Equals((ISymbol)symbol1, (ISymbol)symbol2)); Assert.AreEqual(true, ParameterSymbolComparer.Equals(symbol1, symbol1)); Assert.AreEqual(false, ParameterSymbolComparer.Equals(symbol1, symbol2)); Assert.AreEqual(SymbolComparer.Default.GetHashCode(symbol1), ParameterSymbolComparer.Default.GetHashCode(symbol1)); Assert.AreNotEqual(SymbolComparer.Default.GetHashCode(symbol1), ParameterSymbolComparer.Default.GetHashCode(symbol2)); }
public static void RegisterCompilationStartAction(CompilationStartAnalysisContext csac) { var item = GetTypeSymbol(csac.Compilation); if (item.Item1 == null || item.Item2 == null || item.Item3 == null || item.Item4 == null || item.Item5 == null) { return; } var sta = csac.Compilation.Assembly.GetAttributes().FirstOrDefault(attr => SymbolComparer.Equals(attr.AttributeClass, item.Item5)); string startupName; #if DEBUG if (sta == null) { startupName = $"{csac.Compilation.Assembly.Name}.Startup"; } #else if (sta == null) { return; } #endif else if (sta.ConstructorArguments.Length == 1) { if (sta.ConstructorArguments[0].Value is INamedTypeSymbol st && SymbolComparer.Equals(st.ContainingAssembly, csac.Compilation.Assembly)) { startupName = $"{st.ContainingNamespace.Name}.{st.Name}"; } else { return; } }
private bool AreEventsEqual(EventSymbol @event, EventSymbol other) { Debug.Assert(StringOrdinalComparer.Equals(@event.Name, other.Name)); return(_comparer.Equals(@event.Type, other.Type)); }