Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit d00de38

Browse files
borsbors
committed
Auto merge of rust-lang#17021 - roife:add-hover-limits-for-adts, r=Veykril
Support hovering limits for adts Fix rust-lang#17009 1. Currently, r-a supports limiting the number of struct fields displayed when hovering. This PR extends it to support enum variants and union fields. Since the display of these three (ADTs) is similar, this PR extends 'hover_show_structFields' to 'hover_show_adtFieldsOrVariants'. 2. This PR also resolved the problem that the layout of ADT was not restricted by display limitations when hovering on the Self type. 3. Additionally, this PR changes the default value of display limitations to `10` (instead of the original `null`), which helps users discover this feature.
2 parents 1709e37 + f7f02c0 commit d00de38

File tree

8 files changed

+563
-97
lines changed

8 files changed

+563
-97
lines changed

‎src/tools/rust-analyzer/crates/hir/src/display.rs‎

Lines changed: 95 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -188,28 +188,7 @@ impl HirDisplay for Struct {
188188
StructKind::Record => {
189189
let has_where_clause = write_where_clause(def_id, f)?;
190190
if let Some(limit) = f.entity_limit {
191-
let fields = self.fields(f.db);
192-
let count = fields.len().min(limit);
193-
f.write_char(if !has_where_clause { ' ' } else { '\n' })?;
194-
if count == 0 {
195-
if fields.is_empty() {
196-
f.write_str("{}")?;
197-
} else {
198-
f.write_str("{ /* … */ }")?;
199-
}
200-
} else {
201-
f.write_str(" {\n")?;
202-
for field in &fields[..count] {
203-
f.write_str(" ")?;
204-
field.hir_fmt(f)?;
205-
f.write_str(",\n")?;
206-
}
207-
208-
if fields.len() > count {
209-
f.write_str(" /* … */\n")?;
210-
}
211-
f.write_str("}")?;
212-
}
191+
display_fields(&self.fields(f.db), has_where_clause, limit, false, f)?;
213192
}
214193
}
215194
StructKind::Unit => _ = write_where_clause(def_id, f)?,
@@ -226,18 +205,10 @@ impl HirDisplay for Enum {
226205
write!(f, "{}", self.name(f.db).display(f.db.upcast()))?;
227206
let def_id = GenericDefId::AdtId(AdtId::EnumId(self.id));
228207
write_generic_params(def_id, f)?;
229-
let has_where_clause = write_where_clause(def_id, f)?;
230208

231-
let variants = self.variants(f.db);
232-
if !variants.is_empty() {
233-
f.write_char(if !has_where_clause { ' ' } else { '\n' })?;
234-
f.write_str("{\n")?;
235-
for variant in variants {
236-
f.write_str(" ")?;
237-
variant.hir_fmt(f)?;
238-
f.write_str(",\n")?;
239-
}
240-
f.write_str("}")?;
209+
let has_where_clause = write_where_clause(def_id, f)?;
210+
if let Some(limit) = f.entity_limit {
211+
display_variants(&self.variants(f.db), has_where_clause, limit, f)?;
241212
}
242213

243214
Ok(())
@@ -251,22 +222,102 @@ impl HirDisplay for Union {
251222
write!(f, "{}", self.name(f.db).display(f.db.upcast()))?;
252223
let def_id = GenericDefId::AdtId(AdtId::UnionId(self.id));
253224
write_generic_params(def_id, f)?;
225+
254226
let has_where_clause = write_where_clause(def_id, f)?;
227+
if let Some(limit) = f.entity_limit {
228+
display_fields(&self.fields(f.db), has_where_clause, limit, false, f)?;
229+
}
230+
Ok(())
231+
}
232+
}
233+
234+
fn display_fields(
235+
fields: &[Field],
236+
has_where_clause: bool,
237+
limit: usize,
238+
in_line: bool,
239+
f: &mut HirFormatter<'_>,
240+
) -> Result<(), HirDisplayError> {
241+
let count = fields.len().min(limit);
242+
let (indent, separator) = if in_line { ("", ' ') } else { (" ", '\n') };
243+
f.write_char(if !has_where_clause { ' ' } else { separator })?;
244+
if count == 0 {
245+
if fields.is_empty() {
246+
f.write_str("{}")?;
247+
} else {
248+
f.write_str("{ /* … */ }")?;
249+
}
250+
} else {
251+
f.write_char('{')?;
255252

256-
let fields = self.fields(f.db);
257253
if !fields.is_empty() {
258-
f.write_char(if !has_where_clause { ' ' } else { '\n' })?;
259-
f.write_str("{\n")?;
260-
for field in self.fields(f.db) {
261-
f.write_str(" ")?;
254+
f.write_char(separator)?;
255+
for field in &fields[..count] {
256+
f.write_str(indent)?;
262257
field.hir_fmt(f)?;
263-
f.write_str(",\n")?;
258+
f.write_char(',')?;
259+
f.write_char(separator)?;
260+
}
261+
262+
if fields.len() > count {
263+
f.write_str(indent)?;
264+
f.write_str("/* … */")?;
265+
f.write_char(separator)?;
264266
}
265-
f.write_str("}")?;
266267
}
267268

268-
Ok(())
269+
f.write_str("}")?;
270+
}
271+
272+
Ok(())
273+
}
274+
275+
fn display_variants(
276+
variants: &[Variant],
277+
has_where_clause: bool,
278+
limit: usize,
279+
f: &mut HirFormatter<'_>,
280+
) -> Result<(), HirDisplayError> {
281+
let count = variants.len().min(limit);
282+
f.write_char(if !has_where_clause { ' ' } else { '\n' })?;
283+
if count == 0 {
284+
if variants.is_empty() {
285+
f.write_str("{}")?;
286+
} else {
287+
f.write_str("{ /* … */ }")?;
288+
}
289+
} else {
290+
f.write_str("{\n")?;
291+
for variant in &variants[..count] {
292+
f.write_str(" ")?;
293+
write!(f, "{}", variant.name(f.db).display(f.db.upcast()))?;
294+
match variant.kind(f.db) {
295+
StructKind::Tuple => {
296+
if variant.fields(f.db).is_empty() {
297+
f.write_str("()")?;
298+
} else {
299+
f.write_str("( /* … */ )")?;
300+
}
301+
}
302+
StructKind::Record => {
303+
if variant.fields(f.db).is_empty() {
304+
f.write_str(" {}")?;
305+
} else {
306+
f.write_str(" { /* … */ }")?;
307+
}
308+
}
309+
StructKind::Unit => {}
310+
}
311+
f.write_str(",\n")?;
312+
}
313+
314+
if variants.len() > count {
315+
f.write_str(" /* … */\n")?;
316+
}
317+
f.write_str("}")?;
269318
}
319+
320+
Ok(())
270321
}
271322

272323
impl HirDisplay for Field {
@@ -304,21 +355,10 @@ impl HirDisplay for Variant {
304355
}
305356
f.write_char(')')?;
306357
}
307-
VariantData::Record(fields) => {
308-
f.write_str(" {")?;
309-
let mut first = true;
310-
for (_, field) in fields.iter() {
311-
if first {
312-
first = false;
313-
f.write_char(' ')?;
314-
} else {
315-
f.write_str(", ")?;
316-
}
317-
// Enum variant fields must be pub.
318-
write!(f, "{}: ", field.name.display(f.db.upcast()))?;
319-
field.type_ref.hir_fmt(f)?;
358+
VariantData::Record(_) => {
359+
if let Some(limit) = f.entity_limit {
360+
display_fields(&self.fields(f.db), false, limit, true, f)?;
320361
}
321-
f.write_str(" }")?;
322362
}
323363
}
324364
Ok(())

‎src/tools/rust-analyzer/crates/ide/src/hover.rs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,8 @@ pub struct HoverConfig {
3333
pub keywords: bool,
3434
pub format: HoverDocFormat,
3535
pub max_trait_assoc_items_count: Option<usize>,
36-
pub max_struct_field_count: Option<usize>,
36+
pub max_fields_count: Option<usize>,
37+
pub max_enum_variants_count: Option<usize>,
3738
}
3839

3940
#[derive(Copy, Clone, Debug, PartialEq, Eq)]

‎src/tools/rust-analyzer/crates/ide/src/hover/render.rs‎

Lines changed: 15 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -411,8 +411,21 @@ pub(super) fn definition(
411411
Definition::Trait(trait_) => {
412412
trait_.display_limited(db, config.max_trait_assoc_items_count).to_string()
413413
}
414-
Definition::Adt(Adt::Struct(struct_)) => {
415-
struct_.display_limited(db, config.max_struct_field_count).to_string()
414+
Definition::Adt(adt @ (Adt::Struct(_) | Adt::Union(_))) => {
415+
adt.display_limited(db, config.max_fields_count).to_string()
416+
}
417+
Definition::Variant(variant) => {
418+
variant.display_limited(db, config.max_fields_count).to_string()
419+
}
420+
Definition::Adt(adt @ Adt::Enum(_)) => {
421+
adt.display_limited(db, config.max_enum_variants_count).to_string()
422+
}
423+
Definition::SelfType(impl_def) => {
424+
let self_ty = &impl_def.self_ty(db);
425+
match self_ty.as_adt() {
426+
Some(adt) => adt.display_limited(db, config.max_fields_count).to_string(),
427+
None => self_ty.display(db).to_string(),
428+
}
416429
}
417430
Definition::Macro(it) => {
418431
let mut label = it.display(db).to_string();

0 commit comments

Comments
 (0)