Method parse_interface_decl

scribe-parser/src/parser/declarations.rs:289–357

Parse an interface declaration (like Rust trait) ```ignore interface Drawable { fn draw(&this); } sealed interface SealedTrait permits A, B, C { fn method(&this); } ```

(
        &mut self,
        visibility: Visibility,
        is_sealed: bool,
    )

    /// }
    /// ```
    pub fn parse_interface_decl(
        &mut self,
        visibility: Visibility,
        is_sealed: bool,
    ) -> Result<Stmt<'a, 'bump>, DiagnosticError<'a>> {
        let token = self.cursor.expect(TokenKind::Interface)?;

        let (name, _span) = self.cursor.expect_ident()?;

        // Parse optional generics: <T, U: Display>
        let generics = if self.cursor.peek() == TokenKind::Lt {
            self.parse_generics()?
        } else {
            None
        };

        // Parse optional permits clause for sealed interfaces
        let permits = if self.cursor.peek() == TokenKind::Permits {
            Some(self.parse_permits_expr()?)
        } else {
            None
        };

        self.cursor.expect(TokenKind::LBrace)?;

        let mut methods = Vec::new();

        while self.cursor.peek() != TokenKind::RBrace && self.cursor.peek() != TokenKind::EOF {
            let method_vis = if self.cursor.peek() == TokenKind::Private
                || self.cursor.peek() == TokenKind::Module
                || self.cursor.peek() == TokenKind::Package
            {
                let vis = token_to_visibility(self.cursor.peek());
                self.cursor.advance();
                vis
            } else {
                Visibility::Public
            };

            if matches!(
                self.cursor.peek(),
                TokenKind::Func
                    | TokenKind::Unsafe
                    | TokenKind::Inline
                    | TokenKind::Noinline
                    | TokenKind::Extern
            ) {
                let func = self.parse_function_signature(method_vis)?;
                methods.push(func);
            } else {
                // Interface can also have associated types, consts, etc.
                // For now, just skip unknown tokens
                self.cursor.advance();
            }
        }

        self.cursor.expect(TokenKind::RBrace)?;