/// <summary>
/// Determines if two trees are the same, disregarding trivia differences.
/// </summary>
/// <param name="oldTree">The original tree.</param>
/// <param name="newTree">The new tree.</param>
/// <param name="topLevel">
/// If true then the trees are equivalent if the contained nodes and tokens declaring
/// metadata visible symbolic information are equivalent, ignoring any differences of nodes inside method bodies
/// or initializer expressions, otherwise all nodes and tokens must be equivalent.
/// </param>
public virtual bool AreEquivalent(SyntaxTree oldTree, SyntaxTree newTree, bool topLevel)
{
if (oldTree == null && newTree == null)
{
return(true);
}
if (oldTree == null || newTree == null)
{
return(false);
}
return(SyntaxEquivalence.AreEquivalent(oldTree, newTree, ignoreChildNode: null, topLevel: topLevel));
}
/// <summary>
/// Determines if two lists of syntax nodes are the same, disregarding trivia differences.
/// </summary>
/// <param name="oldList">The old list.</param>
/// <param name="newList">The new list.</param>
/// <param name="ignoreChildNode">
/// If specified called for every child syntax node (not token) that is visited during the comparison.
/// If it returns true the child is recursively visited, otherwise the child and its subtree is disregarded.
/// </param>
public virtual bool AreEquivalent <TNode>(SeparatedSyntaxList <TNode> oldList, SeparatedSyntaxList <TNode> newList, Func <int, bool> ignoreChildNode = null)
where TNode : SyntaxNode
{
return(SyntaxEquivalence.AreEquivalent(oldList.Node, newList.Node, ignoreChildNode, topLevel: false));
}
/// <summary>
/// Determines if two lists of syntax nodes are the same, disregarding trivia differences.
/// </summary>
/// <param name="oldList">The old list.</param>
/// <param name="newList">The new list.</param>
/// <param name="topLevel">
/// If true then the nodes are equivalent if the contained nodes and tokens declaring
/// metadata visible symbolic information are equivalent, ignoring any differences of nodes inside method bodies
/// or initializer expressions, otherwise all nodes and tokens must be equivalent.
/// </param>
public virtual bool AreEquivalent <TNode>(SeparatedSyntaxList <TNode> oldList, SeparatedSyntaxList <TNode> newList, bool topLevel)
where TNode : SyntaxNode
{
return(SyntaxEquivalence.AreEquivalent(oldList.Node, newList.Node, null, topLevel));
}
/// <summary>
/// Determines if two lists of tokens are the same, disregarding trivia differences.
/// </summary>
/// <param name="oldList">The old token list.</param>
/// <param name="newList">The new token list.</param>
public virtual bool AreEquivalent(SyntaxTokenList oldList, SyntaxTokenList newList)
{
return(SyntaxEquivalence.AreEquivalent(oldList, newList));
}
/// <summary>
/// Determines if two syntax tokens are the same, disregarding trivia differences.
/// </summary>
/// <param name="oldToken">The old token.</param>
/// <param name="newToken">The new token.</param>
public virtual bool AreEquivalent(SyntaxToken oldToken, SyntaxToken newToken)
{
return(SyntaxEquivalence.AreEquivalent(oldToken, newToken));
}
/// <summary>
/// Determines if two syntax nodes are the same, disregarding trivia differences.
/// </summary>
/// <param name="oldNode">The old node.</param>
/// <param name="newNode">The new node.</param>
/// <param name="ignoreChildNode">
/// If specified called for every child syntax node (not token) that is visited during the comparison.
/// If it returns true the child is recursively visited, otherwise the child and its subtree is disregarded.
/// </param>
public virtual bool AreEquivalent(SyntaxNode oldNode, SyntaxNode newNode, Func <int, bool> ignoreChildNode = null)
{
return(SyntaxEquivalence.AreEquivalent(oldNode, newNode, ignoreChildNode: ignoreChildNode, topLevel: false));
}
/// <summary>
/// Determines if two syntax nodes are the same, disregarding trivia differences.
/// </summary>
/// <param name="oldNode">The old node.</param>
/// <param name="newNode">The new node.</param>
/// <param name="topLevel">
/// If true then the nodes are equivalent if the contained nodes and tokens declaring
/// metadata visible symbolic information are equivalent, ignoring any differences of nodes inside method bodies
/// or initializer expressions, otherwise all nodes and tokens must be equivalent.
/// </param>
public virtual bool AreEquivalent(SyntaxNode oldNode, SyntaxNode newNode, bool topLevel)
{
return(SyntaxEquivalence.AreEquivalent(oldNode, newNode, ignoreChildNode: null, topLevel: topLevel));
}
