X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=crates%2Fhir_ty%2Fsrc%2Fdisplay.rs;h=2ee4f5cf41bf351508ab8bf3143c1bd1f4bde481;hb=d1fc208c9ceb959d616fa790fca5d282bc8d820d;hp=d1ca50c6909538cb5db9a57b87d47e456e5c502c;hpb=c9c6fa8f56a2b095b5f6b7dc66a4f1db4a9a9a30;p=rust.git diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs index d1ca50c6909..2ee4f5cf41b 100644 --- a/crates/hir_ty/src/display.rs +++ b/crates/hir_ty/src/display.rs @@ -16,10 +16,11 @@ path::{Path, PathKind}, type_ref::{TraitBoundModifier, TypeBound, TypeRef}, visibility::Visibility, - AssocContainerId, HasModule, Lookup, ModuleId, TraitId, + HasModule, ItemContainerId, Lookup, ModuleId, TraitId, }; use hir_expand::{hygiene::Hygiene, name::Name}; use itertools::Itertools; +use syntax::SmolStr; use crate::{ const_from_placeholder_idx, @@ -150,6 +151,12 @@ pub fn write_joined( write!(self, "{}", sep)?; } first = false; + + // Abbreviate multiple omitted types with a single ellipsis. + if self.should_truncate() { + return write!(self, "{}", TYPE_HINT_TRUNCATION); + } + e.hir_fmt(self)?; } Ok(()) @@ -273,11 +280,11 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { let trait_ = f.db.trait_data(self.trait_(f.db)); write!(f, "<")?; - self.self_type_parameter(&Interner).hir_fmt(f)?; + self.self_type_parameter(Interner).hir_fmt(f)?; write!(f, " as {}", trait_.name)?; - if self.substitution.len(&Interner) > 1 { + if self.substitution.len(Interner) > 1 { write!(f, "<")?; - f.write_joined(&self.substitution.as_slice(&Interner)[1..], ", ")?; + f.write_joined(&self.substitution.as_slice(Interner)[1..], ", ")?; write!(f, ">")?; } write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty_id)).name)?; @@ -291,7 +298,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { return write!(f, "{}", TYPE_HINT_TRUNCATION); } - self.substitution.at(&Interner, 0).hir_fmt(f) + self.substitution.at(Interner, 0).hir_fmt(f) } } @@ -334,7 +341,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { return write!(f, "{}", TYPE_HINT_TRUNCATION); } - match self.kind(&Interner) { + match self.kind(Interner) { TyKind::Never => write!(f, "!")?, TyKind::Str => write!(f, "str")?, TyKind::Scalar(Scalar::Bool) => write!(f, "bool")?, @@ -355,7 +362,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { write!(f, "]")?; } TyKind::Raw(m, t) | TyKind::Ref(m, _, t) => { - if matches!(self.kind(&Interner), TyKind::Raw(..)) { + if matches!(self.kind(Interner), TyKind::Raw(..)) { write!( f, "*{}", @@ -386,7 +393,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { } }) }; - let (preds_to_print, has_impl_fn_pred) = match t.kind(&Interner) { + let (preds_to_print, has_impl_fn_pred) = match t.kind(Interner) { TyKind::Dyn(dyn_ty) if dyn_ty.bounds.skip_binders().interned().len() > 1 => { let bounds = dyn_ty.bounds.skip_binders().interned(); (bounds.len(), contains_impl_fn(bounds)) @@ -405,7 +412,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { let data = (*datas) .as_ref() .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); - let bounds = data.substitute(&Interner, parameters); + let bounds = data.substitute(Interner, parameters); let mut len = bounds.skip_binders().len(); // Don't count Sized but count when it absent @@ -455,13 +462,13 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { } } TyKind::Tuple(_, substs) => { - if substs.len(&Interner) == 1 { + if substs.len(Interner) == 1 { write!(f, "(")?; - substs.at(&Interner, 0).hir_fmt(f)?; + substs.at(Interner, 0).hir_fmt(f)?; write!(f, ",)")?; } else { write!(f, "(")?; - f.write_joined(&*substs.as_slice(&Interner), ", ")?; + f.write_joined(&*substs.as_slice(Interner), ", ")?; write!(f, ")")?; } } @@ -471,7 +478,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { } TyKind::FnDef(def, parameters) => { let def = from_chalk(f.db, *def); - let sig = f.db.callable_item_signature(def).substitute(&Interner, parameters); + let sig = f.db.callable_item_signature(def).substitute(Interner, parameters); match def { CallableDefId::FunctionId(ff) => { write!(f, "fn {}", f.db.function_data(ff).name)? @@ -481,7 +488,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { write!(f, "{}", f.db.enum_data(e.parent).variants[e.local_id].name)? } }; - if parameters.len(&Interner) > 0 { + if parameters.len(Interner) > 0 { let generics = generics(f.db.upcast(), def.into()); let (parent_params, self_param, type_params, _impl_trait_params) = generics.provenance_split(); @@ -489,7 +496,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { // We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self? if total_len > 0 { write!(f, "<")?; - f.write_joined(¶meters.as_slice(&Interner)[..total_len], ", ")?; + f.write_joined(¶meters.as_slice(Interner)[..total_len], ", ")?; write!(f, ">")?; } } @@ -527,7 +534,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { } } - if parameters.len(&Interner) > 0 { + if parameters.len(Interner) > 0 { let parameters_to_write = if f.display_target.is_source_code() || f.omit_verbose_types() { @@ -536,39 +543,57 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { .map(|generic_def_id| f.db.generic_defaults(generic_def_id)) .filter(|defaults| !defaults.is_empty()) { - None => parameters.as_slice(&Interner), + None => parameters.as_slice(Interner), Some(default_parameters) => { let mut default_from = 0; - for (i, parameter) in parameters.iter(&Interner).enumerate() { + for (i, parameter) in parameters.iter(Interner).enumerate() { match ( - parameter.assert_ty_ref(&Interner).kind(&Interner), + parameter.assert_ty_ref(Interner).kind(Interner), default_parameters.get(i), ) { (&TyKind::Error, _) | (_, None) => { default_from = i + 1; } (_, Some(default_parameter)) => { - let actual_default = - default_parameter.clone().substitute( - &Interner, - &subst_prefix(parameters, i), - ); - if parameter.assert_ty_ref(&Interner) != &actual_default + let actual_default = default_parameter + .clone() + .substitute(Interner, &subst_prefix(parameters, i)); + if parameter.assert_ty_ref(Interner) != &actual_default { default_from = i + 1; } } } } - ¶meters.as_slice(&Interner)[0..default_from] + ¶meters.as_slice(Interner)[0..default_from] } } } else { - parameters.as_slice(&Interner) + parameters.as_slice(Interner) }; if !parameters_to_write.is_empty() { write!(f, "<")?; - f.write_joined(parameters_to_write, ", ")?; + + if f.display_target.is_source_code() { + let mut first = true; + for generic_arg in parameters_to_write { + if !first { + write!(f, ", ")?; + } + first = false; + + if generic_arg.ty(Interner).map(|ty| ty.kind(Interner)) + == Some(&TyKind::Error) + { + write!(f, "_")?; + } else { + generic_arg.hir_fmt(f)?; + } + } + } else { + f.write_joined(parameters_to_write, ", ")?; + } + write!(f, ">")?; } } @@ -576,7 +601,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { TyKind::AssociatedType(assoc_type_id, parameters) => { let type_alias = from_assoc_type_id(*assoc_type_id); let trait_ = match type_alias.lookup(f.db.upcast()).container { - AssocContainerId::TraitId(it) => it, + ItemContainerId::TraitId(it) => it, _ => panic!("not an associated type"), }; let trait_ = f.db.trait_data(trait_); @@ -585,9 +610,9 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types) if f.display_target.is_test() { write!(f, "{}::{}", trait_.name, type_alias_data.name)?; - if parameters.len(&Interner) > 0 { + if parameters.len(Interner) > 0 { write!(f, "<")?; - f.write_joined(&*parameters.as_slice(&Interner), ", ")?; + f.write_joined(&*parameters.as_slice(Interner), ", ")?; write!(f, ">")?; } } else { @@ -612,7 +637,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { let data = (*datas) .as_ref() .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); - let bounds = data.substitute(&Interner, ¶meters); + let bounds = data.substitute(Interner, ¶meters); let krate = func.lookup(f.db.upcast()).module(f.db.upcast()).krate(); write_bounds_like_dyn_trait_with_prefix( "impl", @@ -624,7 +649,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { } ImplTraitId::AsyncBlockTypeImplTrait(..) => { write!(f, "impl Future")?; } } @@ -635,11 +660,11 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { DisplaySourceCodeError::Closure, )); } - let sig = substs.at(&Interner, 0).assert_ty_ref(&Interner).callable_sig(f.db); + let sig = substs.at(Interner, 0).assert_ty_ref(Interner).callable_sig(f.db); if let Some(sig) = sig { if sig.params().is_empty() { write!(f, "||")?; - } else if f.omit_verbose_types() { + } else if f.should_truncate() { write!(f, "|{}|", TYPE_HINT_TRUNCATION)?; } else { write!(f, "|")?; @@ -666,15 +691,15 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { let bounds = f.db.generic_predicates(id.parent) .iter() - .map(|pred| pred.clone().substitute(&Interner, &substs)) + .map(|pred| pred.clone().substitute(Interner, &substs)) .filter(|wc| match &wc.skip_binders() { WhereClause::Implemented(tr) => { - &tr.self_type_parameter(&Interner) == self + &tr.self_type_parameter(Interner) == self } WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(proj), ty: _, - }) => &proj.self_type_parameter(&Interner) == self, + }) => &proj.self_type_parameter(Interner) == self, _ => false, }) .collect::>(); @@ -707,7 +732,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { let data = (*datas) .as_ref() .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); - let bounds = data.substitute(&Interner, &opaque_ty.substitution); + let bounds = data.substitute(Interner, &opaque_ty.substitution); let krate = func.lookup(f.db.upcast()).module(f.db.upcast()).krate(); write_bounds_like_dyn_trait_with_prefix( "impl", @@ -774,8 +799,9 @@ fn is_sized_trait(self, trait_: TraitId, db: &dyn DefDatabase) -> bool { match self { Self::NotSized => false, Self::Sized { anchor } => { - let sized_trait = - db.lang_item(anchor, "sized".into()).and_then(|lang_item| lang_item.as_trait()); + let sized_trait = db + .lang_item(anchor, SmolStr::new_inline("sized")) + .and_then(|lang_item| lang_item.as_trait()); Some(trait_) == sized_trait } } @@ -839,13 +865,13 @@ fn write_bounds_like_dyn_trait( // existential) here, which is the only thing that's // possible in actual Rust, and hence don't print it write!(f, "{}", f.db.trait_data(trait_).name)?; - if let [_, params @ ..] = &*trait_ref.substitution.as_slice(&Interner) { + if let [_, params @ ..] = &*trait_ref.substitution.as_slice(Interner) { if is_fn_trait { if let Some(args) = - params.first().and_then(|it| it.assert_ty_ref(&Interner).as_tuple()) + params.first().and_then(|it| it.assert_ty_ref(Interner).as_tuple()) { write!(f, "(")?; - f.write_joined(args.as_slice(&Interner), ", ")?; + f.write_joined(args.as_slice(Interner), ", ")?; write!(f, ")")?; } } else if !params.is_empty() { @@ -904,16 +930,16 @@ fn fmt_trait_ref(tr: &TraitRef, f: &mut HirFormatter, use_as: bool) -> Result<() return write!(f, "{}", TYPE_HINT_TRUNCATION); } - tr.self_type_parameter(&Interner).hir_fmt(f)?; + tr.self_type_parameter(Interner).hir_fmt(f)?; if use_as { write!(f, " as ")?; } else { write!(f, ": ")?; } write!(f, "{}", f.db.trait_data(tr.hir_trait_id()).name)?; - if tr.substitution.len(&Interner) > 1 { + if tr.substitution.len(Interner) > 1 { write!(f, "<")?; - f.write_joined(&tr.substitution.as_slice(&Interner)[1..], ", ")?; + f.write_joined(&tr.substitution.as_slice(Interner)[1..], ", ")?; write!(f, ">")?; } Ok(()) @@ -1068,20 +1094,33 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { inner.hir_fmt(f)?; write!(f, "]")?; } - TypeRef::Fn(tys, is_varargs) => { + TypeRef::Fn(parameters, is_varargs) => { // FIXME: Function pointer qualifiers. write!(f, "fn(")?; - f.write_joined(&tys[..tys.len() - 1], ", ")?; + for index in 0..parameters.len() - 1 { + let (param_name, param_type) = ¶meters[index]; + if let Some(name) = param_name { + write!(f, "{}: ", name)?; + } + + param_type.hir_fmt(f)?; + + // Last index contains the return type so we stop writing commas on the second-to-last index + if index != parameters.len() - 2 { + write!(f, ", ")?; + } + } if *is_varargs { - write!(f, "{}...", if tys.len() == 1 { "" } else { ", " })?; + write!(f, "{}...", if parameters.len() == 1 { "" } else { ", " })?; } write!(f, ")")?; - let ret_ty = tys.last().unwrap(); - match ret_ty { - TypeRef::Tuple(tup) if tup.is_empty() => {} - _ => { - write!(f, " -> ")?; - ret_ty.hir_fmt(f)?; + if let Some((_, ret_ty)) = ¶meters.last() { + match ret_ty { + TypeRef::Tuple(tup) if tup.is_empty() => {} + _ => { + write!(f, " -> ")?; + ret_ty.hir_fmt(f)?; + } } } } @@ -1164,10 +1203,23 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { // Do we actually format expressions? if generic_args.desugared_from_fn { // First argument will be a tuple, which already includes the parentheses. - generic_args.args[0].hir_fmt(f)?; + // If the tuple only contains 1 item, write it manually to avoid the trailing `,`. + if let hir_def::path::GenericArg::Type(TypeRef::Tuple(v)) = + &generic_args.args[0] + { + if v.len() == 1 { + write!(f, "(")?; + v[0].hir_fmt(f)?; + write!(f, ")")?; + } else { + generic_args.args[0].hir_fmt(f)?; + } + } if let Some(ret) = &generic_args.bindings[0].type_ref { - write!(f, " -> ")?; - ret.hir_fmt(f)?; + if !matches!(ret, TypeRef::Tuple(v) if v.is_empty()) { + write!(f, " -> ")?; + ret.hir_fmt(f)?; + } } return Ok(()); }