feat: always show constructor inlay hints, add option to disable #10761
Conversation
There was a problem hiding this comment.
Great, wanted to do this as well but I somehow forgot about this, as I also prefer always showing the hints.
Not sure about whether we want to go with show or hide as the name. show would fit with the rest of things as usually we go for *enable, but at the same time this is a specific thing that removes from the general inlayhints feature so I think hide does fit here.
What I would change though is that the default value should show named constructors, as it probably would be rather confusing for newcomers, wondering why some inlay hints are missing.
|
I'm totally cool with changing the default to always show inlay hints. I think it is confusing if inlay hints sometimes show and do not show. But I also didn't want to essentially erase the functionality in 10441 by making it the non-default (most people don't really change config.) But if you agree that always showing inlay hints is a more sensible default (and I concur with this), I'll flip the default. |
|
While we do want to make everthing as much as discoverable we should still keep sensible defaults in mind imo, and this one is one of them. I feel like people would not easily realize that a type hint is missing because of a constructor(in fact even though I implemented that feature I at times wondered why the type hint was missing for a moment), I personally think this feature is more confusing than helpful as well, though I can see why someone would maybe want it. |
|
Done! |
|
Thanks! bors r+ |
lnicola
changed the title
feat: hide type inlay hints for initializations of closures  This PR adds an option to hide the inlay hints for `let IDENT_PAT = CLOSURE_EXPR;`, which is a somewhat common coding pattern. Currently the inlay hints for the assigned variable and the closure expression itself are both displayed, making it rather repetitive. In order to be consistent with closure return type hints, only closures with block bodies will be hid by this option. Personally I'd feel comfortable making it always enabled (or at least when closure return type hints are enabled), but considering the precedent set in #10761, I introduced an off-by-default option for this. changelog feature: option to hide type inlay hints for initializations of closures
perf: improve write_fmt to handle simple strings In case format string has no arguments, simplify its implementation with a direct call to `output.write_str(value)`. This builds on `@dtolnay` original [suggestion](serde-rs/serde#2697 (comment)). This does not change any expectations because the original `fn write()` implementation calls `write_str` for parts of the format string. ```rust write!(f, "text") -> f.write_str("text") ``` ```diff /// [`write!`]: crate::write! +#[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result { + if let Some(s) = args.as_str() { output.write_str(s) } else { write_internal(output, args) } +} + +/// Actual implementation of the [`write`], but without the simple string optimization. +fn write_internal(output: &mut dyn Write, args: Arguments<'_>) -> Result { let mut formatter = Formatter::new(output); let mut idx = 0; ``` * Hopefully it will improve the simple case for the rust-lang/rust#99012 * Another related (original?) issues rust-lang#10761 * Previous similar attempt to fix it by by `@Kobzol` #100700 CC: `@m-ou-se` as probably the biggest expert in everything `format!`
perf: improve write_fmt to handle simple strings In case format string has no arguments, simplify its implementation with a direct call to `output.write_str(value)`. This builds on `@dtolnay` original [suggestion](serde-rs/serde#2697 (comment)). This does not change any expectations because the original `fn write()` implementation calls `write_str` for parts of the format string. ```rust write!(f, "text") -> f.write_str("text") ``` ```diff /// [`write!`]: crate::write! +#[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result { + if let Some(s) = args.as_str() { output.write_str(s) } else { write_internal(output, args) } +} + +/// Actual implementation of the [`write`], but without the simple string optimization. +fn write_internal(output: &mut dyn Write, args: Arguments<'_>) -> Result { let mut formatter = Formatter::new(output); let mut idx = 0; ``` * Hopefully it will improve the simple case for the rust-lang/rust#99012 * Another related (original?) issues rust-lang#10761 * Previous similar attempt to fix it by by `@Kobzol` #100700 CC: `@m-ou-se` as probably the biggest expert in everything `format!`
This PR adds a config to disable the functionality in #10441 - and makes that functionality disabled by default.
I actually really like inlay hints always showing up, and it helps a lot as a teaching tool too, and also it's quite reassuring to know that r-a indeed understands the code I've written. This PR adds the option
rust-analyzer.inlayHints.hideNamedConstructorHints(i can also invert this to berust-analyzer.inlayHints.showNamedConstructorHints, just let me know.)