public void TraverseAllExpressionsInASyntaxTreeUsingAWalker()
{
var tree = SyntaxFactory.ParseSyntaxTree(@"
using System;
class Program
{
static void Main()
{
var i = 0.0;
i += 1 + 2L;
}
}");
var compilation = CSharpCompilation.Create("MyCompilation")
.AddReferences(Mscorlib)
.AddSyntaxTrees(tree);
var model = compilation.GetSemanticModel(tree);
var walker = new ExpressionWalker() { SemanticModel = model };
walker.Visit(tree.GetRoot());
Assert.Equal(@"
PredefinedTypeSyntax void has type void
IdentifierNameSyntax var has type double
LiteralExpressionSyntax 0.0 has type double
AssignmentExpressionSyntax i += 1 + 2L has type double
IdentifierNameSyntax i has type double
BinaryExpressionSyntax 1 + 2L has type long
LiteralExpressionSyntax 1 has type int
LiteralExpressionSyntax 2L has type long", walker.Results.ToString());
}
public static Expression Parse(ExpressionWalker ew, Expression left = null)
{
var ret = new IndexerCallExpression(left ?? IdentityExpression.Parse(ew), ArgumentsExpression.Parse(ew, ExpressionToken.LeftBracet, ExpressionToken.RightBracet, false));
return(InteractableExpression.TryExpand(ret, ew));
}
public static NewExpression Parse(ExpressionWalker ew)
{
ew.IsCurrentOrThrow(ExpressionToken.New);
ew.NextOrThrow();
return(new NewExpression(CallExpression.Parse(ew)));
}
public static ArrayExpression Parse(ExpressionWalker ew)
{
return(new ArrayExpression(ArgumentsExpression.Parse(ew, ExpressionToken.LeftBracet, ExpressionToken.RightBracet, true).Arguments));
}
public static Expression ParseExpression(ExpressionWalker ew, Type caller = null)
{
Expression ret = null;
_retry:
bool isOperatorCall = caller == typeof(OperatorExpression) || caller == typeof(RightOperatorExpression) || caller == typeof(ForeachExpression);
var current = ew.Current.Token;
if (current == ExpressionToken.Literal)
{
//cases like variable(.., variable[.., variable + .., variable
if (ew.HasNext)
{
var peak = ew.PeakNextOrThrow().Token;
if (peak == ExpressionToken.LeftParen)
{
ret = CallExpression.Parse(ew);
}
else if (peak == ExpressionToken.Period && caller != typeof(IdentityExpression) && caller != typeof(InteractableExpression))
{
ret = IdentityExpression.Parse(ew);
}
else if (peak == ExpressionToken.LeftBracet)
{
ret = IndexerCallExpression.Parse(ew);
}
else if (peak == ExpressionToken.New)
{
ret = NewExpression.Parse(ew);
}
else if (RightOperatorExpression.IsNextAnRightUniOperation(ew, caller) && caller != typeof(RightOperatorExpression))
{
ret = RightOperatorExpression.Parse(ew);
}
else if (OperatorExpression.IsNextAnOperation(ew) && !isOperatorCall)
{
ret = OperatorExpression.Parse(ew);
}
else
{
ret = IdentityExpression.Parse(ew, caller);
}
}
else
{
ret = IdentityExpression.Parse(ew, caller);
}
}
else if (LeftOperatorExpression.IsCurrentAnLeftUniOperation(ew))
{
ret = LeftOperatorExpression.Parse(ew);
}
else if (current == ExpressionToken.NumberLiteral)
{
ret = NumberLiteral.Parse(ew);
}
else if (current == ExpressionToken.StringLiteral)
{
ret = StringLiteral.Parse(ew);
}
else if (current == ExpressionToken.LeftParen)
{
ret = GroupExpression.Parse(ew, ExpressionToken.LeftParen, ExpressionToken.RightParen);
}
else if (current == ExpressionToken.LeftBracet)
{
ret = ArrayExpression.Parse(ew);
}
else if (current == ExpressionToken.New)
{
ret = NewExpression.Parse(ew);
}
else if (current == ExpressionToken.Boolean)
{
ret = BooleanLiteral.Parse(ew);
}
else if (current == ExpressionToken.CharLiteral)
{
ret = CharLiteral.Parse(ew);
}
else if (current == ExpressionToken.Throw)
{
ret = ThrowExpression.Parse(ew);
}
else if (current == ExpressionToken.Hashtag && ew.HasNext && ew.PeakNext.Token == ExpressionToken.NumberLiteral)
{
ret = HashtagReferenceExpression.Parse(ew, caller);
}
else if (current == ExpressionToken.Null)
{
ret = NullIdentity.Parse(ew);
}
else if (current == ExpressionToken.NewLine)
{
ew.NextOrThrow();
goto _retry;
}
else
{
throw new UnexpectedTokenException($"Token was not expected to be a {ew.Current.Token}");
}
//here we parse chained math operations
while (OperatorExpression.IsCurrentAnOperation(ew) && !isOperatorCall)
{
if (RightOperatorExpression.IsCurrentAnRightUniOperation(ew) && caller != typeof(OperatorExpression))
{
ret = RightOperatorExpression.Parse(ew, ret);
}
else if (OperatorExpression.IsCurrentAnOperation(ew))
{
ret = OperatorExpression.Parse(ew, ret);
}
}
return(ret);
}
public static Expression Parse(ExpressionWalker ew)
{
ew.IsCurrentOrThrow(ExpressionToken.Null);
ew.Next();
return(new IdentityExpression(Instance));
}