Method _parseExpressionStatement

server/src/parser/parser.ts:2094–2140

()

    // augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' |
    //             '<<=' | '>>=' | '**=' | '//=')
    private _parseExpressionStatement(): ExpressionNode {
        let leftExpr = this._parseTestOrStarListAsExpression();
        let annotationExpr: TypeAnnotationExpression | undefined;

        if (leftExpr instanceof ErrorExpressionNode) {
            return leftExpr;
        }

        // Is this a type annotation assignment?
        if (this._consumeTokenIfType(TokenType.Colon)) {
            annotationExpr = this._parseTypeAnnotation(this._parseTestExpression());
            leftExpr = new TypeAnnotationExpressionNode(leftExpr, annotationExpr);

            if (!this._consumeTokenIfOperator(OperatorType.Assign)) {
                return leftExpr;
            }

            if (!this._parseOptions.isStubFile && this._getLanguageVersion() < PythonVersion.V36) {
                this._addError('Type annotations for variables requires Python 3.6 or newer',
                    annotationExpr.rawExpression);
            }

            let rightExpr = this._parseTestExpression();
            return new AssignmentNode(leftExpr, rightExpr);
        }

        // Is this a simple assignment?
        if (this._consumeTokenIfOperator(OperatorType.Assign)) {
            return this._parseChainAssignments(leftExpr);
        }

        if (!annotationExpr && Tokenizer.isOperatorAssignment(this._peekOperatorType())) {
            let operatorToken = this._getNextToken() as OperatorToken;

            // Is the left side of the assignment assignable?
            const assignError = leftExpr.getAssignmentError();
            if (assignError) {
                this._addError(assignError, leftExpr);
            }

            let rightExpr = this._tryParseYieldExpression() ||
                this._parseTestListAsExpression('Expected expression to the right of operator');
            return new AugmentedAssignemtnExpressionNode(leftExpr, rightExpr, operatorToken.operatorType);
        }

        return leftExpr;
    }

    private _parseChainAssignments(leftExpr: ExpressionNode): ExpressionNode {
        // Is the left side of the assignment assignable?