From 4201fd273e242a9fecf78d04d5743fe4116e2f59 Mon Sep 17 00:00:00 2001 From: Matthew Jasper Date: Sun, 10 May 2020 12:15:51 +0100 Subject: [PATCH] Remove associated opaque types They're unused now. --- src/librustc_hir/def.rs | 8 +- src/librustc_hir/hir.rs | 7 +- src/librustc_hir/intravisit.rs | 4 - src/librustc_hir_pretty/lib.rs | 6 - .../persist/dirty_clean.rs | 1 - .../infer/error_reporting/mod.rs | 4 +- src/librustc_metadata/rmeta/decoder.rs | 2 - src/librustc_metadata/rmeta/encoder.rs | 7 +- src/librustc_metadata/rmeta/mod.rs | 1 - src/librustc_middle/hir/map/mod.rs | 4 - .../traits/specialization_graph.rs | 17 +- src/librustc_middle/ty/error.rs | 4 +- src/librustc_middle/ty/mod.rs | 20 +-- src/librustc_passes/check_attr.rs | 2 +- src/librustc_passes/dead.rs | 2 +- src/librustc_passes/reachable.rs | 4 +- src/librustc_privacy/lib.rs | 14 +- src/librustc_resolve/build_reduced_graph.rs | 3 +- src/librustc_resolve/late/lifetimes.rs | 37 ---- src/librustc_save_analysis/dump_visitor.rs | 1 - src/librustc_save_analysis/lib.rs | 1 - src/librustc_trait_selection/opaque_types.rs | 17 +- .../traits/project.rs | 11 +- src/librustc_ty/ty.rs | 2 - src/librustc_typeck/check/compare_method.rs | 2 +- src/librustc_typeck/check/method/probe.rs | 2 +- src/librustc_typeck/check/method/suggest.rs | 4 +- src/librustc_typeck/check/mod.rs | 5 +- src/librustc_typeck/check/wfcheck.rs | 167 +++++++++--------- src/librustc_typeck/collect.rs | 32 +--- src/librustc_typeck/collect/type_of.rs | 7 - src/librustc_typeck/impl_wf_check.rs | 7 - src/librustdoc/clean/mod.rs | 5 - .../clippy/clippy_lints/src/lifetimes.rs | 2 +- .../clippy_lints/src/manual_async_fn.rs | 2 +- .../clippy_lints/src/utils/hir_utils.rs | 2 +- 36 files changed, 116 insertions(+), 300 deletions(-) diff --git a/src/librustc_hir/def.rs b/src/librustc_hir/def.rs index 88049f85f45e4..af1860ca6bfea 100644 --- a/src/librustc_hir/def.rs +++ b/src/librustc_hir/def.rs @@ -54,15 +54,11 @@ pub enum DefKind { /// Refers to the variant itself, `DefKind::Ctor` refers to its constructor if it exists. Variant, Trait, - /// `type Foo = impl Bar;` - OpaqueTy, /// `type Foo = Bar;` TyAlias, ForeignTy, TraitAlias, AssocTy, - /// `type Foo = impl Bar;` - AssocOpaqueTy, TyParam, // Value namespace @@ -83,6 +79,7 @@ pub enum DefKind { Use, ForeignMod, AnonConst, + OpaqueTy, Field, LifetimeParam, GlobalAsm, @@ -115,7 +112,6 @@ impl DefKind { DefKind::TyAlias => "type alias", DefKind::TraitAlias => "trait alias", DefKind::AssocTy => "associated type", - DefKind::AssocOpaqueTy => "associated opaque type", DefKind::Union => "union", DefKind::Trait => "trait", DefKind::ForeignTy => "foreign type", @@ -143,7 +139,6 @@ impl DefKind { match *self { DefKind::AssocTy | DefKind::AssocConst - | DefKind::AssocOpaqueTy | DefKind::AssocFn | DefKind::Enum | DefKind::OpaqueTy @@ -168,7 +163,6 @@ impl DefKind { | DefKind::ForeignTy | DefKind::TraitAlias | DefKind::AssocTy - | DefKind::AssocOpaqueTy | DefKind::TyParam => ns == Namespace::TypeNS, DefKind::Fn diff --git a/src/librustc_hir/hir.rs b/src/librustc_hir/hir.rs index 1e305c6d32d6a..122b8f2ac1612 100644 --- a/src/librustc_hir/hir.rs +++ b/src/librustc_hir/hir.rs @@ -1919,14 +1919,12 @@ pub enum ImplItemKind<'hir> { Fn(FnSig<'hir>, BodyId), /// An associated type. TyAlias(&'hir Ty<'hir>), - /// An associated `type = impl Trait`. - OpaqueTy(GenericBounds<'hir>), } impl ImplItemKind<'_> { pub fn namespace(&self) -> Namespace { match self { - ImplItemKind::OpaqueTy(..) | ImplItemKind::TyAlias(..) => Namespace::TypeNS, + ImplItemKind::TyAlias(..) => Namespace::TypeNS, ImplItemKind::Const(..) | ImplItemKind::Fn(..) => Namespace::ValueNS, } } @@ -2016,8 +2014,6 @@ pub struct OpaqueTy<'hir> { /// From whence the opaque type came. #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] pub enum OpaqueTyOrigin { - /// `type Foo = impl Trait;` - TypeAlias, /// `-> impl Trait` FnReturn, /// `async fn` @@ -2614,7 +2610,6 @@ pub enum AssocItemKind { Const, Fn { has_self: bool }, Type, - OpaqueTy, } #[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] diff --git a/src/librustc_hir/intravisit.rs b/src/librustc_hir/intravisit.rs index 97601a3e1ac7b..8d7bba7dbd578 100644 --- a/src/librustc_hir/intravisit.rs +++ b/src/librustc_hir/intravisit.rs @@ -1007,10 +1007,6 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt visitor.visit_id(impl_item.hir_id); visitor.visit_ty(ty); } - ImplItemKind::OpaqueTy(bounds) => { - visitor.visit_id(impl_item.hir_id); - walk_list!(visitor, visit_param_bound, bounds); - } } } diff --git a/src/librustc_hir_pretty/lib.rs b/src/librustc_hir_pretty/lib.rs index ad22eaf7f10e3..8b2a346b1fc38 100644 --- a/src/librustc_hir_pretty/lib.rs +++ b/src/librustc_hir_pretty/lib.rs @@ -1003,12 +1003,6 @@ impl<'a> State<'a> { hir::ImplItemKind::TyAlias(ref ty) => { self.print_associated_type(ii.ident, &ii.generics, None, Some(ty)); } - hir::ImplItemKind::OpaqueTy(bounds) => { - self.word_space("type"); - self.print_ident(ii.ident); - self.print_bounds("= impl", bounds); - self.s.word(";"); - } } self.ann.post(self, AnnNode::SubItem(ii.hir_id)) } diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index 9bf992537dfaf..2ee95174dffe6 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -336,7 +336,6 @@ impl DirtyCleanVisitor<'tcx> { ImplItemKind::Fn(..) => ("Node::ImplItem", LABELS_FN_IN_IMPL), ImplItemKind::Const(..) => ("NodeImplConst", LABELS_CONST_IN_IMPL), ImplItemKind::TyAlias(..) => ("NodeImplType", LABELS_CONST_IN_IMPL), - ImplItemKind::OpaqueTy(..) => ("NodeImplType", LABELS_CONST_IN_IMPL), }, _ => self.tcx.sess.span_fatal( attr.span, diff --git a/src/librustc_infer/infer/error_reporting/mod.rs b/src/librustc_infer/infer/error_reporting/mod.rs index a59a91e3005aa..12f7a9c0ca502 100644 --- a/src/librustc_infer/infer/error_reporting/mod.rs +++ b/src/librustc_infer/infer/error_reporting/mod.rs @@ -224,9 +224,7 @@ fn trait_item_scope_tag(item: &hir::TraitItem<'_>) -> &'static str { fn impl_item_scope_tag(item: &hir::ImplItem<'_>) -> &'static str { match item.kind { hir::ImplItemKind::Fn(..) => "method body", - hir::ImplItemKind::Const(..) - | hir::ImplItemKind::OpaqueTy(..) - | hir::ImplItemKind::TyAlias(..) => "associated item", + hir::ImplItemKind::Const(..) | hir::ImplItemKind::TyAlias(..) => "associated item", } } diff --git a/src/librustc_metadata/rmeta/decoder.rs b/src/librustc_metadata/rmeta/decoder.rs index f5a9dceb78295..44944a9fb265a 100644 --- a/src/librustc_metadata/rmeta/decoder.rs +++ b/src/librustc_metadata/rmeta/decoder.rs @@ -579,7 +579,6 @@ impl EntryKind { EntryKind::ConstParam => DefKind::ConstParam, EntryKind::OpaqueTy => DefKind::OpaqueTy, EntryKind::AssocType(_) => DefKind::AssocTy, - EntryKind::AssocOpaqueTy(_) => DefKind::AssocOpaqueTy, EntryKind::Mod(_) => DefKind::Mod, EntryKind::Variant(_) => DefKind::Variant, EntryKind::Trait(_) => DefKind::Trait, @@ -1145,7 +1144,6 @@ impl<'a, 'tcx> CrateMetadataRef<'a> { (ty::AssocKind::Fn, data.container, data.has_self) } EntryKind::AssocType(container) => (ty::AssocKind::Type, container, false), - EntryKind::AssocOpaqueTy(container) => (ty::AssocKind::OpaqueTy, container, false), _ => bug!("cannot get associated-item of `{:?}`", def_key), }; diff --git a/src/librustc_metadata/rmeta/encoder.rs b/src/librustc_metadata/rmeta/encoder.rs index 64ccd46a744f5..1dc22c10c8e7a 100644 --- a/src/librustc_metadata/rmeta/encoder.rs +++ b/src/librustc_metadata/rmeta/encoder.rs @@ -874,7 +874,6 @@ impl EncodeContext<'tcx> { })) } ty::AssocKind::Type => EntryKind::AssocType(container), - ty::AssocKind::OpaqueTy => span_bug!(ast_item.span, "opaque type in trait"), }); record!(self.tables.visibility[def_id] <- trait_item.vis); record!(self.tables.span[def_id] <- ast_item.span); @@ -892,7 +891,6 @@ impl EncodeContext<'tcx> { self.encode_item_type(def_id); } } - ty::AssocKind::OpaqueTy => unreachable!(), } if trait_item.kind == ty::AssocKind::Fn { record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id)); @@ -957,7 +955,6 @@ impl EncodeContext<'tcx> { has_self: impl_item.fn_has_self_parameter, })) } - ty::AssocKind::OpaqueTy => EntryKind::AssocOpaqueTy(container), ty::AssocKind::Type => EntryKind::AssocType(container) }); record!(self.tables.visibility[def_id] <- impl_item.vis); @@ -989,7 +986,7 @@ impl EncodeContext<'tcx> { let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir; needs_inline || is_const_fn || always_encode_mir } - hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(..) => false, + hir::ImplItemKind::TyAlias(..) => false, }; if mir { self.encode_optimized_mir(def_id.expect_local()); @@ -1786,7 +1783,7 @@ impl<'tcx, 'v> ParItemLikeVisitor<'v> for PrefetchVisitor<'tcx> { self.prefetch_mir(def_id) } } - hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(..) => (), + hir::ImplItemKind::TyAlias(..) => (), } } } diff --git a/src/librustc_metadata/rmeta/mod.rs b/src/librustc_metadata/rmeta/mod.rs index 89d525eb80b8c..626a436b40060 100644 --- a/src/librustc_metadata/rmeta/mod.rs +++ b/src/librustc_metadata/rmeta/mod.rs @@ -308,7 +308,6 @@ enum EntryKind { Impl(Lazy), AssocFn(Lazy), AssocType(AssocContainer), - AssocOpaqueTy(AssocContainer), AssocConst(AssocContainer, mir::ConstQualifs, Lazy), TraitAlias, } diff --git a/src/librustc_middle/hir/map/mod.rs b/src/librustc_middle/hir/map/mod.rs index e8e92646bf46a..d1cfc4867a2fe 100644 --- a/src/librustc_middle/hir/map/mod.rs +++ b/src/librustc_middle/hir/map/mod.rs @@ -228,7 +228,6 @@ impl<'hir> Map<'hir> { ImplItemKind::Const(..) => DefKind::AssocConst, ImplItemKind::Fn(..) => DefKind::AssocFn, ImplItemKind::TyAlias(..) => DefKind::AssocTy, - ImplItemKind::OpaqueTy(..) => DefKind::AssocOpaqueTy, }, Node::Variant(_) => DefKind::Variant, Node::Ctor(variant_data) => { @@ -1023,9 +1022,6 @@ fn hir_id_to_string(map: &Map<'_>, id: HirId) -> String { ImplItemKind::TyAlias(_) => { format!("assoc type {} in {}{}", ii.ident, path_str(), id_str) } - ImplItemKind::OpaqueTy(_) => { - format!("assoc opaque type {} in {}{}", ii.ident, path_str(), id_str) - } }, Some(Node::TraitItem(ti)) => { let kind = match ti.kind { diff --git a/src/librustc_middle/traits/specialization_graph.rs b/src/librustc_middle/traits/specialization_graph.rs index 4f02aaa96acd3..f4961617b81c6 100644 --- a/src/librustc_middle/traits/specialization_graph.rs +++ b/src/librustc_middle/traits/specialization_graph.rs @@ -100,24 +100,11 @@ impl<'tcx> Node { trait_item_kind: ty::AssocKind, trait_def_id: DefId, ) -> Option { - use crate::ty::AssocKind::*; - tcx.associated_items(self.def_id()) .filter_by_name_unhygienic(trait_item_name.name) .find(move |impl_item| { - match (trait_item_kind, impl_item.kind) { - | (Const, Const) - | (Fn, Fn) - | (Type, Type) - | (Type, OpaqueTy) // assoc. types can be made opaque in impls - => tcx.hygienic_eq(impl_item.ident, trait_item_name, trait_def_id), - - | (Const, _) - | (Fn, _) - | (Type, _) - | (OpaqueTy, _) - => false, - } + trait_item_kind == impl_item.kind + && tcx.hygienic_eq(impl_item.ident, trait_item_name, trait_def_id) }) .copied() } diff --git a/src/librustc_middle/ty/error.rs b/src/librustc_middle/ty/error.rs index 480420dfdcf5e..be3bf748225b9 100644 --- a/src/librustc_middle/ty/error.rs +++ b/src/librustc_middle/ty/error.rs @@ -814,7 +814,7 @@ fn foo(&self) -> Self::T { String::new() } // FIXME: account for `#![feature(specialization)]` for item in &items[..] { match item.kind { - hir::AssocItemKind::Type | hir::AssocItemKind::OpaqueTy => { + hir::AssocItemKind::Type => { // FIXME: account for returning some type in a trait fn impl that has // an assoc type as a return type (#72076). if let hir::Defaultness::Default { has_value: true } = item.defaultness @@ -838,7 +838,7 @@ fn foo(&self) -> Self::T { String::new() } })) => { for item in &items[..] { match item.kind { - hir::AssocItemKind::Type | hir::AssocItemKind::OpaqueTy => { + hir::AssocItemKind::Type => { if self.type_of(self.hir().local_def_id(item.id.hir_id)) == found { db.span_label(item.span, "expected this associated type"); return true; diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs index caa1b4cb375fe..93ef73171993c 100644 --- a/src/librustc_middle/ty/mod.rs +++ b/src/librustc_middle/ty/mod.rs @@ -198,14 +198,13 @@ pub struct AssocItem { pub enum AssocKind { Const, Fn, - OpaqueTy, Type, } impl AssocKind { pub fn namespace(&self) -> Namespace { match *self { - ty::AssocKind::OpaqueTy | ty::AssocKind::Type => Namespace::TypeNS, + ty::AssocKind::Type => Namespace::TypeNS, ty::AssocKind::Const | ty::AssocKind::Fn => Namespace::ValueNS, } } @@ -215,22 +214,11 @@ impl AssocKind { AssocKind::Const => DefKind::AssocConst, AssocKind::Fn => DefKind::AssocFn, AssocKind::Type => DefKind::AssocTy, - AssocKind::OpaqueTy => DefKind::AssocOpaqueTy, } } } impl AssocItem { - /// Tests whether the associated item admits a non-trivial implementation - /// for ! - pub fn relevant_for_never(&self) -> bool { - match self.kind { - AssocKind::OpaqueTy | AssocKind::Const | AssocKind::Type => true, - // FIXME(canndrew): Be more thorough here, check if any argument is uninhabited. - AssocKind::Fn => !self.fn_has_self_parameter, - } - } - pub fn signature(&self, tcx: TyCtxt<'_>) -> String { match self.kind { ty::AssocKind::Fn => { @@ -241,8 +229,6 @@ impl AssocItem { tcx.fn_sig(self.def_id).skip_binder().to_string() } ty::AssocKind::Type => format!("type {};", self.ident), - // FIXME(type_alias_impl_trait): we should print bounds here too. - ty::AssocKind::OpaqueTy => format!("type {};", self.ident), ty::AssocKind::Const => { format!("const {}: {:?};", self.ident, tcx.type_of(self.def_id)) } @@ -2581,10 +2567,6 @@ impl<'tcx> TyCtxt<'tcx> { .filter(|item| item.kind == AssocKind::Fn && item.defaultness.has_value()) } - pub fn trait_relevant_for_never(self, did: DefId) -> bool { - self.associated_items(did).in_definition_order().any(|item| item.relevant_for_never()) - } - pub fn opt_item_name(self, def_id: DefId) -> Option { def_id .as_local() diff --git a/src/librustc_passes/check_attr.rs b/src/librustc_passes/check_attr.rs index b54731d8881d1..80681c143750f 100644 --- a/src/librustc_passes/check_attr.rs +++ b/src/librustc_passes/check_attr.rs @@ -37,7 +37,7 @@ fn target_from_impl_item<'tcx>(tcx: TyCtxt<'tcx>, impl_item: &hir::ImplItem<'_>) Target::Method(MethodKind::Inherent) } } - hir::ImplItemKind::TyAlias(..) | hir::ImplItemKind::OpaqueTy(..) => Target::AssocTy, + hir::ImplItemKind::TyAlias(..) => Target::AssocTy, } } diff --git a/src/librustc_passes/dead.rs b/src/librustc_passes/dead.rs index 1dcf0e7c7a98a..419bbda78271a 100644 --- a/src/librustc_passes/dead.rs +++ b/src/librustc_passes/dead.rs @@ -668,7 +668,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> { } self.visit_nested_body(body_id) } - hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(..) => {} + hir::ImplItemKind::TyAlias(..) => {} } } diff --git a/src/librustc_passes/reachable.rs b/src/librustc_passes/reachable.rs index cac71b3836c54..c9a4428c007aa 100644 --- a/src/librustc_passes/reachable.rs +++ b/src/librustc_passes/reachable.rs @@ -180,7 +180,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { } } } - hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => false, + hir::ImplItemKind::TyAlias(_) => false, } } Some(_) => false, @@ -289,7 +289,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { self.visit_nested_body(body) } } - hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => {} + hir::ImplItemKind::TyAlias(_) => {} }, Node::Expr(&hir::Expr { kind: hir::ExprKind::Closure(.., body, _, _), .. }) => { self.visit_nested_body(body); diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index cb896810951ba..9778626212242 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -615,7 +615,6 @@ impl EmbargoVisitor<'tcx> { // public, or are not namespaced at all. DefKind::AssocConst | DefKind::AssocTy - | DefKind::AssocOpaqueTy | DefKind::ConstParam | DefKind::Ctor(_, _) | DefKind::Enum @@ -1333,11 +1332,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> { _ => None, }; let def = def.filter(|(kind, _)| match kind { - DefKind::AssocFn - | DefKind::AssocConst - | DefKind::AssocTy - | DefKind::AssocOpaqueTy - | DefKind::Static => true, + DefKind::AssocFn | DefKind::AssocConst | DefKind::AssocTy | DefKind::Static => true, _ => false, }); if let Some((kind, def_id)) = def { @@ -1602,9 +1597,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { hir::ImplItemKind::Const(..) | hir::ImplItemKind::Fn(..) => { self.access_levels.is_reachable(impl_item_ref.id.hir_id) } - hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => { - false - } + hir::ImplItemKind::TyAlias(_) => false, } }); @@ -1952,9 +1945,6 @@ impl<'a, 'tcx> PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> { let (check_ty, is_assoc_ty) = match assoc_item_kind { AssocItemKind::Const | AssocItemKind::Fn { .. } => (true, false), AssocItemKind::Type => (defaultness.has_value(), true), - // `ty()` for opaque types is the underlying type, - // it's not a part of interface, so we skip it. - AssocItemKind::OpaqueTy => (false, true), }; check.in_assoc_ty = is_assoc_ty; check.generics().predicates(); diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 53ec7f67f1906..e633bd1843e85 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -916,8 +916,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> { | DefKind::ForeignTy | DefKind::OpaqueTy | DefKind::TraitAlias - | DefKind::AssocTy - | DefKind::AssocOpaqueTy, + | DefKind::AssocTy, _, ) | Res::PrimTy(..) diff --git a/src/librustc_resolve/late/lifetimes.rs b/src/librustc_resolve/late/lifetimes.rs index 02193dcec901e..aa3e04121435f 100644 --- a/src/librustc_resolve/late/lifetimes.rs +++ b/src/librustc_resolve/late/lifetimes.rs @@ -799,43 +799,6 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { this.visit_ty(ty); }); } - OpaqueTy(bounds) => { - let generics = &impl_item.generics; - let mut index = self.next_early_index(); - let mut next_early_index = index; - debug!("visit_ty: index = {}", index); - let lifetimes = generics - .params - .iter() - .filter_map(|param| match param.kind { - GenericParamKind::Lifetime { .. } => { - Some(Region::early(&self.tcx.hir(), &mut index, param)) - } - GenericParamKind::Type { .. } => { - next_early_index += 1; - None - } - GenericParamKind::Const { .. } => { - next_early_index += 1; - None - } - }) - .collect(); - - let scope = Scope::Binder { - lifetimes, - next_early_index, - s: self.scope, - track_lifetime_uses: true, - opaque_type_parent: true, - }; - self.with(scope, |_old_scope, this| { - this.visit_generics(generics); - for bound in bounds { - this.visit_param_bound(bound); - } - }); - } Const(_, _) => { // Only methods and types support generics. assert!(impl_item.generics.params.is_empty()); diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index fbde6bfd9aae6..a4cef14e156f2 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -1102,7 +1102,6 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> { impl_item.span, ); } - hir::ImplItemKind::OpaqueTy(..) => {} hir::ImplItemKind::TyAlias(ref ty) => { // FIXME: uses of the assoc type should ideally point to this // 'def' and the name here should be a ref to the def in the diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 8a456c903ecdf..45c3e3e639f95 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -698,7 +698,6 @@ impl<'l, 'tcx> SaveContext<'l, 'tcx> { | HirDefKind::TyAlias | HirDefKind::ForeignTy | HirDefKind::TraitAlias - | HirDefKind::AssocOpaqueTy | HirDefKind::AssocTy | HirDefKind::Trait | HirDefKind::OpaqueTy diff --git a/src/librustc_trait_selection/opaque_types.rs b/src/librustc_trait_selection/opaque_types.rs index 51b1db390b927..af2fa783c93bd 100644 --- a/src/librustc_trait_selection/opaque_types.rs +++ b/src/librustc_trait_selection/opaque_types.rs @@ -11,7 +11,7 @@ use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKi use rustc_infer::infer::{self, InferCtxt, InferOk}; use rustc_middle::ty::fold::{BottomUpFolder, TypeFoldable, TypeFolder, TypeVisitor}; use rustc_middle::ty::subst::{GenericArg, GenericArgKind, InternalSubsts, SubstsRef}; -use rustc_middle::ty::{self, GenericParamDefKind, Ty, TyCtxt}; +use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_session::config::nightly_options; use rustc_span::Span; @@ -1059,21 +1059,10 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { ), origin, ), - _ => (def_scope_default(), hir::OpaqueTyOrigin::TypeAlias), - }, - Some(Node::ImplItem(item)) => match item.kind { - hir::ImplItemKind::OpaqueTy(_) => ( - may_define_opaque_type( - tcx, - self.parent_def_id.expect_local(), - opaque_hir_id, - ), - hir::OpaqueTyOrigin::TypeAlias, - ), - _ => (def_scope_default(), hir::OpaqueTyOrigin::TypeAlias), + _ => (def_scope_default(), hir::OpaqueTyOrigin::Misc), }, _ => bug!( - "expected (impl) item, found {}", + "expected item, found {}", tcx.hir().node_to_string(opaque_hir_id), ), }; diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs index d6c79d1973a71..9492c3c340995 100644 --- a/src/librustc_trait_selection/traits/project.rs +++ b/src/librustc_trait_selection/traits/project.rs @@ -25,7 +25,7 @@ use rustc_errors::ErrorReported; use rustc_hir::def_id::DefId; use rustc_hir::lang_items::{FnOnceTraitLangItem, GeneratorTraitLangItem}; use rustc_middle::ty::fold::{TypeFoldable, TypeFolder}; -use rustc_middle::ty::subst::{InternalSubsts, Subst}; +use rustc_middle::ty::subst::Subst; use rustc_middle::ty::util::IntTypeExt; use rustc_middle::ty::{self, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, WithConstness}; use rustc_span::symbol::{sym, Ident}; @@ -1477,12 +1477,7 @@ fn confirm_impl_candidate<'cx, 'tcx>( let substs = obligation.predicate.substs.rebase_onto(tcx, trait_def_id, substs); let substs = translate_substs(selcx.infcx(), param_env, impl_def_id, substs, assoc_ty.defining_node); - let ty = if let ty::AssocKind::OpaqueTy = assoc_ty.item.kind { - let item_substs = InternalSubsts::identity_for_item(tcx, assoc_ty.item.def_id); - tcx.mk_opaque(assoc_ty.item.def_id, item_substs) - } else { - tcx.type_of(assoc_ty.item.def_id) - }; + let ty = tcx.type_of(assoc_ty.item.def_id); if substs.len() != tcx.generics_of(assoc_ty.item.def_id).count() { tcx.sess .delay_span_bug(DUMMY_SP, "impl item and trait item have different parameter counts"); @@ -1515,7 +1510,7 @@ fn assoc_ty_def( // cycle error if the specialization graph is currently being built. let impl_node = specialization_graph::Node::Impl(impl_def_id); for item in impl_node.items(tcx) { - if matches!(item.kind, ty::AssocKind::Type | ty::AssocKind::OpaqueTy) + if matches!(item.kind, ty::AssocKind::Type) && tcx.hygienic_eq(item.ident, assoc_ty_name, trait_def_id) { return Ok(specialization_graph::LeafDef { diff --git a/src/librustc_ty/ty.rs b/src/librustc_ty/ty.rs index 3da5da2d9efb8..99094246a6378 100644 --- a/src/librustc_ty/ty.rs +++ b/src/librustc_ty/ty.rs @@ -85,7 +85,6 @@ fn associated_item_from_trait_item_ref( hir::AssocItemKind::Const => (ty::AssocKind::Const, false), hir::AssocItemKind::Fn { has_self } => (ty::AssocKind::Fn, has_self), hir::AssocItemKind::Type => (ty::AssocKind::Type, false), - hir::AssocItemKind::OpaqueTy => bug!("only impls can have opaque types"), }; ty::AssocItem { @@ -110,7 +109,6 @@ fn associated_item_from_impl_item_ref( hir::AssocItemKind::Const => (ty::AssocKind::Const, false), hir::AssocItemKind::Fn { has_self } => (ty::AssocKind::Fn, has_self), hir::AssocItemKind::Type => (ty::AssocKind::Type, false), - hir::AssocItemKind::OpaqueTy => (ty::AssocKind::OpaqueTy, false), }; ty::AssocItem { diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index 29cd9681295be..5f8fcaadfdb0b 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -1165,6 +1165,6 @@ fn assoc_item_kind_str(impl_item: &ty::AssocItem) -> &'static str { match impl_item.kind { ty::AssocKind::Const => "const", ty::AssocKind::Fn => "method", - ty::AssocKind::Type | ty::AssocKind::OpaqueTy => "type", + ty::AssocKind::Type => "type", } } diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 4095ab5e10fa5..a2e6c8793cbdd 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -1556,7 +1556,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> { match self.mode { Mode::MethodCall => item.fn_has_self_parameter, Mode::Path => match item.kind { - ty::AssocKind::OpaqueTy | ty::AssocKind::Type => false, + ty::AssocKind::Type => false, ty::AssocKind::Fn | ty::AssocKind::Const => true, }, } diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 7ca3eb884d88f..67bdd04d3715c 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -158,9 +158,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let path = self.tcx.def_path_str(trait_ref.def_id); let ty = match item.kind { - ty::AssocKind::Const - | ty::AssocKind::Type - | ty::AssocKind::OpaqueTy => rcvr_ty, + ty::AssocKind::Const | ty::AssocKind::Type => rcvr_ty, ty::AssocKind::Fn => self .tcx .fn_sig(item.def_id) diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 18846813c458f..8970a912743cd 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1943,7 +1943,6 @@ fn check_specialization_validity<'tcx>( let kind = match impl_item.kind { hir::ImplItemKind::Const(..) => ty::AssocKind::Const, hir::ImplItemKind::Fn(..) => ty::AssocKind::Fn, - hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy, hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type, }; @@ -2114,7 +2113,7 @@ fn check_impl_items_against_trait<'tcx>( err.emit() } } - hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => { + hir::ImplItemKind::TyAlias(_) => { let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id); if ty_trait_item.kind == ty::AssocKind::Type { compare_ty_impl( @@ -2367,8 +2366,6 @@ fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String { ) } ty::AssocKind::Type => format!("type {} = Type;", assoc.ident), - // FIXME(type_alias_impl_trait): we should print bounds here too. - ty::AssocKind::OpaqueTy => format!("type {} = Type;", assoc.ident), ty::AssocKind::Const => { let ty = tcx.type_of(assoc.def_id); let val = expr::ty_kind_suggestion(ty).unwrap_or("value"); diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 8a83952c4fc7f..c0be1d42d134c 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -316,9 +316,6 @@ fn check_associated_item( fcx.register_wf_obligation(ty.into(), span, code.clone()); } } - ty::AssocKind::OpaqueTy => { - // Do nothing: opaque types check themselves. - } } implied_bounds @@ -900,102 +897,102 @@ fn check_opaque_types<'fcx, 'tcx>( if !def_id.is_local() { return ty; } - let opaque_hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let opaque_hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); if let hir::ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: Some(_), .. }) = tcx.hir().expect_item(opaque_hir_id).kind { // Don't check return position impl trait. return ty; } - if may_define_opaque_type(tcx, fn_def_id, opaque_hir_id) { - trace!("check_opaque_types: may define, generics={:#?}", generics); - let mut seen_params: FxHashMap<_, Vec<_>> = FxHashMap::default(); - for (i, arg) in substs.iter().enumerate() { - let arg_is_param = match arg.unpack() { - GenericArgKind::Type(ty) => matches!(ty.kind, ty::Param(_)), - - GenericArgKind::Lifetime(region) => { - if let ty::ReStatic = region { - tcx.sess - .struct_span_err( - span, - "non-defining opaque type use in defining scope", - ) - .span_label( - tcx.def_span(generics.param_at(i, tcx).def_id), - "cannot use static lifetime; use a bound lifetime \ + if may_define_opaque_type(tcx, fn_def_id, opaque_hir_id) { + trace!("check_opaque_types: may define, generics={:#?}", generics); + let mut seen_params: FxHashMap<_, Vec<_>> = FxHashMap::default(); + for (i, arg) in substs.iter().enumerate() { + let arg_is_param = match arg.unpack() { + GenericArgKind::Type(ty) => matches!(ty.kind, ty::Param(_)), + + GenericArgKind::Lifetime(region) => { + if let ty::ReStatic = region { + tcx.sess + .struct_span_err( + span, + "non-defining opaque type use in defining scope", + ) + .span_label( + tcx.def_span(generics.param_at(i, tcx).def_id), + "cannot use static lifetime; use a bound lifetime \ instead or remove the lifetime parameter from the \ opaque type", - ) - .emit(); - continue; - } - - true + ) + .emit(); + continue; } - GenericArgKind::Const(ct) => matches!(ct.val, ty::ConstKind::Param(_)), - }; - - if arg_is_param { - seen_params.entry(arg).or_default().push(i); - } else { - // Prevent `fn foo() -> Foo` from being defining. - let opaque_param = generics.param_at(i, tcx); - tcx.sess - .struct_span_err( - span, - "non-defining opaque type use in defining scope", - ) - .span_note( - tcx.def_span(opaque_param.def_id), - &format!( - "used non-generic {} `{}` for generic parameter", - opaque_param.kind.descr(), - arg, - ), - ) - .emit(); - } - } // for (arg, param) - - for (_, indices) in seen_params { - if indices.len() > 1 { - let descr = generics.param_at(indices[0], tcx).kind.descr(); - let spans: Vec<_> = indices - .into_iter() - .map(|i| tcx.def_span(generics.param_at(i, tcx).def_id)) - .collect(); - tcx.sess - .struct_span_err( - span, - "non-defining opaque type use in defining scope", - ) - .span_note(spans, &format!("{} used multiple times", descr)) - .emit(); + true } + + GenericArgKind::Const(ct) => matches!(ct.val, ty::ConstKind::Param(_)), + }; + + if arg_is_param { + seen_params.entry(arg).or_default().push(i); + } else { + // Prevent `fn foo() -> Foo` from being defining. + let opaque_param = generics.param_at(i, tcx); + tcx.sess + .struct_span_err( + span, + "non-defining opaque type use in defining scope", + ) + .span_note( + tcx.def_span(opaque_param.def_id), + &format!( + "used non-generic {} `{}` for generic parameter", + opaque_param.kind.descr(), + arg, + ), + ) + .emit(); } - } // if may_define_opaque_type - - // Now register the bounds on the parameters of the opaque type - // so the parameters given by the function need to fulfill them. - // - // type Foo = impl Baz + 'static; - // fn foo() -> Foo { .. *} - // - // becomes - // - // type Foo = impl Baz + 'static; - // fn foo() -> Foo { .. *} - let predicates = tcx.predicates_of(def_id); - trace!("check_opaque_types: may define, predicates={:#?}", predicates,); - for &(pred, _) in predicates.predicates { - let substituted_pred = pred.subst(fcx.tcx, substs); - // Avoid duplication of predicates that contain no parameters, for example. - if !predicates.predicates.iter().any(|&(p, _)| p == substituted_pred) { - substituted_predicates.push(substituted_pred); + } // for (arg, param) + + for (_, indices) in seen_params { + if indices.len() > 1 { + let descr = generics.param_at(indices[0], tcx).kind.descr(); + let spans: Vec<_> = indices + .into_iter() + .map(|i| tcx.def_span(generics.param_at(i, tcx).def_id)) + .collect(); + tcx.sess + .struct_span_err( + span, + "non-defining opaque type use in defining scope", + ) + .span_note(spans, &format!("{} used multiple times", descr)) + .emit(); } } + } // if may_define_opaque_type + + // Now register the bounds on the parameters of the opaque type + // so the parameters given by the function need to fulfill them. + // + // type Foo = impl Baz + 'static; + // fn foo() -> Foo { .. *} + // + // becomes + // + // type Foo = impl Baz + 'static; + // fn foo() -> Foo { .. *} + let predicates = tcx.predicates_of(def_id); + trace!("check_opaque_types: may define, predicates={:#?}", predicates,); + for &(pred, _) in predicates.predicates { + let substituted_pred = pred.subst(fcx.tcx, substs); + // Avoid duplication of predicates that contain no parameters, for example. + if !predicates.predicates.iter().any(|&(p, _)| p == substituted_pred) { + substituted_predicates.push(substituted_pred); + } + } } // if let Opaque ty }, diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 7038caf4367e6..191244e41c80c 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -742,7 +742,7 @@ fn convert_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::HirId) { hir::ImplItemKind::Fn(..) => { tcx.ensure().fn_sig(def_id); } - hir::ImplItemKind::TyAlias(_) | hir::ImplItemKind::OpaqueTy(_) => { + hir::ImplItemKind::TyAlias(_) => { // Account for `type T = _;` let mut visitor = PlaceholderHirTyCollector::default(); visitor.visit_impl_item(impl_item); @@ -1203,10 +1203,10 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics { impl_trait_fn.or_else(|| { let parent_id = tcx.hir().get_parent_item(hir_id); assert!(parent_id != hir_id && parent_id != CRATE_HIR_ID); - debug!("generics_of: parent of opaque ty {:?} is {:?}", def_id, parent_id); + debug!("generics_of: parent of opaque ty {:?} is {:?}", def_id, parent_id); // Opaque types are always nested within another item, and // inherit the generics of the item. - Some(tcx.hir().local_def_id(parent_id).to_def_id()) + Some(tcx.hir().local_def_id(parent_id).to_def_id()) }) } _ => None, @@ -1704,31 +1704,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat let ast_generics = match node { Node::TraitItem(item) => &item.generics, - Node::ImplItem(item) => match item.kind { - ImplItemKind::OpaqueTy(ref bounds) => { - ty::print::with_no_queries(|| { - let substs = InternalSubsts::identity_for_item(tcx, def_id); - let opaque_ty = tcx.mk_opaque(def_id, substs); - debug!( - "explicit_predicates_of({:?}): created opaque type {:?}", - def_id, opaque_ty - ); - - // Collect the bounds, i.e., the `A + B + 'c` in `impl A + B + 'c`. - let bounds = AstConv::compute_bounds( - &icx, - opaque_ty, - bounds, - SizedByDefault::Yes, - tcx.def_span(def_id), - ); - - predicates.extend(bounds.predicates(tcx, opaque_ty)); - &item.generics - }) - } - _ => &item.generics, - }, + Node::ImplItem(item) => &item.generics, Node::Item(item) => { match item.kind { diff --git a/src/librustc_typeck/collect/type_of.rs b/src/librustc_typeck/collect/type_of.rs index cf0e3f9cdf592..f9bc7389b070d 100644 --- a/src/librustc_typeck/collect/type_of.rs +++ b/src/librustc_typeck/collect/type_of.rs @@ -64,13 +64,6 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { icx.to_ty(ty) } } - ImplItemKind::OpaqueTy(_) => { - if tcx.impl_trait_ref(tcx.hir().get_parent_did(hir_id).to_def_id()).is_none() { - report_assoc_ty_on_inherent_impl(tcx, item.span); - } - - find_opaque_ty_constraints(tcx, def_id.expect_local()) - } ImplItemKind::TyAlias(ref ty) => { if tcx.impl_trait_ref(tcx.hir().get_parent_did(hir_id).to_def_id()).is_none() { report_assoc_ty_on_inherent_impl(tcx, item.span); diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs index e13d9ea2b2626..37d383db68ab6 100644 --- a/src/librustc_typeck/impl_wf_check.rs +++ b/src/librustc_typeck/impl_wf_check.rs @@ -140,13 +140,6 @@ fn enforce_impl_params_are_constrained( Vec::new() } } - ty::AssocKind::OpaqueTy => { - // We don't know which lifetimes appear in the actual - // opaque type, so use all of the lifetimes that appear - // in the type's predicates. - let predicates = tcx.predicates_of(def_id).instantiate_identity(tcx); - cgp::parameters_for(&predicates, true) - } ty::AssocKind::Fn | ty::AssocKind::Const => Vec::new(), } }) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index dd4df11b1df38..92bf6b564cf8a 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1138,10 +1138,6 @@ impl Clean for hir::ImplItem<'_> { let item_type = type_.def_id().and_then(|did| inline::build_ty(cx, did)); TypedefItem(Typedef { type_, generics: Generics::default(), item_type }, true) } - hir::ImplItemKind::OpaqueTy(ref bounds) => OpaqueTyItem( - OpaqueTy { bounds: bounds.clean(cx), generics: Generics::default() }, - true, - ), }; let local_did = cx.tcx.hir().local_def_id(self.hir_id); Item { @@ -1308,7 +1304,6 @@ impl Clean for ty::AssocItem { ) } } - ty::AssocKind::OpaqueTy => unimplemented!(), }; let visibility = match self.container { diff --git a/src/tools/clippy/clippy_lints/src/lifetimes.rs b/src/tools/clippy/clippy_lints/src/lifetimes.rs index d80ad47ab2468..318d0b69d57b7 100644 --- a/src/tools/clippy/clippy_lints/src/lifetimes.rs +++ b/src/tools/clippy/clippy_lints/src/lifetimes.rs @@ -379,7 +379,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> { TyKind::Path(ref path) => { self.collect_anonymous_lifetimes(path, ty); }, - TyKind::Def(item, _) => { + TyKind::OpaqueDef(item, _) => { let map = self.cx.tcx.hir(); if let ItemKind::OpaqueTy(ref exist_ty) = map.expect_item(item.id).kind { for bound in exist_ty.bounds { diff --git a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs index cb72a24058234..03ab274d9ca9c 100644 --- a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs +++ b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs @@ -99,7 +99,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ManualAsyncFn { fn future_trait_ref<'tcx>(cx: &LateContext<'_, 'tcx>, ty: &'tcx Ty<'tcx>) -> Option<&'tcx TraitRef<'tcx>> { if_chain! { - if let TyKind::Def(item_id, _) = ty.kind; + if let TyKind::OpaqueDef(item_id, _) = ty.kind; let item = cx.tcx.hir().item(item_id.id); if let ItemKind::OpaqueTy(opaque) = &item.kind; if opaque.bounds.len() == 1; diff --git a/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs b/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs index f8d197c15e8d6..0096543c1fbca 100644 --- a/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs +++ b/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs @@ -710,7 +710,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { segment.ident.name.hash(&mut self.s); }, }, - TyKind::Def(_, arg_list) => { + TyKind::OpaqueDef(_, arg_list) => { for arg in *arg_list { match arg { GenericArg::Lifetime(ref l) => self.hash_lifetime(l),