Method parse_primary

crates/hll-to-ir/src/parser.rs:1800–1959

(&mut self)

            return Ok((Vec::new(), Vec::new()));
        }

        let mut params = Vec::new();
        let mut bounds = Vec::new();

        // Check for closing bracket
        let should_close = self.check_gt_or_shr();

        if !should_close {
            loop {
                let param = self.expect_ident()?;
                if params.contains(&param) {
                    return Err(self.error(&format!("duplicate generic parameter `{param}`")));
                }
                if matches!(self.peek(), Some(Token::Colon)) {
                    self.advance();
                    let mut seen = std::collections::HashSet::new();
                    loop {
                        let mut segments = vec![self.expect_ident()?];
                        while self.match_dot() {
                            segments.push(self.expect_ident()?);
                        }
                        let interface = Path::from_segments(segments);
                        if !seen.insert(interface.clone()) {
                            return Err(
                                self.error(&format!("duplicate bound `{param}: {interface}`"))
                            );
                        }
                        bounds.push((param.clone(), interface));
                        if !self.match_plus() {
                            break;
                        }
                    }
                }
                params.push(param);
                if self.match_comma() {
                    if self.check_gt_or_shr() {
                        break;
                    }
                    continue;
                }
                break;
            }
        }

        // Consume the closing bracket
        if self.pending_gt_from_shr {
            // Virtual > available from previous Shr split
            self.pending_gt_from_shr = false;
        } else if self.match_gt() {
            // plain >
        } else if matches!(self.peek(), Some(Token::Shr | Token::Gte)) {
            self.advance();
            self.pending_gt_from_shr = true;
        } else {
            return Err(self.error("expected `>` to close generic parameters"));
        }

        Ok((params, bounds))