fn assign_modify()

in starlark/src/eval/fragment/stmt.rs [402:462]
61 lines of code
1 McCabe index (conditional complexity)

    fn assign_modify(
        &mut self,
        span_stmt: Span,
        lhs: CstAssign,
        rhs: IrSpanned<ExprCompiled>,
        op: AssignOp,
    ) -> StmtsCompiled {
        let span_stmt = FrozenFileSpan {
            span: span_stmt,
            file: self.codemap,
        };
        let span_lhs = FrozenFileSpan {
            span: lhs.span,
            file: self.codemap,
        };
        match lhs.node {
            AssignP::Dot(e, s) => {
                let e = self.expr(*e);
                StmtsCompiled::one(IrSpanned {
                    span: span_stmt,
                    node: StmtCompiled::AssignModify(AssignModifyLhs::Dot(e, s.node), op, rhs),
                })
            }
            AssignP::ArrayIndirection(box (e, idx)) => {
                let e = self.expr(e);
                let idx = self.expr(idx);
                StmtsCompiled::one(IrSpanned {
                    span: span_stmt,
                    node: StmtCompiled::AssignModify(AssignModifyLhs::Array(e, idx), op, rhs),
                })
            }
            AssignP::Identifier(ident) => {
                let (slot, captured) = self.scope_data.get_assign_ident_slot(&ident);
                match slot {
                    Slot::Local(slot) => {
                        let lhs = IrSpanned {
                            node: (slot, captured),
                            span: span_lhs,
                        };
                        StmtsCompiled::one(IrSpanned {
                            span: span_stmt,
                            node: StmtCompiled::AssignModify(AssignModifyLhs::Local(lhs), op, rhs),
                        })
                    }
                    Slot::Module(slot) => {
                        let lhs = IrSpanned {
                            node: slot,
                            span: span_lhs,
                        };
                        StmtsCompiled::one(IrSpanned {
                            span: span_stmt,
                            node: StmtCompiled::AssignModify(AssignModifyLhs::Module(lhs), op, rhs),
                        })
                    }
                }
            }
            AssignP::Tuple(_) => {
                unreachable!("Assign modify validates that the LHS is never a tuple")
            }
        }
    }