Method parse_enum_decl

crates/hll-to-ir/src/parser.rs:399–444

(&mut self)

        let init = if self.match_assign() {
            Some(self.parse_expression()?)
        } else {
            return Err(self
                .error("explicit declarations require an initializer: `name: Type = expression`"));
        };

        Ok(DeclNode::Variable {
            name,
            ty,
            init,
            is_extern: false,
        })
    }

    fn parse_inferred_variable_decl(&mut self) -> Result<DeclNode, ParserError> {
        let name = self.expect_ident()?;
        self.expect_colon_equal()?;
        let init = self.parse_expression()?;
        Ok(DeclNode::InferredVariable { name, init })
    }

    // Consume `import ( string )` and return the path literal, with `import` next.
    // Used by the `alias := import(...)` and `const alias = import(...)` module forms.
    fn parse_import_call(&mut self) -> Result<String, ParserError> {
        self.advance(); // `import`
        self.expect_lparen()?;
        let path = self.expect_string_literal()?;
        self.expect_rparen()?;
        Ok(path)
    }

    fn parse_struct_decl(&mut self) -> Result<DeclNode, ParserError> {
        let name = self.expect_ident()?;
        let (generics, bounds) = self.parse_generic_params_with_bounds()?;
        self.expect_lbrace()?;
        let mut fields = Vec::new();
        self.consume_terminators();

        while !self.check_rbrace() {
            let field_name = self.expect_ident()?;
            self.expect_colon()?;
            let ty = self.parse_type()?;
            fields.push(FieldDecl {
                name: field_name,
                ty,
                init: None,
            });

            let newline_separated = matches!(self.peek(), Some(Token::StatementTerminator));
            self.consume_terminators();