rust/crates/hir/src/display.rs

660 lines
23 KiB
Rust
Raw Normal View History

//! HirDisplay implementations for various hir types.
use hir_def::{
2023-11-08 07:45:32 -06:00
data::adt::{StructKind, VariantData},
2021-12-29 07:35:59 -06:00
generics::{
TypeOrConstParamData, TypeParamProvenance, WherePredicate, WherePredicateTypeTarget,
},
lang_item::LangItem,
type_ref::{TypeBound, TypeRef},
2021-03-15 11:05:03 -05:00
AdtId, GenericDefId,
};
use hir_ty::{
display::{
write_bounds_like_dyn_trait_with_prefix, write_visibility, HirDisplay, HirDisplayError,
HirFormatter, SizedByDefault,
},
Interner, TraitRefExt, WhereClause,
};
2021-03-15 11:05:03 -05:00
use crate::{
2023-08-02 04:52:55 -05:00
Adt, AsAssocItem, AssocItemContainer, Const, ConstParam, Enum, ExternCrateDecl, Field,
2023-08-08 13:22:18 -05:00
Function, GenericParam, HasCrate, HasVisibility, LifetimeParam, Macro, Module, SelfParam,
Static, Struct, Trait, TraitAlias, TupleField, TyBuilder, Type, TypeAlias, TypeOrConstParam,
TypeParam, Union, Variant,
2021-03-15 11:05:03 -05:00
};
impl HirDisplay for Function {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
let db = f.db;
let data = db.function_data(self.id);
let container = self.as_assoc_item(db).map(|it| it.container(db));
let mut module = self.module(db);
if let Some(AssocItemContainer::Impl(_)) = container {
// Block-local impls are "hoisted" to the nearest (non-block) module.
module = module.nearest_non_block_module(db);
}
let module_id = module.id;
write_visibility(module_id, self.visibility(db), f)?;
if data.has_default_kw() {
f.write_str("default ")?;
}
if data.has_const_kw() {
f.write_str("const ")?;
}
if data.has_async_kw() {
f.write_str("async ")?;
}
if self.is_unsafe_to_call(db) {
f.write_str("unsafe ")?;
}
if let Some(abi) = &data.abi {
// FIXME: String escape?
write!(f, "extern \"{}\" ", &**abi)?;
}
write!(f, "fn {}", data.name.display(f.db.upcast()))?;
write_generic_params(GenericDefId::FunctionId(self.id), f)?;
f.write_char('(')?;
let mut first = true;
2023-08-08 13:22:18 -05:00
let mut skip_self = 0;
if let Some(self_param) = self.self_param(db) {
self_param.hir_fmt(f)?;
first = false;
skip_self = 1;
}
// FIXME: Use resolved `param.ty` once we no longer discard lifetimes
2023-08-08 13:22:18 -05:00
for (type_ref, param) in data.params.iter().zip(self.assoc_fn_params(db)).skip(skip_self) {
let local = param.as_local(db).map(|it| it.name(db));
if !first {
f.write_str(", ")?;
} else {
first = false;
}
match local {
Some(name) => write!(f, "{}: ", name.display(f.db.upcast()))?,
None => f.write_str("_: ")?,
}
type_ref.hir_fmt(f)?;
}
if data.is_varargs() {
f.write_str(", ...")?;
}
f.write_char(')')?;
// `FunctionData::ret_type` will be `::core::future::Future<Output = ...>` for async fns.
// Use ugly pattern match to strip the Future trait.
// Better way?
let ret_type = if !data.has_async_kw() {
&data.ret_type
} else {
2021-04-01 12:46:43 -05:00
match &*data.ret_type {
TypeRef::ImplTrait(bounds) => match bounds[0].as_ref() {
TypeBound::Path(path, _) => {
path.segments().iter().last().unwrap().args_and_bindings.unwrap().bindings
[0]
.type_ref
.as_ref()
.unwrap()
}
_ => panic!("Async fn ret_type should be impl Future"),
},
_ => panic!("Async fn ret_type should be impl Future"),
}
};
match ret_type {
TypeRef::Tuple(tup) if tup.is_empty() => {}
ty => {
f.write_str(" -> ")?;
ty.hir_fmt(f)?;
}
}
write_where_clause(GenericDefId::FunctionId(self.id), f)?;
Ok(())
}
}
2023-08-08 13:22:18 -05:00
impl HirDisplay for SelfParam {
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
let data = f.db.function_data(self.func);
let param = data.params.first().unwrap();
match &**param {
TypeRef::Path(p) if p.is_self_type() => f.write_str("self"),
TypeRef::Reference(inner, lifetime, mut_) if matches!(&**inner, TypeRef::Path(p) if p.is_self_type()) =>
{
f.write_char('&')?;
if let Some(lifetime) = lifetime {
write!(f, "{} ", lifetime.name.display(f.db.upcast()))?;
}
if let hir_def::type_ref::Mutability::Mut = mut_ {
f.write_str("mut ")?;
}
f.write_str("self")
}
ty => {
f.write_str("self: ")?;
ty.hir_fmt(f)
}
}
}
}
impl HirDisplay for Adt {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
match self {
Adt::Struct(it) => it.hir_fmt(f),
Adt::Union(it) => it.hir_fmt(f),
Adt::Enum(it) => it.hir_fmt(f),
}
}
}
2021-03-15 11:05:03 -05:00
impl HirDisplay for Struct {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-03-15 11:05:03 -05:00
write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
f.write_str("struct ")?;
write!(f, "{}", self.name(f.db).display(f.db.upcast()))?;
2021-03-15 11:05:03 -05:00
let def_id = GenericDefId::AdtId(AdtId::StructId(self.id));
write_generic_params(def_id, f)?;
2023-11-08 07:45:32 -06:00
let variant_data = self.variant_data(f.db);
if let StructKind::Tuple = variant_data.kind() {
f.write_char('(')?;
let mut it = variant_data.fields().iter().peekable();
while let Some((id, _)) = it.next() {
let field = Field { parent: (*self).into(), id };
field.ty(f.db).hir_fmt(f)?;
if it.peek().is_some() {
f.write_str(", ")?;
}
}
f.write_str(");")?;
}
2021-03-15 11:05:03 -05:00
write_where_clause(def_id, f)?;
2023-11-08 07:45:32 -06:00
if let StructKind::Record = variant_data.kind() {
let fields = self.fields(f.db);
if fields.is_empty() {
f.write_str(" {}")?;
} else {
f.write_str(" {\n")?;
for field in self.fields(f.db) {
f.write_str(" ")?;
field.hir_fmt(f)?;
f.write_str(",\n")?;
}
f.write_str("}")?;
}
}
2021-03-15 11:05:03 -05:00
Ok(())
}
}
impl HirDisplay for Enum {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-03-15 11:05:03 -05:00
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()))?;
2021-03-15 11:05:03 -05:00
let def_id = GenericDefId::AdtId(AdtId::EnumId(self.id));
write_generic_params(def_id, f)?;
write_where_clause(def_id, f)?;
2023-11-08 07:45:32 -06:00
let variants = self.variants(f.db);
if !variants.is_empty() {
f.write_str(" {\n")?;
for variant in variants {
f.write_str(" ")?;
variant.hir_fmt(f)?;
f.write_str(",\n")?;
}
f.write_str("}")?;
}
2021-03-15 11:05:03 -05:00
Ok(())
}
}
impl HirDisplay for Union {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-03-15 11:05:03 -05:00
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()))?;
2021-03-15 11:05:03 -05:00
let def_id = GenericDefId::AdtId(AdtId::UnionId(self.id));
write_generic_params(def_id, f)?;
write_where_clause(def_id, f)?;
2023-11-08 07:45:32 -06:00
let fields = self.fields(f.db);
if !fields.is_empty() {
f.write_str(" {\n")?;
for field in self.fields(f.db) {
f.write_str(" ")?;
field.hir_fmt(f)?;
f.write_str(",\n")?;
}
f.write_str("}")?;
}
2021-03-15 11:05:03 -05:00
Ok(())
}
}
impl HirDisplay for Field {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-03-15 11:05:03 -05:00
write_visibility(self.parent.module(f.db).id, self.visibility(f.db), f)?;
write!(f, "{}: ", self.name(f.db).display(f.db.upcast()))?;
self.ty(f.db).hir_fmt(f)
2021-03-15 11:05:03 -05:00
}
}
impl HirDisplay for TupleField {
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
write!(f, "pub {}: ", self.name().display(f.db.upcast()))?;
self.ty(f.db).hir_fmt(f)
}
}
2021-03-15 11:05:03 -05:00
impl HirDisplay for Variant {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
write!(f, "{}", self.name(f.db).display(f.db.upcast()))?;
2021-03-15 11:05:03 -05:00
let data = self.variant_data(f.db);
match &*data {
VariantData::Unit => {}
VariantData::Tuple(fields) => {
f.write_char('(')?;
2021-03-15 11:05:03 -05:00
let mut first = true;
for (_, field) in fields.iter() {
if first {
first = false;
} else {
f.write_str(", ")?;
2021-03-15 11:05:03 -05:00
}
// Enum variant fields must be pub.
field.type_ref.hir_fmt(f)?;
}
f.write_char(')')?;
2021-03-15 11:05:03 -05:00
}
VariantData::Record(fields) => {
f.write_str(" {")?;
2021-03-15 11:05:03 -05:00
let mut first = true;
for (_, field) in fields.iter() {
if first {
first = false;
f.write_char(' ')?;
2021-03-15 11:05:03 -05:00
} else {
f.write_str(", ")?;
2021-03-15 11:05:03 -05:00
}
// Enum variant fields must be pub.
write!(f, "{}: ", field.name.display(f.db.upcast()))?;
2021-03-15 11:05:03 -05:00
field.type_ref.hir_fmt(f)?;
}
f.write_str(" }")?;
2021-03-15 11:05:03 -05:00
}
}
Ok(())
}
}
impl HirDisplay for Type {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
self.ty.hir_fmt(f)
}
}
2023-08-02 04:52:55 -05:00
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()))?;
if let Some(alias) = self.alias(f.db) {
write!(f, " as {alias}",)?;
}
Ok(())
}
}
impl HirDisplay for GenericParam {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
match self {
GenericParam::TypeParam(it) => it.hir_fmt(f),
GenericParam::ConstParam(it) => it.hir_fmt(f),
2021-12-29 07:35:59 -06:00
GenericParam::LifetimeParam(it) => it.hir_fmt(f),
}
}
}
impl HirDisplay for TypeOrConstParam {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-12-29 07:35:59 -06:00
match self.split(f.db) {
2023-07-06 09:03:17 -05:00
either::Either::Left(it) => it.hir_fmt(f),
either::Either::Right(it) => it.hir_fmt(f),
}
}
}
impl HirDisplay for TypeParam {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
write!(f, "{}", self.name(f.db).display(f.db.upcast()))?;
if f.omit_verbose_types() {
return Ok(());
}
2021-12-29 07:35:59 -06:00
let bounds = f.db.generic_predicates_for_param(self.id.parent(), self.id.into(), None);
2022-03-09 12:50:24 -06:00
let substs = TyBuilder::placeholder_subst(f.db, self.id.parent());
let predicates: Vec<_> =
2021-12-19 10:58:39 -06:00
bounds.iter().cloned().map(|b| b.substitute(Interner, &substs)).collect();
2021-12-29 07:35:59 -06:00
let krate = self.id.parent().krate(f.db).id;
let sized_trait =
f.db.lang_item(krate, LangItem::Sized).and_then(|lang_item| lang_item.as_trait());
let has_only_sized_bound = predicates.iter().all(move |pred| match pred.skip_binders() {
WhereClause::Implemented(it) => Some(it.hir_trait_id()) == sized_trait,
_ => false,
});
let has_only_not_sized_bound = predicates.is_empty();
if !has_only_sized_bound || has_only_not_sized_bound {
let default_sized = SizedByDefault::Sized { anchor: krate };
write_bounds_like_dyn_trait_with_prefix(f, ":", &predicates, default_sized)?;
}
Ok(())
}
}
impl HirDisplay for LifetimeParam {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
write!(f, "{}", self.name(f.db).display(f.db.upcast()))
}
}
2021-03-15 11:05:03 -05:00
impl HirDisplay for ConstParam {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
write!(f, "const {}: ", self.name(f.db).display(f.db.upcast()))?;
2021-03-15 11:05:03 -05:00
self.ty(f.db).hir_fmt(f)
}
}
2022-07-20 08:06:15 -05:00
fn write_generic_params(
def: GenericDefId,
f: &mut HirFormatter<'_>,
) -> Result<(), HirDisplayError> {
let params = f.db.generic_params(def);
2021-03-15 11:58:29 -05:00
if params.lifetimes.is_empty()
2023-07-06 09:03:17 -05:00
&& params.type_or_consts.iter().all(|it| it.1.const_param().is_none())
2021-03-15 11:58:29 -05:00
&& params
2022-03-09 12:50:24 -06:00
.type_or_consts
2021-03-15 11:58:29 -05:00
.iter()
2023-07-06 09:03:17 -05:00
.filter_map(|it| it.1.type_param())
2021-12-29 07:35:59 -06:00
.all(|param| !matches!(param.provenance, TypeParamProvenance::TypeParamList))
2021-03-15 11:58:29 -05:00
{
return Ok(());
}
f.write_char('<')?;
let mut first = true;
2022-07-20 08:02:08 -05:00
let mut delim = |f: &mut HirFormatter<'_>| {
if first {
first = false;
Ok(())
} else {
f.write_str(", ")
}
};
for (_, lifetime) in params.lifetimes.iter() {
delim(f)?;
write!(f, "{}", lifetime.name.display(f.db.upcast()))?;
}
2022-03-09 12:50:24 -06:00
for (_, ty) in params.type_or_consts.iter() {
2021-12-29 07:35:59 -06:00
if let Some(name) = &ty.name() {
match ty {
TypeOrConstParamData::TypeParamData(ty) => {
if ty.provenance != TypeParamProvenance::TypeParamList {
continue;
}
delim(f)?;
write!(f, "{}", name.display(f.db.upcast()))?;
2021-12-29 07:35:59 -06:00
if let Some(default) = &ty.default {
f.write_str(" = ")?;
2021-12-29 07:35:59 -06:00
default.hir_fmt(f)?;
}
}
TypeOrConstParamData::ConstParamData(c) => {
delim(f)?;
write!(f, "const {}: ", name.display(f.db.upcast()))?;
2021-12-29 07:35:59 -06:00
c.ty.hir_fmt(f)?;
if let Some(default) = &c.default {
f.write_str(" = ")?;
write!(f, "{}", default.display(f.db.upcast()))?;
}
2021-12-29 07:35:59 -06:00
}
}
}
}
f.write_char('>')?;
Ok(())
}
2022-07-20 08:02:08 -05:00
fn write_where_clause(def: GenericDefId, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
let params = f.db.generic_params(def);
2021-11-20 05:30:53 -06:00
// unnamed type targets are displayed inline with the argument itself, e.g. `f: impl Y`.
let is_unnamed_type_target = |target: &WherePredicateTypeTarget| match target {
WherePredicateTypeTarget::TypeRef(_) => false,
2022-03-09 12:50:24 -06:00
WherePredicateTypeTarget::TypeOrConstParam(id) => {
params.type_or_consts[*id].name().is_none()
}
2021-11-20 05:30:53 -06:00
};
let has_displayable_predicate = params
.where_predicates
.iter()
.any(|pred| {
!matches!(pred, WherePredicate::TypeBound { target, .. } if is_unnamed_type_target(target))
});
if !has_displayable_predicate {
return Ok(());
}
2022-07-20 08:02:08 -05:00
let write_target = |target: &WherePredicateTypeTarget, f: &mut HirFormatter<'_>| match target {
WherePredicateTypeTarget::TypeRef(ty) => ty.hir_fmt(f),
2022-03-09 12:50:24 -06:00
WherePredicateTypeTarget::TypeOrConstParam(id) => {
match &params.type_or_consts[*id].name() {
Some(name) => write!(f, "{}", name.display(f.db.upcast())),
None => f.write_str("{unnamed}"),
2022-03-09 12:50:24 -06:00
}
}
};
f.write_str("\nwhere")?;
for (pred_idx, pred) in params.where_predicates.iter().enumerate() {
let prev_pred =
if pred_idx == 0 { None } else { Some(&params.where_predicates[pred_idx - 1]) };
2022-07-20 08:06:15 -05:00
let new_predicate = |f: &mut HirFormatter<'_>| {
f.write_str(if pred_idx == 0 { "\n " } else { ",\n " })
};
match pred {
2021-11-20 05:30:53 -06:00
WherePredicate::TypeBound { target, .. } if is_unnamed_type_target(target) => {}
WherePredicate::TypeBound { target, bound } => {
if matches!(prev_pred, Some(WherePredicate::TypeBound { target: target_, .. }) if target_ == target)
{
f.write_str(" + ")?;
} else {
new_predicate(f)?;
write_target(target, f)?;
f.write_str(": ")?;
}
bound.hir_fmt(f)?;
}
WherePredicate::Lifetime { target, bound } => {
if matches!(prev_pred, Some(WherePredicate::Lifetime { target: target_, .. }) if target_ == target)
{
write!(f, " + {}", bound.name.display(f.db.upcast()))?;
} else {
new_predicate(f)?;
write!(
f,
"{}: {}",
target.name.display(f.db.upcast()),
bound.name.display(f.db.upcast())
)?;
}
}
WherePredicate::ForLifetime { lifetimes, target, bound } => {
if matches!(
prev_pred,
Some(WherePredicate::ForLifetime { lifetimes: lifetimes_, target: target_, .. })
if lifetimes_ == lifetimes && target_ == target,
) {
f.write_str(" + ")?;
} else {
new_predicate(f)?;
f.write_str("for<")?;
for (idx, lifetime) in lifetimes.iter().enumerate() {
if idx != 0 {
f.write_str(", ")?;
}
write!(f, "{}", lifetime.display(f.db.upcast()))?;
}
f.write_str("> ")?;
write_target(target, f)?;
f.write_str(": ")?;
}
bound.hir_fmt(f)?;
}
}
}
// End of final predicate. There must be at least one predicate here.
f.write_char(',')?;
Ok(())
}
2021-03-15 11:05:03 -05:00
impl HirDisplay for Const {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
let db = f.db;
let container = self.as_assoc_item(db).map(|it| it.container(db));
let mut module = self.module(db);
if let Some(AssocItemContainer::Impl(_)) = container {
// Block-local impls are "hoisted" to the nearest (non-block) module.
module = module.nearest_non_block_module(db);
}
write_visibility(module.id, self.visibility(db), f)?;
let data = db.const_data(self.id);
f.write_str("const ")?;
2021-03-15 11:05:03 -05:00
match &data.name {
Some(name) => write!(f, "{}: ", name.display(f.db.upcast()))?,
None => f.write_str("_: ")?,
2021-03-15 11:05:03 -05:00
}
data.type_ref.hir_fmt(f)?;
Ok(())
}
}
impl HirDisplay for Static {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-03-15 11:05:03 -05:00
write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
let data = f.db.static_data(self.id);
f.write_str("static ")?;
2021-03-15 11:05:03 -05:00
if data.mutable {
f.write_str("mut ")?;
2021-03-15 11:05:03 -05:00
}
write!(f, "{}: ", data.name.display(f.db.upcast()))?;
2021-03-15 11:05:03 -05:00
data.type_ref.hir_fmt(f)?;
Ok(())
}
}
impl HirDisplay for Trait {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-03-15 11:05:03 -05:00
write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
let data = f.db.trait_data(self.id);
if data.is_unsafe {
f.write_str("unsafe ")?;
2021-03-15 11:05:03 -05:00
}
if data.is_auto {
f.write_str("auto ")?;
2021-03-15 11:05:03 -05:00
}
write!(f, "trait {}", data.name.display(f.db.upcast()))?;
2021-03-15 11:05:03 -05:00
let def_id = GenericDefId::TraitId(self.id);
write_generic_params(def_id, f)?;
write_where_clause(def_id, f)?;
Ok(())
}
}
2023-03-03 09:24:07 -06:00
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()))?;
2023-03-03 09:24:07 -06:00
let def_id = GenericDefId::TraitAliasId(self.id);
write_generic_params(def_id, f)?;
f.write_str(" = ")?;
// FIXME: Currently we lower every bounds in a trait alias as a trait bound on `Self` i.e.
// `trait Foo = Bar` is stored and displayed as `trait Foo = where Self: Bar`, which might
// be less readable.
write_where_clause(def_id, f)?;
Ok(())
}
}
2021-03-15 11:05:03 -05:00
impl HirDisplay for TypeAlias {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-03-15 11:05:03 -05:00
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()))?;
let def_id = GenericDefId::TypeAliasId(self.id);
write_generic_params(def_id, f)?;
write_where_clause(def_id, f)?;
2021-03-15 11:05:03 -05:00
if !data.bounds.is_empty() {
f.write_str(": ")?;
2023-11-14 03:08:19 -06:00
f.write_joined(data.bounds.iter(), " + ")?;
2021-03-15 11:05:03 -05:00
}
if let Some(ty) = &data.type_ref {
f.write_str(" = ")?;
2021-03-15 11:05:03 -05:00
ty.hir_fmt(f)?;
}
Ok(())
}
}
impl HirDisplay for Module {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
2021-03-15 11:05:03 -05:00
// FIXME: Module doesn't have visibility saved in data.
match self.name(f.db) {
Some(name) => write!(f, "mod {}", name.display(f.db.upcast())),
2023-06-01 07:46:36 -05:00
None if self.is_crate_root() => match self.krate(f.db).display_name(f.db) {
Some(name) => write!(f, "extern crate {name}"),
None => f.write_str("extern crate {unknown}"),
},
None => f.write_str("mod {unnamed}"),
2021-03-15 11:05:03 -05:00
}
}
}
impl HirDisplay for Macro {
2022-07-20 08:02:08 -05:00
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
match self.id {
hir_def::MacroId::Macro2Id(_) => f.write_str("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()))
}
}