Parameter Size Display Bug

[TheoAC]

I've found what I understand to be a minor bug in how rust-analyzer displays size information for variables. In a generic function, parameters of type &T are assumed to be one word in size, even with the type bound T: ?Sized. But if T happens to be a dynamically sized type, then a parameter of type &T will be a wide pointer, which is two words in size. In this case, we have an inconsistency:

// parameter `_x` has `size = 8, align = 0x8`
fn foo<T: ?Sized>(_x: &T) {}

fn main() {
    // variable `x` has `size = 16 (0x10), align = 0x8`
    let x = "";
    foo(x);
}

The comments in the code above refer to what rust-analyzer displays when hovering the mouse over the declaration of the parameter/variable. The issue here is that the display for _x as a parameter of foo is not necessarily correct.

rust-analyzer version:
0.3.2362-standalone (fb133c8 2025-03-29)

rustc version:
rustc 1.85.0 (4d91de4e4 2025-02-17)

editor:
VSCode, Version 1.98.2

This is my first time contributing to a public project, so I especially appreciate any input for improving this report.

To whom it may concern, I thank you for your time. Hugs and kisses.

[ChayimFriedman2]

I'm not sure how we could fix that. If we e.g. try to show "either 8 or 16 bytes", this will become a lot more complicated when there are multiple parameters combined in a struct.

[TheoAC]

I don't know what expectations you all have of rust-analyzer's memory layout hover. (Any recommendations on where I could find this?) However, my personal impulse would be to not make any claims about the size of a &T at all, unless we already know that T: Sized. After all, if I were to write

fn foo<T>(t: T) { /* ... */ }

then the analyzer doesn't show any information about the size of t as a parameter for id, since it just doesn't have any.
So, along those lines, is it acceptable to just give up on finding/displaying a size for a &T when T: ?Sized?

This would mean that you only get to see the size of a parameterized struct containing reference types once you know the type behind each reference (or if you know that each is Sized). I don't think that that's a problem; it's already the case when generic types are used for fields directly (how big is struct Thing<T>(T);?).

All said, I would be interested to know: When do we expect rust-analyzer to provide memory layout information, and what do we expect it to tell us?