public override bool Walk(ExpressionStatement node) { if (node.Expression is TupleExpression) { node.Expression.Walk(this); CommitByDefault = false; return false; } return base.Walk(node); }
// expr_stmt: expression_list // expression_list: expression ( "," expression )* [","] // assignment_stmt: (target_list "=")+ (expression_list | yield_expression) // augmented_assignment_stmt ::= target augop (expression_list | yield_expression) // augop: '+=' | '-=' | '*=' | '/=' | '%=' | '**=' | '>>=' | '<<=' | '&=' | '^=' | '|=' | '//=' private Statement ParseExprStmt() { Expression ret = ParseTestListAsExpr(); if (PeekToken(TokenKind.Assign)) { if (_langVersion >= PythonLanguageVersion.V30) { SequenceExpression seq = ret as SequenceExpression; bool hasStar = false; if (seq != null) { for (int i = 0; i < seq.Items.Count; i++) { if (seq.Items[i] is StarredExpression) { if (hasStar) { ReportSyntaxError(seq.Items[i].StartIndex, seq.Items[i].EndIndex, "two starred expressions in assignment"); } hasStar = true; } } } } return FinishAssignments(ret); } else { PythonOperator op = GetAssignOperator(PeekToken()); if (op != PythonOperator.None) { NextToken(); string whiteSpace = _tokenWhiteSpace; Expression rhs; if (_langVersion >= PythonLanguageVersion.V25 && PeekToken(TokenKind.KeywordYield)) { if (!AllowYieldSyntax && AllowAsyncAwaitSyntax) { ReportSyntaxError("'yield' inside async function"); } Eat(TokenKind.KeywordYield); rhs = ParseYieldExpression(); } else { rhs = ParseTestListAsExpr(); } string assignError = ret.CheckAugmentedAssign(); if (assignError != null) { ReportSyntaxError(ret.StartIndex, ret.EndIndex, assignError); } AugmentedAssignStatement aug = new AugmentedAssignStatement(op, ret, rhs); if (_verbatim) { AddPreceedingWhiteSpace(aug, whiteSpace); } aug.SetLoc(ret.StartIndex, GetEnd()); return aug; } else { Statement stmt = new ExpressionStatement(ret); stmt.SetLoc(ret.IndexSpan); return stmt; } } }
public override bool Walk(ExpressionStatement node) { if (node.Expression is TupleExpression) { node.Expression.Walk(this); CommitByDefault = false; return false; } else if (node.Expression is ConstantExpression) { node.Expression.Walk(this); return false; } else if (node.Expression is ErrorExpression) { // Might be an unfinished string literal, which we care about node.Expression.Walk(this); return false; } CanComplete = true; CommitByDefault = false; return base.Walk(node); }
private Expression ParseLambdaHelperEnd(FunctionDefinition func, Expression expr, string whitespace, string colonWhiteSpace, List<string> commaWhiteSpace, bool ateTerminator) { // Pep 342 in Python 2.5 allows Yield Expressions, which can occur inside a Lambda body. // In this case, the lambda is a generator and will yield it's final result instead of just return it. Statement body; if (func.IsGenerator) { YieldExpression y = new YieldExpression(expr); y.SetLoc(expr.IndexSpan); body = new ExpressionStatement(y); } else { body = new ReturnStatement(expr); } body.SetLoc(expr.StartIndex, expr.EndIndex); FunctionDefinition func2 = PopFunction(); System.Diagnostics.Debug.Assert(func == func2); func.SetBody(body); func.EndIndex = GetEnd(); LambdaExpression ret = new LambdaExpression(func); func.SetLoc(func.IndexSpan); ret.SetLoc(func.IndexSpan); if (_verbatim) { AddPreceedingWhiteSpace(ret, whitespace); AddSecondPreceedingWhiteSpace(ret, colonWhiteSpace); AddListWhiteSpace(ret, commaWhiteSpace.ToArray()); if (!ateTerminator) { AddErrorIsIncompleteNode(ret); } } return ret; }
private Statement ParseYieldStmt() { // For yield statements, continue to enforce that it's currently in a function. // This gives us better syntax error reporting for yield-statements than for yield-expressions. if (!AllowYieldSyntax) { if (AllowAsyncAwaitSyntax) { ReportSyntaxError("'yield' inside async function"); } else { ReportSyntaxError("misplaced yield"); } } _isGenerator = true; if (_returnsWithValue != null && _langVersion < PythonLanguageVersion.V33) { foreach (var span in _returnsWithValue) { ReportSyntaxError(span.Start, span.End, "'return' with argument inside generator"); } } Eat(TokenKind.KeywordYield); // See Pep 342: a yield statement is now just an expression statement around a yield expression. Expression e = ParseYieldExpression(); Debug.Assert(e != null); // caller already verified we have a yield. Statement s = new ExpressionStatement(e); s.SetLoc(e.IndexSpan); return s; }
private static bool IsDocString(ExpressionStatement exprStmt) { ConstantExpression constExpr; return exprStmt != null && (constExpr = exprStmt.Expression as ConstantExpression) != null && (constExpr.Value is string || constExpr.Value is AsciiString); }
public override bool Walk(ExpressionStatement node) { UpdateLineInfo(node); return base.Walk(node); }
public override bool Walk(ExpressionStatement node) { UpdateChildRanges(node); return base.Walk(node); }
public override void PostWalk(ExpressionStatement node) { PostWalkWorker(node); }
// ExpressionStatement public override bool Walk(ExpressionStatement node) { return ShouldWalkWorker(node); }