Method parse_declaration

crates/hll-to-ir/src/parser.rs:94–201

(&mut self)

            type_names: std::collections::HashSet::new(),
            enum_names: prelude_enum_names(),
            synthesized_declarations: Vec::new(),
            next_lambda_id: 0,
        }
    }

    pub fn parse_program(&mut self) -> Result<Program, ParserError> {
        let mut declarations = Vec::new();
        let mut statements = Vec::new();

        self.consume_terminators();
        while !self.is_eof() {
            if matches!(self.peek(), Some(Token::Impl)) {
                // `impl Type { ... }` desugars in place to flat `Type_method`
                // functions, so no later stage needs to know about methods.
                declarations.extend(self.parse_impl_block(false)?);
            } else if matches!(self.peek(), Some(Token::Export))
                && matches!(self.peek_n(1), Some(Token::Impl))
            {
                self.advance();
                declarations.extend(self.parse_impl_block(true)?);
            } else if self.is_declaration_start() {
                declarations.push(self.parse_declaration()?);
            } else {
                statements.push(self.parse_statement()?);
            }
            self.consume_terminators();
        }

        declarations.append(&mut self.synthesized_declarations);
        Ok(Program {
            declarations,
            statements,
        })
    }

    fn parse_declaration(&mut self) -> Result<Declaration, ParserError> {
        self.consume_terminators();

        // `export` marks the following declaration visible to importers. Record the
        // flag and parse the underlying declaration; it is otherwise unchanged.
        let exported = if matches!(self.peek(), Some(Token::Export)) {
            self.advance();
            self.consume_terminators();
            true
        } else {
            false
        };

        let decl = match self.peek() {
            Some(Token::Const) => {
                self.advance();
                let name = self.expect_ident()?;
                self.expect_assign()?;
                if matches!(self.peek(), Some(Token::Import)) {
                    let path = self.parse_import_call()?;
                    DeclNode::ModuleImport { alias: name, path }
                } else {
                    let init = self.parse_expression()?;