public void PushToken(ref SyntaxNodeOrToken value)
{
tokenStack.Push(value);
discriminatorStack.Push(Which.Token);
}
/// <summary> /// Gets a list of all the diagnostics in either the sub tree that has the specified node as its root or /// associated with the token and its related trivia. /// This method does not filter diagnostics based on #pragmas and compiler options /// like nowarn, warnaserror etc. /// </summary> public abstract IEnumerable <Diagnostic> GetDiagnostics(SyntaxNodeOrToken nodeOrToken);
public SyntaxNodeOrTokenList Add(SyntaxNodeOrToken nodeOrToken)
{
return(Insert(this.Count, nodeOrToken));
}
public SourceLocation(SyntaxNodeOrToken nodeOrToken)
: this(nodeOrToken.SyntaxTree, nodeOrToken.Span)
{
}
private static bool AreSimilar(SyntaxNodeOrToken node1, SyntaxNodeOrToken node2)
{
return(node1.RawKind == node2.RawKind);
}
private static bool AreIdentical(SyntaxNodeOrToken node1, SyntaxNodeOrToken node2)
{
return(node1.UnderlyingNode == node2.UnderlyingNode);
}
private int GetSimilarity(SyntaxNodeOrToken node1, SyntaxNodeOrToken node2)
{
// count the characters in the common/identical nodes
int w = 0;
_nodeSimilaritySet.Clear();
_tokenTextSimilaritySet.Clear();
if (node1.IsToken && node2.IsToken)
{
string text1 = node1.ToString();
string text2 = node2.ToString();
if (text1 == text2)
{
// main text of token is the same
w += text1.Length;
}
foreach (SyntaxTrivia tr in node1.GetLeadingTrivia())
{
_nodeSimilaritySet.Add(tr.UnderlyingNode);
}
foreach (SyntaxTrivia tr in node1.GetTrailingTrivia())
{
_nodeSimilaritySet.Add(tr.UnderlyingNode);
}
foreach (SyntaxTrivia tr in node2.GetLeadingTrivia())
{
if (_nodeSimilaritySet.Contains(tr.UnderlyingNode))
{
w += tr.FullSpan.Length;
}
}
foreach (SyntaxTrivia tr in node2.GetTrailingTrivia())
{
if (_nodeSimilaritySet.Contains(tr.UnderlyingNode))
{
w += tr.FullSpan.Length;
}
}
}
else
{
foreach (SyntaxNodeOrToken n1 in node1.ChildNodesAndTokens())
{
_nodeSimilaritySet.Add(n1.UnderlyingNode);
if (n1.IsToken)
{
_tokenTextSimilaritySet.Add(n1.ToString());
}
}
foreach (SyntaxNodeOrToken n2 in node2.ChildNodesAndTokens())
{
if (_nodeSimilaritySet.Contains(n2.UnderlyingNode))
{
w += n2.FullSpan.Length;
}
else if (n2.IsToken)
{
string tokenText = n2.ToString();
if (_tokenTextSimilaritySet.Contains(tokenText))
{
w += tokenText.Length;
}
}
}
}
return(w);
}
private void FindBestMatch(Stack <SyntaxNodeOrToken> stack, SyntaxNodeOrToken node, out int index, out int similarity, int startIndex = 0)
{
index = -1;
similarity = -1;
int i = 0;
foreach (SyntaxNodeOrToken stackNode in stack)
{
if (i >= MaxSearchLength)
{
break;
}
if (i >= startIndex)
{
if (AreIdentical(stackNode, node))
{
int sim = node.FullSpan.Length;
if (sim > similarity)
{
index = i;
similarity = sim;
return;
}
}
else if (AreSimilar(stackNode, node))
{
int sim = GetSimilarity(stackNode, node);
// Are these really the same? This may be expensive so only check this if
// similarity is rated equal to them being identical.
if (sim == node.FullSpan.Length && node.IsToken)
{
if (stackNode.ToFullString() == node.ToFullString())
{
index = i;
similarity = sim;
return;
}
}
if (sim > similarity)
{
index = i;
similarity = sim;
}
}
else
{
// check one level deep inside list node's children
int j = 0;
foreach (SyntaxNodeOrToken child in stackNode.ChildNodesAndTokens())
{
if (j >= MaxSearchLength)
{
break;
}
j++;
if (AreIdentical(child, node))
{
index = i;
similarity = node.FullSpan.Length;
return;
}
else if (AreSimilar(child, node))
{
int sim = GetSimilarity(child, node);
if (sim > similarity)
{
index = i;
similarity = sim;
}
}
}
}
}
i++;
}
}
