示例#1
0
 public void SetValues(TextSpan span, bool stopOnFirstAwaitExpression = false)
 {
     _shouldStop = false;
     Span        = span;
     StopOnFirstAwaitExpression = stopOnFirstAwaitExpression;
     AwaitExpressions.Clear();
 }
示例#2
0
        public override void VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression)
        {
            if (Emitter != null && binaryOperatorExpression.GetParent <SyntaxTree>() != null)
            {
                if (Emitter.Resolver.ResolveNode(binaryOperatorExpression) is OperatorResolveResult rr && rr.Type.IsKnownType(KnownTypeCode.Boolean))
                {
                    var count = AwaitExpressions.Count;
                    var idx   = InsertPosition;

                    base.VisitBinaryOperatorExpression(binaryOperatorExpression);

                    if (AwaitExpressions.Count > count && (
                            binaryOperatorExpression.Operator == BinaryOperatorType.BitwiseAnd ||
                            binaryOperatorExpression.Operator == BinaryOperatorType.BitwiseOr ||
                            binaryOperatorExpression.Operator == BinaryOperatorType.ConditionalOr ||
                            binaryOperatorExpression.Operator == BinaryOperatorType.ConditionalAnd))
                    {
                        AwaitExpressions.Insert(idx > -1 ? idx : 0, binaryOperatorExpression);
                    }

                    return;
                }
            }

            base.VisitBinaryOperatorExpression(binaryOperatorExpression);
        }
示例#3
0
 private void Add(AstNode node)
 {
     if (InsertPosition >= 0)
     {
         AwaitExpressions.Insert(InsertPosition++, node);
     }
     else
     {
         AwaitExpressions.Add(node);
     }
 }
示例#4
0
        public override void VisitConditionalExpression(ConditionalExpression conditionalExpression)
        {
            var count = AwaitExpressions.Count;
            var idx   = InsertPosition;

            base.VisitConditionalExpression(conditionalExpression);

            if (AwaitExpressions.Count > count)
            {
                AwaitExpressions.Insert(idx > -1 ? idx : 0, conditionalExpression);
            }
        }
        public override void VisitAwaitExpression(AwaitExpressionSyntax node)
        {
            ShouldStop = true;

            if (StopOnFirstAwaitExpression)
            {
                Debug.Assert(AwaitExpressions.Count == 0);

                AwaitExpressions.Add(node);
            }
            else
            {
                AwaitExpressions.Clear();
            }
        }
        public override void VisitReturnStatement(ReturnStatementSyntax node)
        {
            Debug.Assert(!StopOnFirstAwaitExpression);

            if (node.Expression is AwaitExpressionSyntax awaitExpression)
            {
                Visit(awaitExpression.Expression);

                if (!ShouldStop)
                {
                    AwaitExpressions.Add(awaitExpression);
                }
            }
            else
            {
                ShouldStop = true;
                AwaitExpressions.Clear();
            }
        }
 public void Reset()
 {
     ShouldStop = false;
     StopOnFirstAwaitExpression = false;
     AwaitExpressions.Clear();
 }
 public void Reset()
 {
     _shouldVisit = true;
     StopOnFirstAwaitExpression = false;
     AwaitExpressions.Clear();
 }