Method parse_atom

compiler/src/modules/parser/expr.rs:170–240

Atoms: literals, names, numbers, strings, f-strings, containers. */

(&mut self)

    /* Atoms: literals, names, numbers, strings, f-strings, containers. */
    pub(super) fn parse_atom(&mut self) {
        let errs_before = self.errors.len();
        let t = self.advance();
        match t.kind {
            TokenType::Name => self.name(t),
            TokenType::String => {
                let mut s = parse_string(self.lexeme(&t));
                while matches!(self.peek(), Some(TokenType::String)) {
                    let t = self.advance();
                    s.push_str(&parse_string(self.lexeme(&t)));
                }
                self.emit_const(Value::Str(s));
            }
            TokenType::Bytes => {
                // Adjacent bytes literals concat; mixing with str surfaces a diagnostic.
                let mut buf = parse_bytes_literal(self.lexeme(&t));
                while matches!(self.peek(), Some(TokenType::Bytes)) {
                    let t = self.advance();
                    buf.extend_from_slice(&parse_bytes_literal(self.lexeme(&t)));
                }
                self.emit_const(Value::Bytes(buf));
            }
            TokenType::Int | TokenType::Float => {
                self.parse_number(self.lexeme(&t), t.kind);
            }
            TokenType::True => self.chunk.emit(OpCode::LoadTrue, 0),
            TokenType::False => self.chunk.emit(OpCode::LoadFalse, 0),
            TokenType::None => self.chunk.emit(OpCode::LoadNone, 0),
            TokenType::Ellipsis => self.chunk.emit(OpCode::LoadEllipsis, 0),
            TokenType::FstringStart => self.fstring(t.start, t.end),
            TokenType::Lbrace => self.brace_literal(),
            TokenType::Lsqb => self.list_literal(),
            TokenType::Lpar => {
                if matches!(self.peek(), Some(TokenType::Rpar)) {
                    self.advance();
                    self.chunk.emit(OpCode::BuildTuple, 0);
                } else {
                    let elem_start = self.chunk.instructions.len();
                    self.expr();
                    if matches!(self.peek(), Some(TokenType::For)) {
                        let versions_before = self.ssa_versions.clone();
                        let elem_ins: Vec<Instruction> = self.chunk.instructions.drain(elem_start..).collect();
                        self.chunk.emit(OpCode::BuildList, 0);
                        self.comprehension_loop(&[(elem_start, elem_ins)], OpCode::ListAppend, &versions_before);
                        self.advance();
                    } else if self.eat_if(TokenType::Comma) {
                        let mut count = 1u16;
                        while !matches!(self.peek(), Some(TokenType::Rpar) | None) {
                            self.expr();
                            count += 1;
                            if !self.eat_if(TokenType::Comma) { break; }
                        }
                        self.eat(TokenType::Rpar);
                        self.chunk.emit(OpCode::BuildTuple, count);
                    } else {
                        self.eat(TokenType::Rpar);
                    }
                }