Method compile_store

crates/codegen/src/compile.rs:7169–7236

(&mut self, target: &ast::Expr)

    }

    fn compile_store(&mut self, target: &ast::Expr) -> CompileResult<()> {
        match &target {
            ast::Expr::Name(ast::ExprName { id, .. }) => self.store_name(id.as_str())?,
            ast::Expr::Subscript(ast::ExprSubscript {
                value, slice, ctx, ..
            }) => {
                self.compile_subscript(value, slice, *ctx)?;
            }
            ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                self.compile_expression(value)?;
                let namei = self.name(attr.as_str());
                emit!(self, Instruction::StoreAttr { namei });
            }
            ast::Expr::List(ast::ExprList { elts, .. })
            | ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
                let mut seen_star = false;

                // Scan for star args:
                for (i, element) in elts.iter().enumerate() {
                    if let ast::Expr::Starred(_) = &element {
                        if seen_star {
                            return Err(self.error(CodegenErrorType::MultipleStarArgs));
                        } else {
                            seen_star = true;
                            let before = i;
                            let after = elts.len() - i - 1;
                            let (before, after) = (|| Some((before.to_u8()?, after.to_u8()?)))()
                                .ok_or_else(|| {
                                    self.error_ranged(
                                        CodegenErrorType::TooManyStarUnpack,
                                        target.range(),
                                    )
                                })?;
                            let counts = bytecode::UnpackExArgs { before, after };
                            emit!(self, Instruction::UnpackEx { counts });
                        }
                    }
                }

                if !seen_star {
                    emit!(
                        self,
                        Instruction::UnpackSequence {
                            count: elts.len().to_u32(),
                        }
                    );
                }

                for element in elts {
                    if let ast::Expr::Starred(ast::ExprStarred { value, .. }) = &element {
                        self.compile_store(value)?;
                    } else {
                        self.compile_store(element)?;
                    }
                }
            }
            _ => {
                return Err(self.error(match target {