Method name_stmt

compiler/src/modules/parser/stmt.rs:366–556

Name-led statement: assign, augmented-op, attr, index, call, or tuple unpack. */

(&mut self, t: Token)

    /* Name-led statement: assign, augmented-op, attr, index, call, or tuple unpack. */
    pub(super) fn name_stmt(&mut self, t: Token) -> bool {
        let name = self.lexeme(&t).to_string();

    if self.eat_if(TokenType::Colon) && !self.skip_annotation() {
        return false;
    }

        match self.peek() {
            Some(TokenType::Equal) => {
                self.assign(name);
                false
            }
            Some(t) if Self::augmented_op(&t).is_some() => {
                let op = Self::augmented_op(&t).unwrap();
                self.advance();
                self.emit_load_ssa(name.clone());
                self.expr();
                // In-place variants so list `+=` and set `|=`/`&=`/`^=` mutate the shared object (alias-visible).
                let op = match op {
                    OpCode::Add => OpCode::InPlaceAdd,
                    OpCode::BitOr => OpCode::InPlaceBitOr,
                    OpCode::BitAnd => OpCode::InPlaceBitAnd,
                    OpCode::BitXor => OpCode::InPlaceBitXor,
                    other => other,
                };
                self.chunk.emit(op, 0);
                self.store_name(name);
                false
            }
            Some(TokenType::Lsqb) => {
                self.emit_load_ssa(name);
                self.advance();
                // Slice form: BuildSlice+StoreItem; runtime recognises HeapObj::Slice as splice index.
                if self.parse_subscript() {
                    if matches!(self.peek(), Some(TokenType::Equal)) {
                        self.advance();
                        self.expr();
                        self.chunk.emit(OpCode::StoreItem, 0);
                        return false;
                    }
                    self.chunk.emit(OpCode::GetItem, 0);
                    self.expr_tails();
                    return true;
                }
                if matches!(self.peek(), Some(TokenType::Equal)) {
                    self.advance();
                    self.expr();
                    self.chunk.emit(OpCode::StoreItem, 0);
                    false
                } else if let Some(op) = self.peek().and_then(|t| Self::augmented_op(&t)) {
                    self.emit_augmented_subscript(op);
                    false
                } else {
                    self.chunk.emit(OpCode::GetItem, 0);
                    self.expr_tails();
                    true
                }
            }