write!(f, "<{} as {}", first_parameter, trait_.name)?;
if self.substitution.len(&Interner) > 1 {
write!(f, "<")?;
- f.write_joined(&self.substitution.interned(&Interner)[1..], ", ")?;
+ f.write_joined(&self.substitution.interned()[1..], ", ")?;
write!(f, ">")?;
}
write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty_id)).name)?;
write!(f, ",)")?;
} else {
write!(f, "(")?;
- f.write_joined(&*substs.0, ", ")?;
+ f.write_joined(&*substs.interned(), ", ")?;
write!(f, ")")?;
}
}
// 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.0[..total_len], ", ")?;
+ f.write_joined(¶meters.interned()[..total_len], ", ")?;
write!(f, ">")?;
}
}
.map(|generic_def_id| f.db.generic_defaults(generic_def_id))
.filter(|defaults| !defaults.is_empty())
{
- None => parameters.0.as_ref(),
+ None => parameters.interned().as_ref(),
Some(default_parameters) => {
let mut default_from = 0;
for (i, parameter) in parameters.iter(&Interner).enumerate() {
parameter.assert_ty_ref(&Interner).kind(&Interner),
default_parameters.get(i),
) {
- (&TyKind::Unknown, _) | (_, None) => {
+ (&TyKind::Error, _) | (_, None) => {
default_from = i + 1;
}
(_, Some(default_parameter)) => {
}
}
}
- ¶meters.0[0..default_from]
+ ¶meters.interned()[0..default_from]
}
}
} else {
- parameters.0.as_ref()
+ parameters.interned().as_ref()
};
if !parameters_to_write.is_empty() {
write!(f, "<")?;
write!(f, "{}::{}", trait_.name, type_alias_data.name)?;
if parameters.len(&Interner) > 0 {
write!(f, "<")?;
- f.write_joined(&*parameters.0, ", ")?;
+ f.write_joined(&*parameters.interned(), ", ")?;
write!(f, ">")?;
}
} else {
projection_ty.hir_fmt(f)?;
}
}
- TyKind::ForeignType(type_alias) => {
+ TyKind::Foreign(type_alias) => {
let type_alias = f.db.type_alias_data(from_foreign_def_id(*type_alias));
write!(f, "{}", type_alias.name)?;
}
}
};
}
- TyKind::Unknown => {
+ TyKind::Error => {
if f.display_target.is_source_code() {
return Err(HirDisplayError::DisplaySourceCodeError(
DisplaySourceCodeError::UnknownType,
// 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.0 {
+ if let [_, params @ ..] = &*trait_ref.substitution.interned() {
if is_fn_trait {
if let Some(args) =
params.first().and_then(|it| it.assert_ty_ref(&Interner).as_tuple())
{
write!(f, "(")?;
- f.write_joined(&*args.0, ", ")?;
+ f.write_joined(&*args.interned(), ", ")?;
write!(f, ")")?;
}
} else if !params.is_empty() {
write!(f, "{}", f.db.trait_data(self.hir_trait_id()).name)?;
if self.substitution.len(&Interner) > 1 {
write!(f, "<")?;
- f.write_joined(&self.substitution.interned(&Interner)[1..], ", ")?;
+ f.write_joined(&self.substitution.interned()[1..], ", ")?;
write!(f, ">")?;
}
Ok(())