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));
}