mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #130485 - compiler-errors:impossible-types, r=BoxyUwU

Browse Source 
Do not expect infer/bound/placeholder/error in v0 symbol mangling

Infer/bound/placeholder/error are not encounterable during codegen. Let's make sure v0 symbol mangling doesn't "accidentally" handle them.

As for aliases (namely: projections and uv consts) these may still be encounterable because of the way that we render the def paths of items. Specifically, when we have something like:

```
struct W<T>(T);

impl<T> W<T> {
    fn x() {
        fn y() {}
    }
}
```

The path of `y` is rendered like `crate_name::W<T>:❌:y`. Specifically, since `y` doesn't inherit the generics of the impl, we use the *identity* substitutions for that impl. If the impl has any aliases, they will remain unnormalized if they're rigid.

r? `@BoxyUwU`
This commit is contained in:
Matthias Krüger 2024-09-20 06:43:38 +02:00 committed by GitHub
commit b963750b6b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 30 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
compiler/rustc_symbol_mangling/src/v0.rs
View File

@ -330,8 +330,12 @@ fn print_type(&mut self, ty: Ty<'tcx>) -> Result<(), PrintError> {
ty::Float(FloatTy::F128) => "C4f128",
ty::Never => "z",
// Placeholders (should be demangled as `_`).
ty::Param(_) | ty::Bound(..) | ty::Placeholder(_) | ty::Infer(_) | ty::Error(_) => "p",
// Should only be encountered with polymorphization,
// or within the identity-substituted impl header of an
// item nested within an impl item.
ty::Param(_) => "p",
ty::Bound(..) | ty::Placeholder(_) | ty::Infer(_) | ty::Error(_) => bug!(),
_ => "",
};
@ -416,12 +420,18 @@ fn print_type(&mut self, ty: Ty<'tcx>) -> Result<(), PrintError> {
// Mangle all nominal types as paths.
ty::Adt(ty::AdtDef(Interned(&ty::AdtDefData { did: def_id, .. }, _)), args)
| ty::FnDef(def_id, args)
| ty::Alias(ty::Projection | ty::Opaque, ty::AliasTy { def_id, args, .. })
| ty::Closure(def_id, args)
| ty::CoroutineClosure(def_id, args)
| ty::Coroutine(def_id, args) => {
self.print_def_path(def_id, args)?;
}
// We may still encounter projections here due to the printing
// logic sometimes passing identity-substituted impl headers.
ty::Alias(ty::Projection, ty::AliasTy { def_id, args, .. }) => {
self.print_def_path(def_id, args)?;
}
ty::Foreign(def_id) => {
self.print_def_path(def_id, &[])?;
}
@ -467,8 +477,7 @@ fn print_type(&mut self, ty: Ty<'tcx>) -> Result<(), PrintError> {
r.print(self)?;
}
ty::Alias(ty::Inherent, _) => bug!("symbol_names: unexpected inherent projection"),
ty::Alias(ty::Weak, _) => bug!("symbol_names: unexpected weak projection"),
ty::Alias(..) => bug!("symbol_names: unexpected alias"),
ty::CoroutineWitness(..) => bug!("symbol_names: unexpected `CoroutineWitness`"),
}
@ -550,21 +559,26 @@ fn print_const(&mut self, ct: ty::Const<'tcx>) -> Result<(), PrintError> {
let (ct_ty, valtree) = match ct.kind() {
ty::ConstKind::Value(ty, val) => (ty, val),
// Placeholders (should be demangled as `_`).
// NOTE(eddyb) despite `Unevaluated` having a `DefId` (and therefore
// a path), even for it we still need to encode a placeholder, as
// the path could refer back to e.g. an `impl` using the constant.
ty::ConstKind::Unevaluated(_)
| ty::ConstKind::Expr(_)
| ty::ConstKind::Param(_)
| ty::ConstKind::Infer(_)
| ty::ConstKind::Bound(..)
| ty::ConstKind::Placeholder(_)
| ty::ConstKind::Error(_) => {
// Should only be encountered with polymorphization,
// or within the identity-substituted impl header of an
// item nested within an impl item.
ty::ConstKind::Param(_) => {
// Never cached (single-character).
self.push("p");
return Ok(());
}
// We may still encounter unevaluated consts due to the printing
// logic sometimes passing identity-substituted impl headers.
ty::Unevaluated(ty::UnevaluatedConst { def, args, .. }) => {
return self.print_def_path(def, args);
}
ty::ConstKind::Expr(_)
| ty::ConstKind::Infer(_)
| ty::ConstKind::Bound(..)
| ty::ConstKind::Placeholder(_)
| ty::ConstKind::Error(_) => bug!(),
};
if let Some(&i) = self.consts.get(&ct) {