Method emit_parameter_hints

src/inlay_hints.rs:109–253

Emit parameter-name and by-reference hints for a single call site.

(
        &self,
        call_site: &CallSite,
        content: &str,
        range: Range,
        ctx: &FileContext,
        hints: &mut Vec<InlayHint>,
    )

    /// Emit parameter-name and by-reference hints for a single call site.
    fn emit_parameter_hints(
        &self,
        call_site: &CallSite,
        content: &str,
        range: Range,
        ctx: &FileContext,
        hints: &mut Vec<InlayHint>,
    ) {
        // Build a synthetic position from the call site's start so that
        // resolve_callable_target has a cursor context.
        let position = offset_to_position(content, call_site.args_start as usize);

        let resolved = match self.resolve_callable_target(
            &call_site.call_expression,
            content,
            position,
            ctx,
        ) {
            Some(r) => r,
            None => return,
        };

        let params = &resolved.parameters;
        if params.is_empty() {
            return;
        }

        let range_start = position_to_offset(content, range.start);
        let range_end = position_to_offset(content, range.end);

        // Build a set of parameter names consumed by named arguments so
        // positional arguments can be mapped to the remaining parameters.
        let named_consumed: std::collections::HashSet<&str> = call_site
            .named_arg_names
            .iter()
            .map(|n| n.as_str())
            .collect();

        // Parameters not consumed by named args, in declaration order.
        // Each positional argument is assigned to the next entry in this
        // list.  For variadic parameters the last entry is reused.
        let remaining_params: Vec<usize> = params
            .iter()
            .enumerate()
            .filter(|(_, p)| {
                let name = p.name.strip_prefix('$').unwrap_or(&p.name);
                !named_consumed.contains(name)
            })
            .map(|(i, _)| i)
            .collect();

        let mut positional_counter: usize = 0;

        for (arg_idx, &arg_offset) in call_site.arg_offsets.iter().enumerate() {
            // Skip arguments outside the viewport range.
            if arg_offset < range_start || arg_offset > range_end {
                continue;
            }