mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

RPITIT placeholder items

Browse source
This commit is contained in:
Michael Goulet 2022-08-31 03:04:44 +00:00
parent c6861df836
commit 78b962a4f3
21 changed files with 70 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
compiler/rustc_hir/src/def.rs
View file

@ -109,6 +109,8 @@ pub enum DefKind {
InlineConst,
/// Opaque type, aka `impl Trait`.
OpaqueTy,
/// A return-position `impl Trait` in a trait definition
ImplTraitPlaceholder,
Field,
/// Lifetime parameter: the `'a` in `struct Foo<'a> { ... }`
LifetimeParam,
@ -138,6 +140,7 @@ impl DefKind {
panic!("impossible struct constructor")
}
DefKind::OpaqueTy => "opaque type",
DefKind::ImplTraitPlaceholder => "opaque type in trait",
DefKind::TyAlias => "type alias",
DefKind::TraitAlias => "trait alias",
DefKind::AssocTy => "associated type",
@ -190,6 +193,7 @@ impl DefKind {
| DefKind::Variant
| DefKind::Trait
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::TyAlias
| DefKind::ForeignTy
| DefKind::TraitAlias
@ -254,6 +258,7 @@ impl DefKind {
| DefKind::Use
| DefKind::ForeignMod
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::Impl
| DefKind::Field
| DefKind::TyParam

11
compiler/rustc_hir/src/hir.rs
View file

@ -2518,6 +2518,12 @@ pub enum OpaqueTyOrigin {
TyAlias,
}
/// Placeholder representation of an `impl Trait` in a trait. Since this never gets lowered into a `ty::Opaque` of its own, we just keep this as
#[derive(Debug, HashStable_Generic)]
pub struct ImplTraitPlaceholder<'hir> {
pub bounds: GenericBounds<'hir>,
}
/// The various kinds of types recognized by the compiler.
#[derive(Debug, HashStable_Generic)]
pub enum TyKind<'hir> {
@ -2545,6 +2551,8 @@ pub enum TyKind<'hir> {
/// The generic argument list contains the lifetimes (and in the future
/// possibly parameters) that are actually bound on the `impl Trait`.
OpaqueDef(ItemId, &'hir [GenericArg<'hir>]),
/// The placeholder
ImplTraitInTrait(ItemId),
/// A trait object type `Bound1 + Bound2 + Bound3`
/// where `Bound` is a trait or a lifetime.
TraitObject(&'hir [PolyTraitRef<'hir>], &'hir Lifetime, TraitObjectSyntax),
@ -3000,6 +3008,8 @@ pub enum ItemKind<'hir> {
TyAlias(&'hir Ty<'hir>, &'hir Generics<'hir>),
/// An opaque `impl Trait` type alias, e.g., `type Foo = impl Bar;`.
OpaqueTy(OpaqueTy<'hir>),
/// An `impl Trait` in a trait
ImplTraitPlaceholder(ImplTraitPlaceholder<'hir>),
/// An enum definition, e.g., `enum Foo<A, B> {C<A>, D<B>}`.
Enum(EnumDef<'hir>, &'hir Generics<'hir>),
/// A struct definition, e.g., `struct Foo<A> {x: A}`.
@ -3068,6 +3078,7 @@ impl ItemKind<'_> {
ItemKind::Trait(..) => "trait",
ItemKind::TraitAlias(..) => "trait alias",
ItemKind::Impl(..) => "implementation",
ItemKind::ImplTraitPlaceholder(..) => "opaque type in trait",
}
}
}

7
compiler/rustc_hir/src/intravisit.rs
View file

@ -562,6 +562,10 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {
walk_generics(visitor, generics);
walk_list!(visitor, visit_param_bound, bounds);
}
ItemKind::ImplTraitPlaceholder(ImplTraitPlaceholder { bounds }) => {
visitor.visit_id(item.hir_id());
walk_list!(visitor, visit_param_bound, bounds);
}
ItemKind::Enum(ref enum_definition, ref generics) => {
visitor.visit_generics(generics);
// `visit_enum_def()` takes care of visiting the `Item`'s `HirId`.
@ -674,6 +678,9 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) {
visitor.visit_nested_item(item_id);
walk_list!(visitor, visit_generic_arg, lifetimes);
}
TyKind::ImplTraitInTrait(item_id) => {
visitor.visit_nested_item(item_id);
}
TyKind::Array(ref ty, ref length) => {
visitor.visit_ty(ty);
visitor.visit_array_length(length)

3
compiler/rustc_hir/src/target.rs
View file

@ -36,6 +36,7 @@ pub enum Target {
GlobalAsm,
TyAlias,
OpaqueTy,
ImplTraitPlaceholder,
Enum,
Variant,
Struct,
@ -80,6 +81,7 @@ impl Target {
ItemKind::GlobalAsm(..) => Target::GlobalAsm,
ItemKind::TyAlias(..) => Target::TyAlias,
ItemKind::OpaqueTy(..) => Target::OpaqueTy,
ItemKind::ImplTraitPlaceholder(..) => Target::ImplTraitPlaceholder,
ItemKind::Enum(..) => Target::Enum,
ItemKind::Struct(..) => Target::Struct,
ItemKind::Union(..) => Target::Union,
@ -157,6 +159,7 @@ impl Target {
Target::GlobalAsm => "global asm",
Target::TyAlias => "type alias",
Target::OpaqueTy => "opaque type",
Target::ImplTraitPlaceholder => "opaque type in trait",
Target::Enum => "enum",
Target::Variant => "enum variant",
Target::Struct => "struct",

4
compiler/rustc_hir_pretty/src/lib.rs
View file

@ -327,6 +327,7 @@ impl<'a> State<'a> {
self.print_ty_fn(f.abi, f.unsafety, f.decl, None, f.generic_params, f.param_names);
}
hir::TyKind::OpaqueDef(..) => self.word("/*impl Trait*/"),
hir::TyKind::ImplTraitInTrait(..) => self.word("/*impl Trait*/"),
hir::TyKind::Path(ref qpath) => self.print_qpath(qpath, false),
hir::TyKind::TraitObject(bounds, ref lifetime, syntax) => {
if syntax == ast::TraitObjectSyntax::Dyn {
@ -608,6 +609,9 @@ impl<'a> State<'a> {
state.print_bounds("= impl", real_bounds);
});
}
hir::ItemKind::ImplTraitPlaceholder(..) => {
unreachable!("FIXME(RPITIT): I don't think this ever gets called here...");
}
hir::ItemKind::Enum(ref enum_definition, params) => {
self.print_enum_def(enum_definition, params, item.ident.name, item.span);
}

5
compiler/rustc_metadata/src/rmeta/encoder.rs
View file

@ -847,6 +847,7 @@ fn should_encode_visibility(def_kind: DefKind) -> bool {
| DefKind::Use
| DefKind::ForeignMod
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::Impl
| DefKind::Field => true,
DefKind::TyParam
@ -879,6 +880,7 @@ fn should_encode_stability(def_kind: DefKind) -> bool {
| DefKind::ForeignMod
| DefKind::TyAlias
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::Enum
| DefKind::Union
| DefKind::Impl
@ -967,6 +969,7 @@ fn should_encode_variances(def_kind: DefKind) -> bool {
| DefKind::ForeignMod
| DefKind::TyAlias
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::Impl
| DefKind::Trait
| DefKind::TraitAlias
@ -1003,6 +1006,7 @@ fn should_encode_generics(def_kind: DefKind) -> bool {
| DefKind::AnonConst
| DefKind::InlineConst
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::Impl
| DefKind::Field
| DefKind::TyParam
@ -1493,6 +1497,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
}
hir::ItemKind::OpaqueTy(..) => {
self.encode_explicit_item_bounds(def_id);
EntryKind::OpaqueTy
}
hir::ItemKind::Enum(..) => {
let adt_def = self.tcx.adt_def(def_id);

1
compiler/rustc_metadata/src/rmeta/table.rs
View file

@ -90,6 +90,7 @@ fixed_size_enum! {
( AnonConst )
( InlineConst )
( OpaqueTy )
( ImplTraitPlaceholder )
( Field )
( LifetimeParam )
( GlobalAsm )

2
compiler/rustc_middle/src/hir/map/mod.rs
View file

@ -213,6 +213,7 @@ impl<'hir> Map<'hir> {
ItemKind::Macro(_, macro_kind) => DefKind::Macro(macro_kind),
ItemKind::Mod(..) => DefKind::Mod,
ItemKind::OpaqueTy(..) => DefKind::OpaqueTy,
ItemKind::ImplTraitPlaceholder(..) => DefKind::ImplTraitPlaceholder,
ItemKind::TyAlias(..) => DefKind::TyAlias,
ItemKind::Enum(..) => DefKind::Enum,
ItemKind::Struct(..) => DefKind::Struct,
@ -1188,6 +1189,7 @@ fn hir_id_to_string(map: Map<'_>, id: HirId) -> String {
ItemKind::GlobalAsm(..) => "global asm",
ItemKind::TyAlias(..) => "ty",
ItemKind::OpaqueTy(..) => "opaque type",
ItemKind::ImplTraitPlaceholder(..) => "opaque type in trait",
ItemKind::Enum(..) => "enum",
ItemKind::Struct(..) => "struct",
ItemKind::Union(..) => "union",

1
compiler/rustc_monomorphize/src/polymorphize.rs
View file

@ -170,6 +170,7 @@ fn mark_used_by_default_parameters<'tcx>(
| DefKind::AnonConst
| DefKind::InlineConst
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::Field
| DefKind::LifetimeParam
| DefKind::GlobalAsm

1
compiler/rustc_passes/src/check_attr.rs
View file

@ -661,6 +661,7 @@ impl CheckAttrVisitor<'_> {
| Target::GlobalAsm
| Target::TyAlias
| Target::OpaqueTy
| Target::ImplTraitPlaceholder
| Target::Enum
| Target::Variant
| Target::Struct

1
compiler/rustc_passes/src/reachable.rs
View file

@ -235,6 +235,7 @@ impl<'tcx> ReachableContext<'tcx> {
hir::ItemKind::ExternCrate(_)
| hir::ItemKind::Use(..)
| hir::ItemKind::OpaqueTy(..)
| hir::ItemKind::ImplTraitPlaceholder(..)
| hir::ItemKind::TyAlias(..)
| hir::ItemKind::Macro(..)
| hir::ItemKind::Mod(..)

5
compiler/rustc_privacy/src/lib.rs
View file

@ -596,6 +596,7 @@ impl<'tcx> EmbargoVisitor<'tcx> {
| DefKind::ForeignTy
| DefKind::Fn
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::AssocFn
| DefKind::Trait
| DefKind::TyParam
@ -685,6 +686,7 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
}
hir::ItemKind::OpaqueTy(..)
| hir::ItemKind::ImplTraitPlaceholder(..)
| hir::ItemKind::Use(..)
| hir::ItemKind::Static(..)
| hir::ItemKind::Const(..)
@ -720,6 +722,9 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
self.reach(item.def_id, exist_level).generics().predicates().ty();
}
}
hir::ItemKind::ImplTraitPlaceholder(..) => {
// FIXME(RPITIT): Do we need to do anything here?
}
// Visit everything.
hir::ItemKind::Const(..)
| hir::ItemKind::Static(..)

1
compiler/rustc_resolve/src/build_reduced_graph.rs
View file

@ -972,6 +972,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
| DefKind::TyAlias
| DefKind::ForeignTy
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::TraitAlias
| DefKind::AssocTy,
_,

3
compiler/rustc_resolve/src/late/lifetimes.rs
View file

@ -596,6 +596,9 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
}
}
}
hir::ItemKind::ImplTraitPlaceholder(..) => {
// FIXME(RPITIT): We don't need to do anything here, right?
}
hir::ItemKind::TyAlias(_, ref generics)
| hir::ItemKind::Enum(_, ref generics)
| hir::ItemKind::Struct(_, ref generics)

1
compiler/rustc_save_analysis/src/lib.rs
View file

@ -685,6 +685,7 @@ impl<'tcx> SaveContext<'tcx> {
| HirDefKind::AssocTy
| HirDefKind::Trait
| HirDefKind::OpaqueTy
| HirDefKind::ImplTraitPlaceholder
| HirDefKind::TyParam,
def_id,
) => Some(Ref { kind: RefKind::Type, span, ref_id: id_from_def_id(def_id) }),

5
compiler/rustc_save_analysis/src/sig.rs
View file

@ -320,6 +320,10 @@ impl<'hir> Sig for hir::Ty<'hir> {
let item = scx.tcx.hir().item(item_id);
item.make(offset, Some(item_id.hir_id()), scx)
}
hir::TyKind::ImplTraitInTrait(item_id) => {
let item = scx.tcx.hir().item(item_id);
item.make(offset, Some(item_id.hir_id()), scx)
}
hir::TyKind::Typeof(_) | hir::TyKind::Infer | hir::TyKind::Err => Err("Ty"),
}
}
@ -562,6 +566,7 @@ impl<'hir> Sig for hir::Item<'hir> {
hir::ItemKind::GlobalAsm(_) => Err("global asm"),
hir::ItemKind::ExternCrate(_) => Err("extern crate"),
hir::ItemKind::OpaqueTy(..) => Err("opaque type"),
hir::ItemKind::ImplTraitPlaceholder(..) => Err("opaque type in trait"),
// FIXME should implement this (e.g., pub use).
hir::ItemKind::Use(..) => Err("import"),
}

1
compiler/rustc_ty_utils/src/implied_bounds.rs
View file

@ -51,6 +51,7 @@ fn assumed_wf_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::List<Ty
| DefKind::AnonConst
| DefKind::InlineConst
| DefKind::OpaqueTy
| DefKind::ImplTraitPlaceholder
| DefKind::Field
| DefKind::LifetimeParam
| DefKind::GlobalAsm

3
compiler/rustc_typeck/src/astconv/mod.rs
View file

@ -2638,6 +2638,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
ref i => bug!("`impl Trait` pointed to non-opaque type?? {:#?}", i),
}
}
hir::TyKind::ImplTraitInTrait(..) => {
span_bug!(ast_ty.span, "not yet implemented")
}
hir::TyKind::Path(hir::QPath::TypeRelative(ref qself, ref segment)) => {
debug!(?qself, ?segment);
let ty = self.ast_ty_to_ty_inner(qself, false, true);

5
compiler/rustc_typeck/src/collect.rs
View file

@ -815,6 +815,11 @@ fn convert_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
tcx.ensure().predicates_of(def_id);
tcx.ensure().explicit_item_bounds(def_id);
}
hir::ItemKind::ImplTraitPlaceholder(..) => {
tcx.ensure().generics_of(def_id);
tcx.ensure().predicates_of(def_id);
tcx.ensure().explicit_item_bounds(def_id);
}
hir::ItemKind::TyAlias(..)
| hir::ItemKind::Static(..)
| hir::ItemKind::Const(..)

3
compiler/rustc_typeck/src/collect/type_of.rs
View file

@ -336,6 +336,9 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
ItemKind::OpaqueTy(OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn(owner) | hir::OpaqueTyOrigin::AsyncFn(owner), .. }) => {
find_opaque_ty_constraints_for_rpit(tcx, def_id, owner)
}
ItemKind::ImplTraitPlaceholder(..) => {
span_bug!(item.span, "not yet implemented")
}
ItemKind::Trait(..)
| ItemKind::TraitAlias(..)
| ItemKind::Macro(..)

4
src/librustdoc/clean/utils.rs
View file

@ -511,8 +511,8 @@ pub(crate) fn register_res(cx: &mut DocContext<'_>, res: Res) -> DefId {
| Res::Err => return res.def_id(),
Res::Def(
TyParam | ConstParam | Ctor(..) | ExternCrate | Use | ForeignMod | AnonConst
| InlineConst | OpaqueTy | Field | LifetimeParam | GlobalAsm | Impl | Closure
| Generator,
| InlineConst | OpaqueTy | ImplTraitPlaceholder | Field | LifetimeParam | GlobalAsm
| Impl | Closure | Generator,
id,
) => return id,
};