Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/hir/src/display.rs')
| -rw-r--r-- | crates/hir/src/display.rs | 238 |
1 files changed, 117 insertions, 121 deletions
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs index 6f4168ab08..53817f37aa 100644 --- a/crates/hir/src/display.rs +++ b/crates/hir/src/display.rs @@ -1,59 +1,59 @@ //! HirDisplay implementations for various hir types. + use either::Either; use hir_def::{ - data::{ - adt::{StructKind, VariantData}, - TraitFlags, - }, - generics::{ - GenericParams, TypeOrConstParamData, TypeParamProvenance, WherePredicate, - WherePredicateTypeTarget, - }, - lang_item::LangItem, - type_ref::{TypeBound, TypeRef}, AdtId, GenericDefId, + expr_store::ExpressionStore, + hir::generics::{GenericParams, TypeOrConstParamData, TypeParamProvenance, WherePredicate}, + item_tree::FieldsShape, + lang_item::LangItem, + signatures::{StaticFlags, TraitFlags}, + type_ref::{TypeBound, TypeRef, TypeRefId}, }; use hir_ty::{ + AliasEq, AliasTy, Interner, ProjectionTyExt, TraitRefExt, TyKind, WhereClause, + db::HirDatabase, display::{ - hir_display_with_types_map, write_bounds_like_dyn_trait_with_prefix, write_visibility, - HirDisplay, HirDisplayError, HirDisplayWithTypesMap, HirFormatter, SizedByDefault, + HirDisplay, HirDisplayError, HirDisplayWithExpressionStore, HirFormatter, SizedByDefault, + hir_display_with_store, write_bounds_like_dyn_trait_with_prefix, write_visibility, }, - AliasEq, AliasTy, Interner, ProjectionTyExt, TraitRefExt, TyKind, WhereClause, }; use itertools::Itertools; use crate::{ Adt, AsAssocItem, AssocItem, AssocItemContainer, Const, ConstParam, Crate, Enum, ExternCrateDecl, Field, Function, GenericParam, HasCrate, HasVisibility, Impl, LifetimeParam, - Macro, Module, SelfParam, Static, Struct, Trait, TraitAlias, TraitRef, TupleField, TyBuilder, - Type, TypeAlias, TypeOrConstParam, TypeParam, Union, Variant, + Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitAlias, TraitRef, TupleField, + TyBuilder, Type, TypeAlias, TypeOrConstParam, TypeParam, Union, Variant, }; impl HirDisplay for Function { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { let db = f.db; - let data = db.function_data(self.id); + let data = db.function_signature(self.id); let container = self.as_assoc_item(db).map(|it| it.container(db)); let mut module = self.module(db); // Write container (trait or impl) let container_params = match container { Some(AssocItemContainer::Trait(trait_)) => { - let params = f.db.generic_params(trait_.id.into()); + let (params, params_store) = f.db.generic_params_and_store(trait_.id.into()); if f.show_container_bounds() && !params.is_empty() { write_trait_header(&trait_, f)?; f.write_char('\n')?; - has_disaplayable_predicates(¶ms).then_some(params) + has_disaplayable_predicates(f.db, ¶ms, ¶ms_store) + .then_some((params, params_store)) } else { None } } Some(AssocItemContainer::Impl(impl_)) => { - let params = f.db.generic_params(impl_.id.into()); + let (params, params_store) = f.db.generic_params_and_store(impl_.id.into()); if f.show_container_bounds() && !params.is_empty() { write_impl_header(&impl_, f)?; f.write_char('\n')?; - has_disaplayable_predicates(¶ms).then_some(params) + has_disaplayable_predicates(f.db, ¶ms, ¶ms_store) + .then_some((params, params_store)) } else { None } @@ -88,7 +88,7 @@ impl HirDisplay for Function { if let Some(abi) = &data.abi { write!(f, "extern \"{}\" ", abi.as_str())?; } - write!(f, "fn {}", data.name.display(f.db.upcast(), f.edition()))?; + write!(f, "fn {}", data.name.display(f.db, f.edition()))?; write_generic_params(GenericDefId::FunctionId(self.id), f)?; @@ -112,12 +112,11 @@ impl HirDisplay for Function { } let pat_id = body.params[param.idx - body.self_param.is_some() as usize]; - let pat_str = - body.pretty_print_pat(db.upcast(), self.id.into(), pat_id, true, f.edition()); + let pat_str = body.pretty_print_pat(db, self.id.into(), pat_id, true, f.edition()); f.write_str(&pat_str)?; f.write_str(": ")?; - type_ref.hir_fmt(f, &data.types_map)?; + type_ref.hir_fmt(f, &data.store)?; } if data.is_varargs() { @@ -133,12 +132,12 @@ impl HirDisplay for Function { // Use ugly pattern match to strip the Future trait. // Better way? let ret_type = if !data.is_async() { - Some(data.ret_type) - } else { - match &data.types_map[data.ret_type] { + data.ret_type + } else if let Some(ret_type) = data.ret_type { + match &data.store[ret_type] { TypeRef::ImplTrait(bounds) => match &bounds[0] { &TypeBound::Path(path, _) => Some( - *data.types_map[path] + *data.store[path] .segments() .iter() .last() @@ -154,21 +153,23 @@ impl HirDisplay for Function { }, _ => None, } + } else { + None }; if let Some(ret_type) = ret_type { - match &data.types_map[ret_type] { + match &data.store[ret_type] { TypeRef::Tuple(tup) if tup.is_empty() => {} _ => { f.write_str(" -> ")?; - ret_type.hir_fmt(f, &data.types_map)?; + ret_type.hir_fmt(f, &data.store)?; } } } // Write where clauses let has_written_where = write_where_clause(GenericDefId::FunctionId(self.id), f)?; - if let Some(container_params) = container_params { + if let Some((container_params, container_params_store)) = container_params { if !has_written_where { f.write_str("\nwhere")?; } @@ -177,7 +178,7 @@ impl HirDisplay for Function { AssocItemContainer::Impl(_) => "impl", }; write!(f, "\n // Bounds from {container_name}:",)?; - write_where_predicates(&container_params, f)?; + write_where_predicates(&container_params, &container_params_store, f)?; } Ok(()) } @@ -191,8 +192,8 @@ fn write_impl_header(impl_: &Impl, f: &mut HirFormatter<'_>) -> Result<(), HirDi write_generic_params(def_id, f)?; if let Some(trait_) = impl_.trait_(db) { - let trait_data = db.trait_data(trait_.id); - write!(f, " {} for", trait_data.name.display(db.upcast(), f.edition()))?; + let trait_data = db.trait_signature(trait_.id); + write!(f, " {} for", trait_data.name.display(db, f.edition()))?; } f.write_char(' ')?; @@ -203,15 +204,16 @@ fn write_impl_header(impl_: &Impl, f: &mut HirFormatter<'_>) -> Result<(), HirDi impl HirDisplay for SelfParam { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { - let data = f.db.function_data(self.func); + let data = f.db.function_signature(self.func); let param = *data.params.first().unwrap(); - match &data.types_map[param] { + match &data.store[param] { TypeRef::Path(p) if p.is_self_type() => f.write_str("self"), - TypeRef::Reference(ref_) if matches!(&data.types_map[ref_.ty], TypeRef::Path(p) if p.is_self_type()) => + TypeRef::Reference(ref_) if matches!(&data.store[ref_.ty], TypeRef::Path(p) if p.is_self_type()) => { f.write_char('&')?; if let Some(lifetime) = &ref_.lifetime { - write!(f, "{} ", lifetime.name.display(f.db.upcast(), f.edition()))?; + lifetime.hir_fmt(f, &data.store)?; + f.write_char(' ')?; } if let hir_def::type_ref::Mutability::Mut = ref_.mutability { f.write_str("mut ")?; @@ -220,7 +222,7 @@ impl HirDisplay for SelfParam { } _ => { f.write_str("self: ")?; - param.hir_fmt(f, &data.types_map) + param.hir_fmt(f, &data.store) } } } @@ -242,12 +244,12 @@ impl HirDisplay for Struct { // FIXME: Render repr if its set explicitly? write_visibility(module_id, self.visibility(f.db), f)?; f.write_str("struct ")?; - write!(f, "{}", self.name(f.db).display(f.db.upcast(), f.edition()))?; + write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?; let def_id = GenericDefId::AdtId(AdtId::StructId(self.id)); write_generic_params(def_id, f)?; - let variant_data = self.variant_data(f.db); - match variant_data.kind() { + let variant_data = self.variant_fields(f.db); + match self.kind(f.db) { StructKind::Tuple => { f.write_char('(')?; let mut it = variant_data.fields().iter().peekable(); @@ -281,7 +283,7 @@ impl HirDisplay for Enum { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; f.write_str("enum ")?; - write!(f, "{}", self.name(f.db).display(f.db.upcast(), f.edition()))?; + write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?; let def_id = GenericDefId::AdtId(AdtId::EnumId(self.id)); write_generic_params(def_id, f)?; @@ -298,7 +300,7 @@ impl HirDisplay for Union { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; f.write_str("union ")?; - write!(f, "{}", self.name(f.db).display(f.db.upcast(), f.edition()))?; + write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?; let def_id = GenericDefId::AdtId(AdtId::UnionId(self.id)); write_generic_params(def_id, f)?; @@ -358,7 +360,7 @@ fn write_variants( } else { f.write_str("{\n")?; for variant in &variants[..count] { - write!(f, " {}", variant.name(f.db).display(f.db.upcast(), f.edition()))?; + write!(f, " {}", variant.name(f.db).display(f.db, f.edition()))?; match variant.kind(f.db) { StructKind::Tuple => { let fields_str = @@ -387,39 +389,39 @@ fn write_variants( impl HirDisplay for Field { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { write_visibility(self.parent.module(f.db).id, self.visibility(f.db), f)?; - write!(f, "{}: ", self.name(f.db).display(f.db.upcast(), f.edition()))?; + write!(f, "{}: ", self.name(f.db).display(f.db, f.edition()))?; self.ty(f.db).hir_fmt(f) } } impl HirDisplay for TupleField { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { - write!(f, "pub {}: ", self.name().display(f.db.upcast(), f.edition()))?; + write!(f, "pub {}: ", self.name().display(f.db, f.edition()))?; self.ty(f.db).hir_fmt(f) } } impl HirDisplay for Variant { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { - write!(f, "{}", self.name(f.db).display(f.db.upcast(), f.edition()))?; - let data = self.variant_data(f.db); - match &*data { - VariantData::Unit => {} - VariantData::Tuple { fields, types_map } => { + write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?; + let data = f.db.variant_fields(self.id.into()); + match data.shape { + FieldsShape::Unit => {} + FieldsShape::Tuple => { f.write_char('(')?; let mut first = true; - for (_, field) in fields.iter() { + for (_, field) in data.fields().iter() { if first { first = false; } else { f.write_str(", ")?; } // Enum variant fields must be pub. - field.type_ref.hir_fmt(f, types_map)?; + field.type_ref.hir_fmt(f, &data.store)?; } f.write_char(')')?; } - VariantData::Record { .. } => { + FieldsShape::Record => { if let Some(limit) = f.entity_limit { write_fields(&self.fields(f.db), false, limit, true, f)?; } @@ -439,7 +441,7 @@ impl HirDisplay for ExternCrateDecl { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; f.write_str("extern crate ")?; - write!(f, "{}", self.name(f.db).display(f.db.upcast(), f.edition()))?; + write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?; if let Some(alias) = self.alias(f.db) { write!(f, " as {}", alias.display(f.edition()))?; } @@ -493,7 +495,7 @@ impl HirDisplay for TypeParam { match param_data { TypeOrConstParamData::TypeParamData(p) => match p.provenance { TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => { - write!(f, "{}", p.name.clone().unwrap().display(f.db.upcast(), f.edition()))? + write!(f, "{}", p.name.clone().unwrap().display(f.db, f.edition()))? } TypeParamProvenance::ArgumentImplTrait => { return write_bounds_like_dyn_trait_with_prefix( @@ -506,7 +508,7 @@ impl HirDisplay for TypeParam { } }, TypeOrConstParamData::ConstParamData(p) => { - write!(f, "{}", p.name.display(f.db.upcast(), f.edition()))?; + write!(f, "{}", p.name.display(f.db, f.edition()))?; } } @@ -540,13 +542,13 @@ impl HirDisplay for TypeParam { impl HirDisplay for LifetimeParam { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { - write!(f, "{}", self.name(f.db).display(f.db.upcast(), f.edition())) + write!(f, "{}", self.name(f.db).display(f.db, f.edition())) } } impl HirDisplay for ConstParam { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { - write!(f, "const {}: ", self.name(f.db).display(f.db.upcast(), f.edition()))?; + write!(f, "const {}: ", self.name(f.db).display(f.db, f.edition()))?; self.ty(f.db).hir_fmt(f) } } @@ -555,7 +557,7 @@ fn write_generic_params( def: GenericDefId, f: &mut HirFormatter<'_>, ) -> Result<(), HirDisplayError> { - let params = f.db.generic_params(def); + let (params, store) = f.db.generic_params_and_store(def); if params.iter_lt().next().is_none() && params.iter_type_or_consts().all(|it| it.1.const_param().is_none()) && params @@ -578,7 +580,7 @@ fn write_generic_params( }; for (_, lifetime) in params.iter_lt() { delim(f)?; - write!(f, "{}", lifetime.name.display(f.db.upcast(), f.edition()))?; + write!(f, "{}", lifetime.name.display(f.db, f.edition()))?; } for (_, ty) in params.iter_type_or_consts() { if let Some(name) = &ty.name() { @@ -588,20 +590,20 @@ fn write_generic_params( continue; } delim(f)?; - write!(f, "{}", name.display(f.db.upcast(), f.edition()))?; + write!(f, "{}", name.display(f.db, f.edition()))?; if let Some(default) = &ty.default { f.write_str(" = ")?; - default.hir_fmt(f, ¶ms.types_map)?; + default.hir_fmt(f, &store)?; } } TypeOrConstParamData::ConstParamData(c) => { delim(f)?; - write!(f, "const {}: ", name.display(f.db.upcast(), f.edition()))?; - c.ty.hir_fmt(f, ¶ms.types_map)?; + write!(f, "const {}: ", name.display(f.db, f.edition()))?; + c.ty.hir_fmt(f, &store)?; if let Some(default) = &c.default { f.write_str(" = ")?; - write!(f, "{}", default.display(f.db.upcast(), f.edition()))?; + default.hir_fmt(f, &store)?; } } } @@ -616,48 +618,47 @@ fn write_where_clause( def: GenericDefId, f: &mut HirFormatter<'_>, ) -> Result<bool, HirDisplayError> { - let params = f.db.generic_params(def); - if !has_disaplayable_predicates(¶ms) { + let (params, store) = f.db.generic_params_and_store(def); + if !has_disaplayable_predicates(f.db, ¶ms, &store) { return Ok(false); } f.write_str("\nwhere")?; - write_where_predicates(¶ms, f)?; + write_where_predicates(¶ms, &store, f)?; Ok(true) } -fn has_disaplayable_predicates(params: &GenericParams) -> bool { +fn has_disaplayable_predicates( + db: &dyn HirDatabase, + params: &GenericParams, + store: &ExpressionStore, +) -> bool { params.where_predicates().any(|pred| { !matches!( pred, - WherePredicate::TypeBound { target: WherePredicateTypeTarget::TypeOrConstParam(id), .. } - if params[*id].name().is_none() + WherePredicate::TypeBound { target, .. } + if matches!(store[*target], + TypeRef::TypeParam(id) if db.generic_params(id.parent())[id.local_id()].name().is_none() + ) ) }) } fn write_where_predicates( params: &GenericParams, + store: &ExpressionStore, f: &mut HirFormatter<'_>, ) -> Result<(), HirDisplayError> { use WherePredicate::*; // unnamed type targets are displayed inline with the argument itself, e.g. `f: impl Y`. - let is_unnamed_type_target = |params: &GenericParams, target: &WherePredicateTypeTarget| { - matches!(target, - WherePredicateTypeTarget::TypeOrConstParam(id) if params[*id].name().is_none() + let is_unnamed_type_target = |target: TypeRefId| { + matches!(store[target], + TypeRef::TypeParam(id) if f.db.generic_params(id.parent())[id.local_id()].name().is_none() ) }; - let write_target = |target: &WherePredicateTypeTarget, f: &mut HirFormatter<'_>| match target { - WherePredicateTypeTarget::TypeRef(ty) => ty.hir_fmt(f, ¶ms.types_map), - WherePredicateTypeTarget::TypeOrConstParam(id) => match params[*id].name() { - Some(name) => write!(f, "{}", name.display(f.db.upcast(), f.edition())), - None => f.write_str("{unnamed}"), - }, - }; - let check_same_target = |pred1: &WherePredicate, pred2: &WherePredicate| match (pred1, pred2) { (TypeBound { target: t1, .. }, TypeBound { target: t2, .. }) => t1 == t2, (Lifetime { target: t1, .. }, Lifetime { target: t2, .. }) => t1 == t2, @@ -670,41 +671,36 @@ fn write_where_predicates( let mut iter = params.where_predicates().peekable(); while let Some(pred) = iter.next() { - if matches!(pred, TypeBound { target, .. } if is_unnamed_type_target(params, target)) { + if matches!(pred, TypeBound { target, .. } if is_unnamed_type_target(*target)) { continue; } f.write_str("\n ")?; match pred { TypeBound { target, bound } => { - write_target(target, f)?; + target.hir_fmt(f, store)?; f.write_str(": ")?; - bound.hir_fmt(f, ¶ms.types_map)?; + bound.hir_fmt(f, store)?; } Lifetime { target, bound } => { - let target = target.name.display(f.db.upcast(), f.edition()); - let bound = bound.name.display(f.db.upcast(), f.edition()); - write!(f, "{target}: {bound}")?; + target.hir_fmt(f, store)?; + write!(f, ": ")?; + bound.hir_fmt(f, store)?; } ForLifetime { lifetimes, target, bound } => { - let lifetimes = - lifetimes.iter().map(|it| it.display(f.db.upcast(), f.edition())).join(", "); + let lifetimes = lifetimes.iter().map(|it| it.display(f.db, f.edition())).join(", "); write!(f, "for<{lifetimes}> ")?; - write_target(target, f)?; + target.hir_fmt(f, store)?; f.write_str(": ")?; - bound.hir_fmt(f, ¶ms.types_map)?; + bound.hir_fmt(f, store)?; } } while let Some(nxt) = iter.next_if(|nxt| check_same_target(pred, nxt)) { f.write_str(" + ")?; match nxt { - TypeBound { bound, .. } | ForLifetime { bound, .. } => { - bound.hir_fmt(f, ¶ms.types_map)? - } - Lifetime { bound, .. } => { - write!(f, "{}", bound.name.display(f.db.upcast(), f.edition()))? - } + TypeBound { bound, .. } | ForLifetime { bound, .. } => bound.hir_fmt(f, store)?, + Lifetime { bound, .. } => bound.hir_fmt(f, store)?, } } f.write_str(",")?; @@ -723,13 +719,13 @@ impl HirDisplay for Const { module = module.nearest_non_block_module(db); } write_visibility(module.id, self.visibility(db), f)?; - let data = db.const_data(self.id); + let data = db.const_signature(self.id); f.write_str("const ")?; match &data.name { - Some(name) => write!(f, "{}: ", name.display(f.db.upcast(), f.edition()))?, + Some(name) => write!(f, "{}: ", name.display(f.db, f.edition()))?, None => f.write_str("_: ")?, } - data.type_ref.hir_fmt(f, &data.types_map)?; + data.type_ref.hir_fmt(f, &data.store)?; Ok(()) } } @@ -737,13 +733,13 @@ impl HirDisplay for Const { impl HirDisplay for Static { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; - let data = f.db.static_data(self.id); + let data = f.db.static_signature(self.id); f.write_str("static ")?; - if data.mutable { + if data.flags.contains(StaticFlags::MUTABLE) { f.write_str("mut ")?; } - write!(f, "{}: ", data.name.display(f.db.upcast(), f.edition()))?; - data.type_ref.hir_fmt(f, &data.types_map)?; + write!(f, "{}: ", data.name.display(f.db, f.edition()))?; + data.type_ref.hir_fmt(f, &data.store)?; Ok(()) } } @@ -795,14 +791,14 @@ impl HirDisplay for Trait { fn write_trait_header(trait_: &Trait, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { write_visibility(trait_.module(f.db).id, trait_.visibility(f.db), f)?; - let data = f.db.trait_data(trait_.id); - if data.flags.contains(TraitFlags::IS_UNSAFE) { + let data = f.db.trait_signature(trait_.id); + if data.flags.contains(TraitFlags::UNSAFE) { f.write_str("unsafe ")?; } - if data.flags.contains(TraitFlags::IS_AUTO) { + if data.flags.contains(TraitFlags::AUTO) { f.write_str("auto ")?; } - write!(f, "trait {}", data.name.display(f.db.upcast(), f.edition()))?; + write!(f, "trait {}", data.name.display(f.db, f.edition()))?; write_generic_params(GenericDefId::TraitId(trait_.id), f)?; Ok(()) } @@ -810,8 +806,8 @@ fn write_trait_header(trait_: &Trait, f: &mut HirFormatter<'_>) -> Result<(), Hi impl HirDisplay for TraitAlias { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; - let data = f.db.trait_alias_data(self.id); - write!(f, "trait {}", data.name.display(f.db.upcast(), f.edition()))?; + let data = f.db.trait_alias_signature(self.id); + write!(f, "trait {}", data.name.display(f.db, f.edition()))?; let def_id = GenericDefId::TraitAliasId(self.id); write_generic_params(def_id, f)?; f.write_str(" = ")?; @@ -826,20 +822,20 @@ impl HirDisplay for TraitAlias { impl HirDisplay for TypeAlias { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; - let data = f.db.type_alias_data(self.id); - write!(f, "type {}", data.name.display(f.db.upcast(), f.edition()))?; + let data = f.db.type_alias_signature(self.id); + write!(f, "type {}", data.name.display(f.db, f.edition()))?; let def_id = GenericDefId::TypeAliasId(self.id); write_generic_params(def_id, f)?; if !data.bounds.is_empty() { f.write_str(": ")?; f.write_joined( - data.bounds.iter().map(|bound| hir_display_with_types_map(bound, &data.types_map)), + data.bounds.iter().map(|bound| hir_display_with_store(bound, &data.store)), " + ", )?; } - if let Some(ty) = data.type_ref { + if let Some(ty) = data.ty { f.write_str(" = ")?; - ty.hir_fmt(f, &data.types_map)?; + ty.hir_fmt(f, &data.store)?; } write_where_clause(def_id, f)?; Ok(()) @@ -854,11 +850,11 @@ impl HirDisplay for Module { return match self.krate(f.db).display_name(f.db) { Some(name) => write!(f, "extern crate {name}"), None => f.write_str("extern crate {unknown}"), - } + }; } } match self.name(f.db) { - Some(name) => write!(f, "mod {}", name.display(f.db.upcast(), f.edition())), + Some(name) => write!(f, "mod {}", name.display(f.db, f.edition())), None => f.write_str("mod {unknown}"), } } @@ -880,6 +876,6 @@ impl HirDisplay for Macro { hir_def::MacroId::MacroRulesId(_) => f.write_str("macro_rules!"), hir_def::MacroId::ProcMacroId(_) => f.write_str("proc_macro"), }?; - write!(f, " {}", self.name(f.db).display(f.db.upcast(), f.edition())) + write!(f, " {}", self.name(f.db).display(f.db, f.edition())) } } |