public void WithLotsOfChildrenTest()
{
var alphabet = "abcdefghijklmnopqrstuvwxyz";
var commaSeparatedList = string.Join(",", (IEnumerable <char>)alphabet);
var parsedArgumentList = SyntaxFactory.ParseArgumentList(commaSeparatedList);
Assert.Equal(alphabet.Length, parsedArgumentList.Arguments.Count);
for (int position = 0; position < parsedArgumentList.FullWidth; position++)
{
var item = ChildSyntaxList.ChildThatContainsPosition(parsedArgumentList, position);
Assert.Equal(position, item.Position);
Assert.Equal(1, item.Width);
if (position % 2 == 0)
{
// Even. We should get a node
Assert.True(item.IsNode);
Assert.True(item.IsKind(SyntaxKind.Argument));
string expectedArgName = ((char)('a' + (position / 2))).ToString();
Assert.Equal(expectedArgName, ((ArgumentSyntax)item).Expression.ToString());
}
else
{
// Odd. We should get a comma
Assert.True(item.IsToken);
Assert.True(item.IsKind(SyntaxKind.CommaToken));
int expectedTokenIndex = position + 1; // + 1 because there is a (missing) OpenParen at slot 0
Assert.Equal(expectedTokenIndex, item.AsToken().Index);
}
}
}
internal SyntaxToken(CSharpSyntaxNode parent, Syntax.InternalSyntax.SyntaxToken node, int position, int index)
{
Debug.Assert(parent == null || parent.Kind != SyntaxKind.List);
Debug.Assert(node != null || (position == 0 && index == 0 && parent == null));
Debug.Assert(position >= 0);
this.position = position;
this.parent = parent;
this.node = node;
this.index = index;
#if DEBUG
if (parent != null && node != null)
{
var nodeOrToken = ChildSyntaxList.ItemInternal(parent, index, fromTokenCtor: true);
Debug.Assert(nodeOrToken.UnderlyingNode == node, "node was not found at given index");
Debug.Assert(nodeOrToken.Position == position, "position mismatch");
}
else
{
Debug.Assert(parent == null || position >= parent.Position);
}
#endif
}
public override void DefaultVisit(SyntaxNode node)
{
var childCnt = node.ChildNodesAndTokens().Count;
int i = 0;
do
{
var child = ChildSyntaxList.ItemInternal((CSharpSyntaxNode)node, i);
i++;
var asNode = child.AsNode();
if (asNode != null)
{
if (this.Depth >= SyntaxWalkerDepth.Node)
{
this.Visit(asNode);
}
}
else
{
if (this.Depth >= SyntaxWalkerDepth.Token)
{
this.VisitToken(child.AsToken());
}
}
} while (i < childCnt);
}
private ISymbol TryGetAssignedSymbol(
SemanticDocument document, SymbolKind symbolKind,
ChildSyntaxList children, int index,
CancellationToken cancellationToken)
{
var syntaxFacts = document.Document.GetLanguageService <ISyntaxFactsService>();
if (index >= 0 && index < children.Count)
{
var sibling = children[index];
if (sibling.IsNode)
{
var siblingNode = sibling.AsNode();
if (syntaxFacts.IsSimpleAssignmentStatement(siblingNode))
{
syntaxFacts.GetPartsOfAssignmentStatement(
siblingNode, out var left, out var right);
var symbol = document.SemanticModel.GetSymbolInfo(left, cancellationToken).Symbol;
if (symbol?.Kind == symbolKind &&
symbol.ContainingType.Equals(this.ContainingType))
{
return(symbol);
}
}
}
}
return(null);
}
private static string GetAccessorsString(PropertyDeclarationSyntax prop)
{
ChildSyntaxList children = prop.ChildNodesAndTokens();
var accessorList = children.FirstOrDefault(n => n.Kind == SyntaxKind.AccessorList);
return(accessorList != null?accessorList.ToString() : string.Empty);
}
private void append(TreeViewItem _rootItem, SyntaxNode _node)
{
if (__treeView.Items.Count == 0)
{
__treeView.Items.Add(_rootItem);
}
ChildSyntaxList _children = _node.ChildNodesAndTokens();
ChildSyntaxList.Enumerator _enumerator = _children.GetEnumerator();
while (_enumerator.MoveNext())
{
SyntaxNodeOrToken _syntaxElement = _enumerator.Current;
if (_syntaxElement.IsNode)
{
SyntaxNode _childNode = _syntaxElement.AsNode();
TreeViewItem _childNodeItem = syntaxNodeItem(_childNode);
_rootItem.Items.Add(_childNodeItem);
append(_childNodeItem, _childNode);
}
else
if (_syntaxElement.IsToken)
{
SyntaxToken _token = _syntaxElement.AsToken();
_rootItem.Items.Add(syntaxTokenItem(_token));
}
}
}
/// <summary>
/// Try getting the first element in <paramref name="source"/>
/// </summary>
/// <param name="source">The source collection, can be null.</param>
/// <param name="result">The first element, can be null.</param>
/// <returns>True if an element was found.</returns>
internal static bool TryFirst(this ChildSyntaxList source, out SyntaxNodeOrToken result)
{
result = default(SyntaxNodeOrToken);
if (source.Count == 0)
{
return(false);
}
result = source[0];
return(true);
}
internal static bool TryGetAtIndex(this ChildSyntaxList source, int index, out SyntaxNodeOrToken result)
{
result = default(SyntaxNodeOrToken);
if (source.Count <= index)
{
return(false);
}
result = source[index];
return(true);
}
/// <summary>
/// Returns child node or token that contains given position.
/// </summary>
public override SyntaxNodeOrToken ChildThatContainsPosition(int position)
{
//PERF: it is very important to keep this method fast.
if (!FullSpan.Contains(position))
{
throw new ArgumentOutOfRangeException("position");
}
SyntaxNodeOrToken childNodeOrToken = ChildSyntaxList.ChildThatContainsPosition(this, position);
Debug.Assert(childNodeOrToken.FullSpan.Contains(position), "ChildThatContainsPosition's return value does not contain the requested position.");
return childNodeOrToken;
}
public static SyntaxNodeOrToken First(this ChildSyntaxList childSyntaxList, Func <SyntaxNodeOrToken, bool> predicate)
{
foreach (var syntaxNodeOrToken in childSyntaxList)
{
if (predicate(syntaxNodeOrToken))
{
return(syntaxNodeOrToken);
}
}
// Delegate to Enumerable.Last which will throw the exception.
return(Enumerable.First(childSyntaxList, predicate));
}
/// <summary>
/// Try getting the first element in <paramref name="source"/> matching <paramref name="predicate"/>
/// </summary>
/// <param name="source">The source collection, can be null.</param>
/// <param name="predicate">The predicate.</param>
/// <param name="result">The first element matching the predicate, can be null.</param>
/// <returns>True if an element was found.</returns>
internal static bool TryFirst(this ChildSyntaxList source, Func <SyntaxNodeOrToken, bool> predicate, out SyntaxNodeOrToken result)
{
result = default(SyntaxNodeOrToken);
foreach (var item in source)
{
if (predicate(item))
{
result = item;
return(true);
}
}
return(false);
}
internal static bool TryGetSingle(this ChildSyntaxList source, Func <SyntaxNodeOrToken, bool> selector, out SyntaxNodeOrToken result)
{
result = default(SyntaxNodeOrToken);
foreach (var item in source)
{
if (selector(item))
{
result = item;
return(true);
}
}
return(false);
}
internal static bool TryGetLast(this ChildSyntaxList source, Func <SyntaxNodeOrToken, bool> selector, out SyntaxNodeOrToken result)
{
result = default(SyntaxNodeOrToken);
for (var i = source.Count - 1; i >= 0; i--)
{
var item = source[i];
if (selector(item))
{
result = item;
return(true);
}
}
return(false);
}
void TraversideNodes(ChildSyntaxList nodes, List <SyntaxNodeOrToken> methods)
{
foreach (var node in nodes)
{
if (node.IsKind(SyntaxKind.IdentifierName) && node.ToString().Equals("Splice"))
{
methods.Add(node);
continue;
}
var child = node.ChildNodesAndTokens();
if (child.Any())
{
TraversideNodes(child, methods);
}
}
}
private int GetStatementIndex(ChildSyntaxList children, SyntaxNode statement)
{
var index = 0;
foreach (var child in children)
{
if (child == statement)
{
return(index);
}
index++;
}
throw ExceptionUtilities.Unreachable;
}
public static IEnumerable <ParamWithTokens> AggregateParamsWithTokens(this ChildSyntaxList childSyntaxList)
{
var array = childSyntaxList.ToArray();
for (int i = 0; i < array.Length; i++)
{
var elem = array[i];
if (elem.IsToken)
{
continue;
}
yield return(new ParamWithTokens
{
Parameter = (ParameterSyntax)elem,
TrailingToken = (SyntaxToken)array[i - 1],
LeadingToken = (SyntaxToken)array[i + 1]
});
}
}
/// <summary>
/// Try getting the single element in <paramref name="source"/> matching <paramref name="predicate"/>
/// </summary>
/// <param name="source">The source collection, can be null.</param>
/// <param name="predicate">The predicate.</param>
/// <param name="result">The single element matching the predicate, can be null.</param>
/// <returns>True if an element was found.</returns>
internal static bool TrySingle(this ChildSyntaxList source, Func <SyntaxNodeOrToken, bool> predicate, out SyntaxNodeOrToken result)
{
result = default(SyntaxNodeOrToken);
for (var i = 0; i < source.Count; i++)
{
var item = source[i];
if (predicate(item))
{
result = item;
for (var j = i + 1; j < source.Count; j++)
{
if (predicate(source[j]))
{
return(false);
}
}
return(true);
}
}
return(false);
}
/// <summary>
/// Returns child node or token that contains given position.
/// </summary>
public override SyntaxNodeOrToken ChildThatContainsPosition(int position)
{
//PERF: it is very important to keep this method fast.
// if there are ways to make it faster through some use of green nodes and such -
// it would be a welcome change.
var childList = this.ChildNodesAndTokens();
int left = 0;
int right = childList.Count - 1;
while (left <= right)
{
int middle = left + ((right - left) / 2);
SyntaxNodeOrToken node = ChildSyntaxList.ItemInternal(childList.Node, middle);
if (position < node.Position)
{
right = middle - 1;
}
else
{
if (position >= node.EndPosition)
{
left = middle + 1;
continue;
}
return(node);
}
}
// we could check up front that index is within FullSpan,
// but we want to optimize for the common case where position is valid.
Debug.Assert(!FullSpan.Contains(position), "Position is valid. How could we not find a child?");
throw new ArgumentOutOfRangeException("position");
}
static void TraverseTree(ChildSyntaxList child_nodes_tokens, XmlWriter writer, SemanticModel model)
{
level += 1;
//traverse every child node and token
for (int i = 0; i < child_nodes_tokens.Count(); i++)
{
// Console.WriteLine("Level: " + level);
//child is a node
if (child_nodes_tokens.ElementAt(i).IsNode)
{
//specifies the type of the node (e.g. VariableDeclarationSyntax)
//Console.WriteLine(child_nodes_tokens.ElementAt(i).AsNode().GetType().Name);
writer.WriteStartElement(child_nodes_tokens.ElementAt(i).AsNode().GetType().Name);
//writes the content of the node as an attribute
//Console.WriteLine(child_nodes_tokens.ElementAt(i).AsNode().ToFullString());
writer.WriteAttributeString("content", child_nodes_tokens.ElementAt(i).AsNode().ToFullString());
var type = child_nodes_tokens.ElementAt(i).AsNode();
if (type.GetType().Name == "NamespaceDeclarationSyntax" ||
type.GetType().Name == "ClassDeclarationSyntax" ||
type.GetType().Name == "InterfaceDeclarationSyntax" ||
type.GetType().Name == "EnumDeclarationSyntax" ||
type.GetType().Name == "DelegateDeclarationSyntax" ||
type.GetType().Name == "StructDeclarationSyntax" ||
type.GetType().Name == "MethodDeclarationSyntax")
{
var typeSymbol = model.GetDeclaredSymbol(type);
writer.WriteAttributeString("name", typeSymbol.Name);
var symbolDisplayFormat = new SymbolDisplayFormat(typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces);
writer.WriteAttributeString("fqn", typeSymbol.ToDisplayString(symbolDisplayFormat));
writer.WriteAttributeString("access", typeSymbol.DeclaredAccessibility.ToString());
writer.WriteAttributeString("abstract", typeSymbol.IsAbstract.ToString());
writer.WriteAttributeString("extern", typeSymbol.IsExtern.ToString());
writer.WriteAttributeString("override", typeSymbol.IsOverride.ToString());
writer.WriteAttributeString("sealed", typeSymbol.IsSealed.ToString());
writer.WriteAttributeString("static", typeSymbol.IsStatic.ToString());
writer.WriteAttributeString("virtual", typeSymbol.IsVirtual.ToString());
}
//if node has children, start TraverseTree again
if (child_nodes_tokens.ElementAt(i).ChildNodesAndTokens().Count > 0)
{
TraverseTree(child_nodes_tokens.ElementAt(i).ChildNodesAndTokens(), writer, model);
}
}
// child is a token
else
{
//specifies the type of the token (e.g. SyntaxToken)
//Console.WriteLine(child_nodes_tokens.ElementAt(i).AsToken().GetType().Name);
writer.WriteStartElement(child_nodes_tokens.ElementAt(i).AsToken().GetType().Name);
//writes the content of the token as an attribute
//Console.WriteLine(child_nodes_tokens.ElementAt(i).AsToken().ToFullString());
writer.WriteAttributeString("content", child_nodes_tokens.ElementAt(i).AsToken().ToFullString());
//if token has children, start TraverseTree again
if (child_nodes_tokens.ElementAt(i).ChildNodesAndTokens().Count > 0)
{
TraverseTree(child_nodes_tokens.ElementAt(i).ChildNodesAndTokens(), writer, model);
}
}
//closes the XML element (either the node or the token)
writer.WriteEndElement();
}
level -= 1;
}
public RazorSyntaxNodeList(ChildSyntaxList childSyntaxList)
{
_childSyntaxList = childSyntaxList;
}
/// <summary>
/// Generates the expression code
/// </summary>
/// <param name="node">The expression node</param>
public override void Generate(SyntaxNode node)
{
SyntaxKind kind = node.Kind();
switch (kind)
{
case SyntaxKind.ArrayCreationExpression:
m_context.Generators.ArrayCreationExpression.Generate(node as ArrayCreationExpressionSyntax);
break;
case SyntaxKind.PointerMemberAccessExpression:
m_context.Generators.PointerMemberAccessExpression.Generate(node as MemberAccessExpressionSyntax);
break;
case SyntaxKind.AddressOfExpression:
m_context.Generators.AddressOfExpression.Generate(node as PrefixUnaryExpressionSyntax);
break;
case SyntaxKind.ElementAccessExpression:
m_context.Generators.ElementAccess.Generate(node as ElementAccessExpressionSyntax);
break;
case SyntaxKind.SimpleMemberAccessExpression:
m_context.Generators.SimpleMemberAccess.Generate(node as ExpressionSyntax);
break;
case SyntaxKind.ObjectCreationExpression:
m_context.Generators.ObjectCreationExpression.Generate(node as ObjectCreationExpressionSyntax);
break;
case SyntaxKind.SimpleAssignmentExpression:
m_context.Generators.SimpleAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.InvocationExpression:
m_context.Generators.Invocation.Generate(node as InvocationExpressionSyntax);
break;
case SyntaxKind.LeftShiftAssignmentExpression:
m_context.Generators.LeftShiftAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.RightShiftAssignmentExpression:
m_context.Generators.RightShiftAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.OrAssignmentExpression:
m_context.Generators.BinaryOrAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.AndAssignmentExpression:
m_context.Generators.BinaryAndAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.ExclusiveOrAssignmentExpression:
m_context.Generators.ExclusiveOrAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.AddAssignmentExpression:
m_context.Generators.AddAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.SubtractAssignmentExpression:
m_context.Generators.SubstractAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.MultiplyAssignmentExpression:
m_context.Generators.MultiplyAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.DivideAssignmentExpression:
m_context.Generators.DivideAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.ModuloAssignmentExpression:
m_context.Generators.ModuloAssignment.Generate(node as AssignmentExpressionSyntax);
break;
case SyntaxKind.IdentifierName:
m_context.Generators.IdentifierName.Generate(node as IdentifierNameSyntax);
break;
case SyntaxKind.CastExpression:
m_context.Generators.CastExpression.Generate(node as CastExpressionSyntax);
break;
case SyntaxKind.SizeOfExpression:
m_context.Generators.SizeOfExpression.Generate(node as SizeOfExpressionSyntax);
break;
case SyntaxKind.PostDecrementExpression:
m_context.Generators.PostDecrementExpression.Generate(node as ExpressionSyntax);
break;
case SyntaxKind.PostIncrementExpression:
m_context.Generators.PostIncrementExpression.Generate(node as ExpressionSyntax);
break;
case SyntaxKind.PreDecrementExpression:
m_context.Generators.PreDecrementExpression.Generate(node as ExpressionSyntax);
break;
case SyntaxKind.PreIncrementExpression:
m_context.Generators.PreIncrementExpression.Generate(node as ExpressionSyntax);
break;
case SyntaxKind.ConditionalAccessExpression:
m_context.Generators.ConditionalAccessExpression.Generate(node as ConditionalAccessExpressionSyntax);
break;
case SyntaxKind.ThisExpression:
m_context.Writer.Append("obj");
break;
case SyntaxKind.TrueLiteralExpression:
m_context.Writer.Append("1");
break;
case SyntaxKind.FalseLiteralExpression:
m_context.Writer.Append("0");
break;
case SyntaxKind.NullLiteralExpression:
m_context.Writer.Append("NULL");
break;
case SyntaxKind.ArrayInitializerExpression:
m_context.Generators.ArrayInitializerExpression.Generate(node as InitializerExpressionSyntax);
break;
default:
if (IsSubExpression(kind) || IsLiteralExpression(kind))
{
ChildSyntaxList children = node.ChildNodesAndTokens();
foreach (SyntaxNodeOrToken child in children)
{
SyntaxKind childKind = child.Kind();
if (child.IsToken)
{
m_context.Writer.Append(child.ToString());
}
else
{
Generate(child.AsNode());
}
}
}
else
{
throw new NotImplementedException("Unknown SyntaxKind in Expression: " + node.Kind());
}
break;
}
}
public DifferenceInfo(ChildSyntaxList.Enumerator oldChildren, ChildSyntaxList.Enumerator newChildren)
{
this.oldChildren = oldChildren;
this.newChildren = newChildren;
}
