Method parse_generic_params

crates/hll-to-ir/src/parser.rs:1370–1407

(&mut self)

                let (fields, rest) = self.parse_struct_literal_fields()?;
                expr = Expression::Primary(PrimaryExpr::NamedStructLiteral {
                    name,
                    type_args,
                    fields,
                    rest,
                });
                continue;
            }

            let type_arguments = self.try_parse_call_type_arguments();

            if type_arguments.is_some() || self.match_lparen() {
                // A non-identifier callee (field access, index, deref) is an
                // indirect call through a function-pointer value.
                let name = match expr {
                    Expression::Primary(PrimaryExpr::Identifier(name)) => name,
                    Expression::Primary(PrimaryExpr::FieldAccess { expr: base, field }) if matches!(base.as_ref(), Expression::Primary(PrimaryExpr::Identifier(name)) if self.type_names.contains(name)) =>
                    {
                        if type_arguments.is_some() {
                            return Err(self.error(
                                "type arguments on associated function calls are not supported",
                            ));
                        }
                        let Expression::Primary(PrimaryExpr::Identifier(type_name)) = *base else {
                            unreachable!();
                        };
                        let arguments = self.parse_argument_list_after_open_paren()?;
                        expr = Expression::Primary(PrimaryExpr::FunctionCall {
                            name: format!("{type_name}_{field}"),
                            type_arguments: Vec::new(),
                            arguments,
                        });
                        continue;
                    }
                    // `alias.member<T>(...)`: a qualified generic call. The dotted name
                    // resolves against the module alias table before monomorphization.
                    Expression::Primary(PrimaryExpr::FieldAccess { expr: base, field })
                        if type_arguments.is_some()
                            && matches!(
                                base.as_ref(),
                                Expression::Primary(PrimaryExpr::Identifier(_))
                            ) =>