Method parse_statement

crates/hll-to-ir/src/parser.rs:217–283

(&mut self)

                    if self.peek_n(2) == Some(&Token::Import) {
                        let alias = self.expect_ident()?;
                        self.expect_colon_equal()?;
                        let path = self.parse_import_call()?;
                        DeclNode::ModuleImport { alias, path }
                    } else {
                        self.parse_inferred_variable_decl()?
                    }
                } else if self.peek_n(1) == Some(&Token::Colon)
                    && (self.peek_n(2) == Some(&Token::LParen)
                        || self.peek_n(2) == Some(&Token::Lt))
                {
                    self.parse_function_decl(false, false)?
                } else {
                    self.parse_variable_decl()?
                }
            }
            Some(tok) => {
                return Err(self.error_with_token("unexpected token at declaration start", tok));
            }
            None => return Err(self.error("unexpected end of input")),
        };

        if let DeclNode::Type { name, .. }
        | DeclNode::Struct { name, .. }
        | DeclNode::Enum { name, .. } = &decl
        {
            self.type_names.insert(name.clone());
        }
        if let DeclNode::Enum { name, .. } = &decl {
            self.enum_names.insert(name.clone());
        }
        Ok(Declaration { decl, exported })
    }

    fn parse_block(&mut self) -> Result<Block, ParserError> {
        self.expect_lbrace()?;
        let mut statements = Vec::new();
        let mut stmt_lines = Vec::new();

        self.consume_terminators();
        while !self.check_rbrace() {
            let line = self.current_line();
            statements.push(self.parse_statement()?);
            stmt_lines.push(line);
            self.consume_terminators();
        }

        self.expect_rbrace()?;
        Ok(Block {
            statements,
            stmt_lines,
        })
    }

    // 1-based source line of the current token (0 if unavailable, e.g. tests).
    fn current_line(&self) -> u32 {
        self.spans.get(self.pos).map(|s| s.line).unwrap_or(0)
    }