示例#1
0
文件: FAQ.cs 项目: Rickinio/roslyn
        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());
        }
示例#2
0
        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));
        }
示例#3
0
 public static NewExpression Parse(ExpressionWalker ew)
 {
     ew.IsCurrentOrThrow(ExpressionToken.New);
     ew.NextOrThrow();
     return(new NewExpression(CallExpression.Parse(ew)));
 }
示例#4
0
 public static ArrayExpression Parse(ExpressionWalker ew)
 {
     return(new ArrayExpression(ArgumentsExpression.Parse(ew, ExpressionToken.LeftBracet, ExpressionToken.RightBracet, true).Arguments));
 }
示例#5
0
        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);
        }
示例#6
0
 public static Expression Parse(ExpressionWalker ew)
 {
     ew.IsCurrentOrThrow(ExpressionToken.Null);
     ew.Next();
     return(new IdentityExpression(Instance));
 }