Method parse_impl_block

crates/hll-to-ir/src/parser.rs:488–540

Parse `impl Type { method: (self: Type*, ...) -> R { ... } }`; each method desugars to a free function `Type_method` (static dispatch, explicit self).

(&mut self)

                }
                self.expect_rparen()?;
            }
            variants.push(Variant {
                name: variant_name,
                payload,
            });

            let newline_separated = matches!(self.peek(), Some(Token::StatementTerminator));
            self.consume_terminators();
            if self.match_comma() {
                self.consume_terminators();
            } else if !newline_separated && !self.check_rbrace() {
                return Err(self.error("expected `,` or newline between enum variants"));
            }
        }

        self.expect_rbrace()?;
        Ok(DeclNode::Enum {
            name,
            generics,
            bounds,
            variants,
        })
    }

    fn parse_function_decl(
        &mut self,
        is_extern: bool,
        is_import_interface: bool,
    ) -> Result<DeclNode, ParserError> {
        let name = self.expect_ident()?;
        self.expect_colon()?;

        let (generics, bounds) = self.parse_generic_params_with_bounds()?;

        let params = self.parse_param_list()?;

        let return_type = if self.match_arrow() {
            if self.peek() == Some(&Token::LParen) && self.peek_n(1) == Some(&Token::RParen) {
                return Err(self.error("void functions omit `->`; `-> ()` is not valid"));
            }
            Some(self.parse_return_type()?)
        } else {
            None
        };

        let body = if is_extern {
            None
        } else if self.check_lbrace() {
            Some(self.parse_block()?)
        } else {
            return Err(self.error("expected function body block"));
        };

        Ok(DeclNode::Function {
            name,
            generics,