diff options
202 files changed, 1050 insertions, 1033 deletions
diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs index 316ca642473..db90e44b892 100644 --- a/src/librustc/hir/check_attr.rs +++ b/src/librustc/hir/check_attr.rs @@ -27,7 +27,7 @@ pub(crate) enum Target { ForeignMod, GlobalAsm, Ty, - Existential, + OpaqueTy, Enum, Struct, Union, @@ -51,7 +51,7 @@ impl Display for Target { Target::ForeignMod => "foreign module", Target::GlobalAsm => "global asm", Target::Ty => "type alias", - Target::Existential => "existential type", + Target::OpaqueTy => "opaque type", Target::Enum => "enum", Target::Struct => "struct", Target::Union => "union", @@ -76,7 +76,7 @@ impl Target { hir::ItemKind::ForeignMod(..) => Target::ForeignMod, hir::ItemKind::GlobalAsm(..) => Target::GlobalAsm, hir::ItemKind::Ty(..) => Target::Ty, - hir::ItemKind::Existential(..) => Target::Existential, + hir::ItemKind::OpaqueTy(..) => Target::OpaqueTy, hir::ItemKind::Enum(..) => Target::Enum, hir::ItemKind::Struct(..) => Target::Struct, hir::ItemKind::Union(..) => Target::Union, diff --git a/src/librustc/hir/def.rs b/src/librustc/hir/def.rs index db568dbf9fb..40992e92744 100644 --- a/src/librustc/hir/def.rs +++ b/src/librustc/hir/def.rs @@ -55,15 +55,15 @@ pub enum DefKind { /// Refers to the variant itself, `DefKind::Ctor` refers to its constructor if it exists. Variant, Trait, - /// `existential type Foo: Bar;` - Existential, + /// `type Foo = impl Bar;` + OpaqueTy, /// `type Foo = Bar;` TyAlias, ForeignTy, TraitAlias, AssocTy, - /// `existential type Foo: Bar;` - AssocExistential, + /// `type Foo = impl Bar;` + AssocOpaqueTy, TyParam, // Value namespace @@ -96,11 +96,11 @@ impl DefKind { DefKind::Ctor(CtorOf::Struct, CtorKind::Const) => "unit struct", DefKind::Ctor(CtorOf::Struct, CtorKind::Fictive) => bug!("impossible struct constructor"), - DefKind::Existential => "existential type", + DefKind::OpaqueTy => "opaque type", DefKind::TyAlias => "type alias", DefKind::TraitAlias => "trait alias", DefKind::AssocTy => "associated type", - DefKind::AssocExistential => "associated existential type", + DefKind::AssocOpaqueTy => "associated opaque type", DefKind::Union => "union", DefKind::Trait => "trait", DefKind::ForeignTy => "foreign type", @@ -118,9 +118,9 @@ impl DefKind { match *self { DefKind::AssocTy | DefKind::AssocConst - | DefKind::AssocExistential + | DefKind::AssocOpaqueTy | DefKind::Enum - | DefKind::Existential => "an", + | DefKind::OpaqueTy => "an", DefKind::Macro(macro_kind) => macro_kind.article(), _ => "a", } diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index 3781d7df176..625e746c24f 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -505,7 +505,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { visitor.visit_ty(ty); visitor.visit_generics(generics) } - ItemKind::Existential(ExistTy { + ItemKind::OpaqueTy(OpaqueTy { ref generics, ref bounds, .. @@ -930,7 +930,7 @@ 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::Existential(ref bounds) => { + ImplItemKind::OpaqueTy(ref bounds) => { visitor.visit_id(impl_item.hir_id); walk_list!(visitor, visit_param_bound, bounds); } diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 026c3cc6f95..20ec7b1f386 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -189,14 +189,14 @@ enum ImplTraitContext<'a> { /// Newly generated parameters should be inserted into the given `Vec`. Universal(&'a mut Vec<hir::GenericParam>), - /// Treat `impl Trait` as shorthand for a new existential parameter. + /// Treat `impl Trait` as shorthand for a new opaque type. /// Example: `fn foo() -> impl Debug`, where `impl Debug` is conceptually - /// equivalent to a fresh existential parameter like `existential type T; fn foo() -> T`. + /// equivalent to a new opaque type like `type T = impl Debug; fn foo() -> T`. /// /// We optionally store a `DefId` for the parent item here so we can look up necessary /// information later. It is `None` when no information about the context should be stored /// (e.g., for consts and statics). - Existential(Option<DefId> /* fn def-ID */), + OpaqueTy(Option<DefId> /* fn def-ID */), /// `impl Trait` is not accepted in this position. Disallowed(ImplTraitPosition), @@ -222,7 +222,7 @@ impl<'a> ImplTraitContext<'a> { use self::ImplTraitContext::*; match self { Universal(params) => Universal(params), - Existential(fn_def_id) => Existential(*fn_def_id), + OpaqueTy(fn_def_id) => OpaqueTy(*fn_def_id), Disallowed(pos) => Disallowed(*pos), } } @@ -487,7 +487,7 @@ impl<'a> LoweringContext<'a> { | ItemKind::Union(_, ref generics) | ItemKind::Enum(_, ref generics) | ItemKind::Ty(_, ref generics) - | ItemKind::Existential(_, ref generics) + | ItemKind::OpaqueTy(_, ref generics) | ItemKind::Trait(_, _, ref generics, ..) => { let def_id = self.lctx.resolver.definitions().local_def_id(item.id); let count = generics @@ -1422,7 +1422,7 @@ impl<'a> LoweringContext<'a> { // so desugar to // // fn foo() -> impl Iterator<Item = impl Debug> - ImplTraitContext::Existential(_) => (true, itctx), + ImplTraitContext::OpaqueTy(_) => (true, itctx), // We are in the argument position, but within a dyn type: // @@ -1436,11 +1436,11 @@ impl<'a> LoweringContext<'a> { // In `type Foo = dyn Iterator<Item: Debug>` we desugar to // `type Foo = dyn Iterator<Item = impl Debug>` but we have to override the // "impl trait context" to permit `impl Debug` in this position (it desugars - // then to an existential type). + // then to an opaque type). // // FIXME: this is only needed until `impl Trait` is allowed in type aliases. ImplTraitContext::Disallowed(_) if self.is_in_dyn_type => - (true, ImplTraitContext::Existential(None)), + (true, ImplTraitContext::OpaqueTy(None)), // We are in the argument position, but not within a dyn type: // @@ -1634,8 +1634,8 @@ impl<'a> LoweringContext<'a> { TyKind::ImplTrait(def_node_id, ref bounds) => { let span = t.span; match itctx { - ImplTraitContext::Existential(fn_def_id) => { - self.lower_existential_impl_trait( + ImplTraitContext::OpaqueTy(fn_def_id) => { + self.lower_opaque_impl_trait( span, fn_def_id, def_node_id, |this| this.lower_param_bounds(bounds, itctx), ) @@ -1717,11 +1717,11 @@ impl<'a> LoweringContext<'a> { } } - fn lower_existential_impl_trait( + fn lower_opaque_impl_trait( &mut self, span: Span, fn_def_id: Option<DefId>, - exist_ty_node_id: NodeId, + opaque_ty_node_id: NodeId, lower_bounds: impl FnOnce(&mut LoweringContext<'_>) -> hir::GenericBounds, ) -> hir::TyKind { // Make sure we know that some funky desugaring has been going on here. @@ -1729,30 +1729,30 @@ impl<'a> LoweringContext<'a> { // desugaring that explicitly states that we don't want to track that. // Not tracking it makes lints in rustc and clippy very fragile, as // frequently opened issues show. - let exist_ty_span = self.mark_span_with_reason( - DesugaringKind::ExistentialType, + let opaque_ty_span = self.mark_span_with_reason( + DesugaringKind::OpaqueTy, span, None, ); - let exist_ty_def_index = self + let opaque_ty_def_index = self .resolver .definitions() - .opt_def_index(exist_ty_node_id) + .opt_def_index(opaque_ty_node_id) .unwrap(); - self.allocate_hir_id_counter(exist_ty_node_id); + self.allocate_hir_id_counter(opaque_ty_node_id); - let hir_bounds = self.with_hir_id_owner(exist_ty_node_id, lower_bounds); + let hir_bounds = self.with_hir_id_owner(opaque_ty_node_id, lower_bounds); let (lifetimes, lifetime_defs) = self.lifetimes_from_impl_trait_bounds( - exist_ty_node_id, - exist_ty_def_index, + opaque_ty_node_id, + opaque_ty_def_index, &hir_bounds, ); - self.with_hir_id_owner(exist_ty_node_id, |lctx| { - let exist_ty_item = hir::ExistTy { + self.with_hir_id_owner(opaque_ty_node_id, |lctx| { + let opaque_ty_item = hir::OpaqueTy { generics: hir::Generics { params: lifetime_defs, where_clause: hir::WhereClause { @@ -1763,54 +1763,54 @@ impl<'a> LoweringContext<'a> { }, bounds: hir_bounds, impl_trait_fn: fn_def_id, - origin: hir::ExistTyOrigin::ReturnImplTrait, + origin: hir::OpaqueTyOrigin::FnReturn, }; - trace!("exist ty from impl trait def-index: {:#?}", exist_ty_def_index); - let exist_ty_id = lctx.generate_existential_type( - exist_ty_node_id, - exist_ty_item, + trace!("exist ty from impl trait def-index: {:#?}", opaque_ty_def_index); + let opaque_ty_id = lctx.generate_opaque_type( + opaque_ty_node_id, + opaque_ty_item, span, - exist_ty_span, + opaque_ty_span, ); // `impl Trait` now just becomes `Foo<'a, 'b, ..>`. - hir::TyKind::Def(hir::ItemId { id: exist_ty_id }, lifetimes) + hir::TyKind::Def(hir::ItemId { id: opaque_ty_id }, lifetimes) }) } - /// Registers a new existential type with the proper `NodeId`s and - /// returns the lowered node-ID for the existential type. - fn generate_existential_type( + /// Registers a new opaque type with the proper `NodeId`s and + /// returns the lowered node-ID for the opaque type. + fn generate_opaque_type( &mut self, - exist_ty_node_id: NodeId, - exist_ty_item: hir::ExistTy, + opaque_ty_node_id: NodeId, + opaque_ty_item: hir::OpaqueTy, span: Span, - exist_ty_span: Span, + opaque_ty_span: Span, ) -> hir::HirId { - let exist_ty_item_kind = hir::ItemKind::Existential(exist_ty_item); - let exist_ty_id = self.lower_node_id(exist_ty_node_id); - // Generate an `existential type Foo: Trait;` declaration. - trace!("registering existential type with id {:#?}", exist_ty_id); - let exist_ty_item = hir::Item { - hir_id: exist_ty_id, + let opaque_ty_item_kind = hir::ItemKind::OpaqueTy(opaque_ty_item); + let opaque_ty_id = self.lower_node_id(opaque_ty_node_id); + // Generate an `type Foo = impl Trait;` declaration. + trace!("registering opaque type with id {:#?}", opaque_ty_id); + let opaque_ty_item = hir::Item { + hir_id: opaque_ty_id, ident: Ident::invalid(), attrs: Default::default(), - node: exist_ty_item_kind, + node: opaque_ty_item_kind, vis: respan(span.shrink_to_lo(), hir::VisibilityKind::Inherited), - span: exist_ty_span, + span: opaque_ty_span, }; // Insert the item into the global item list. This usually happens - // automatically for all AST items. But this existential type item + // automatically for all AST items. But this opaque type item // does not actually exist in the AST. - self.insert_item(exist_ty_item); - exist_ty_id + self.insert_item(opaque_ty_item); + opaque_ty_id } fn lifetimes_from_impl_trait_bounds( &mut self, - exist_ty_id: NodeId, + opaque_ty_id: NodeId, parent_index: DefIndex, bounds: &hir::GenericBounds, ) -> (HirVec<hir::GenericArg>, HirVec<hir::GenericParam>) { @@ -1820,7 +1820,7 @@ impl<'a> LoweringContext<'a> { struct ImplTraitLifetimeCollector<'r, 'a> { context: &'r mut LoweringContext<'a>, parent: DefIndex, - exist_ty_id: NodeId, + opaque_ty_id: NodeId, collect_elided_lifetimes: bool, currently_bound_lifetimes: Vec<hir::LifetimeName>, already_defined_lifetimes: FxHashSet<hir::LifetimeName>, @@ -1894,7 +1894,7 @@ impl<'a> LoweringContext<'a> { hir::LifetimeName::Implicit | hir::LifetimeName::Underscore => { if self.collect_elided_lifetimes { // Use `'_` for both implicit and underscore lifetimes in - // `abstract type Foo<'_>: SomeTrait<'_>;`. + // `type Foo<'_> = impl SomeTrait<'_>;`. hir::LifetimeName::Underscore } else { return; @@ -1916,7 +1916,7 @@ impl<'a> LoweringContext<'a> { let def_node_id = self.context.sess.next_node_id(); let hir_id = - self.context.lower_node_id_with_owner(def_node_id, self.exist_ty_id); + self.context.lower_node_id_with_owner(def_node_id, self.opaque_ty_id); self.context.resolver.definitions().create_def_with_parent( self.parent, def_node_id, @@ -1952,7 +1952,7 @@ impl<'a> LoweringContext<'a> { let mut lifetime_collector = ImplTraitLifetimeCollector { context: self, parent: parent_index, - exist_ty_id, + opaque_ty_id, collect_elided_lifetimes: true, currently_bound_lifetimes: Vec::new(), already_defined_lifetimes: FxHashSet::default(), @@ -2439,7 +2439,7 @@ impl<'a> LoweringContext<'a> { .as_ref() .map(|t| self.lower_ty(t, if self.sess.features_untracked().impl_trait_in_bindings { - ImplTraitContext::Existential(Some(parent_def_id)) + ImplTraitContext::OpaqueTy(Some(parent_def_id)) } else { ImplTraitContext::Disallowed(ImplTraitPosition::Binding) } @@ -2500,7 +2500,7 @@ impl<'a> LoweringContext<'a> { let lt_mode = if make_ret_async.is_some() { // In `async fn`, argument-position elided lifetimes // must be transformed into fresh generic parameters so that - // they can be applied to the existential return type. + // they can be applied to the opaque `impl Trait` return type. AnonymousLifetimeMode::CreateParameter } else { self.anonymous_lifetime_mode @@ -2539,7 +2539,7 @@ impl<'a> LoweringContext<'a> { FunctionRetTy::Ty(ref ty) => match in_band_ty_params { Some((def_id, _)) if impl_trait_return_allow => { hir::Return(self.lower_ty(ty, - ImplTraitContext::Existential(Some(def_id)) + ImplTraitContext::OpaqueTy(Some(def_id)) )) } _ => { @@ -2582,40 +2582,40 @@ impl<'a> LoweringContext<'a> { }) } - // Transforms `-> T` for `async fn` into `-> ExistTy { .. }` - // combined with the following definition of `ExistTy`: + // Transforms `-> T` for `async fn` into `-> OpaqueTy { .. }` + // combined with the following definition of `OpaqueTy`: // - // existential type ExistTy<generics_from_parent_fn>: Future<Output = T>; + // type OpaqueTy<generics_from_parent_fn> = impl Future<Output = T>; // // `inputs`: lowered types of arguments to the function (used to collect lifetimes) // `output`: unlowered output type (`T` in `-> T`) // `fn_def_id`: `DefId` of the parent function (used to create child impl trait definition) - // `exist_ty_node_id`: `NodeId` of the existential type that should be created + // `opaque_ty_node_id`: `NodeId` of the opaque `impl Trait` type that should be created // `elided_lt_replacement`: replacement for elided lifetimes in the return type fn lower_async_fn_ret_ty( &mut self, output: &FunctionRetTy, fn_def_id: DefId, - exist_ty_node_id: NodeId, + opaque_ty_node_id: NodeId, elided_lt_replacement: LtReplacement, ) -> hir::FunctionRetTy { let span = output.span(); - let exist_ty_span = self.mark_span_with_reason( + let opaque_ty_span = self.mark_span_with_reason( DesugaringKind::Async, span, None, ); - let exist_ty_def_index = self + let opaque_ty_def_index = self .resolver .definitions() - .opt_def_index(exist_ty_node_id) + .opt_def_index(opaque_ty_node_id) .unwrap(); - self.allocate_hir_id_counter(exist_ty_node_id); + self.allocate_hir_id_counter(opaque_ty_node_id); - let (exist_ty_id, lifetime_params) = self.with_hir_id_owner(exist_ty_node_id, |this| { + let (opaque_ty_id, lifetime_params) = self.with_hir_id_owner(opaque_ty_node_id, |this| { let future_bound = this.with_anonymous_lifetime_mode( AnonymousLifetimeMode::Replace(elided_lt_replacement), |this| this.lower_async_fn_output_type_to_future_bound( @@ -2626,7 +2626,7 @@ impl<'a> LoweringContext<'a> { ); // Calculate all the lifetimes that should be captured - // by the existential type. This should include all in-scope + // by the opaque type. This should include all in-scope // lifetime parameters, including those defined in-band. // // Note: this must be done after lowering the output type, @@ -2642,11 +2642,11 @@ impl<'a> LoweringContext<'a> { lifetime_params .iter().cloned() .map(|(span, hir_name)| { - this.lifetime_to_generic_param(span, hir_name, exist_ty_def_index) + this.lifetime_to_generic_param(span, hir_name, opaque_ty_def_index) }) .collect(); - let exist_ty_item = hir::ExistTy { + let opaque_ty_item = hir::OpaqueTy { generics: hir::Generics { params: generic_params, where_clause: hir::WhereClause { @@ -2657,18 +2657,18 @@ impl<'a> LoweringContext<'a> { }, bounds: hir_vec![future_bound], impl_trait_fn: Some(fn_def_id), - origin: hir::ExistTyOrigin::AsyncFn, + origin: hir::OpaqueTyOrigin::AsyncFn, }; - trace!("exist ty from async fn def index: {:#?}", exist_ty_def_index); - let exist_ty_id = this.generate_existential_type( - exist_ty_node_id, - exist_ty_item, + trace!("exist ty from async fn def index: {:#?}", opaque_ty_def_index); + let opaque_ty_id = this.generate_opaque_type( + opaque_ty_node_id, + opaque_ty_item, span, - exist_ty_span, + opaque_ty_span, ); - (exist_ty_id, lifetime_params) + (opaque_ty_id, lifetime_params) }); let generic_args = @@ -2683,10 +2683,10 @@ impl<'a> LoweringContext<'a> { }) .collect(); - let exist_ty_ref = hir::TyKind::Def(hir::ItemId { id: exist_ty_id }, generic_args); + let opaque_ty_ref = hir::TyKind::Def(hir::ItemId { id: opaque_ty_id }, generic_args); hir::FunctionRetTy::Return(P(hir::Ty { - node: exist_ty_ref, + node: opaque_ty_ref, span, hir_id: self.next_id(), })) @@ -2702,7 +2702,7 @@ impl<'a> LoweringContext<'a> { // Compute the `T` in `Future<Output = T>` from the return type. let output_ty = match output { FunctionRetTy::Ty(ty) => { - self.lower_ty(ty, ImplTraitContext::Existential(Some(fn_def_id))) + self.lower_ty(ty, ImplTraitContext::OpaqueTy(Some(fn_def_id))) } FunctionRetTy::Default(ret_ty_span) => { P(hir::Ty { @@ -2905,7 +2905,7 @@ impl<'a> LoweringContext<'a> { let kind = hir::GenericParamKind::Type { default: default.as_ref().map(|x| { - self.lower_ty(x, ImplTraitContext::Existential(None)) + self.lower_ty(x, ImplTraitContext::OpaqueTy(None)) }), synthetic: param.attrs.iter() .filter(|attr| attr.check_name(sym::rustc_synthetic)) @@ -3384,7 +3384,7 @@ impl<'a> LoweringContext<'a> { self.lower_ty( t, if self.sess.features_untracked().impl_trait_in_bindings { - ImplTraitContext::Existential(None) + ImplTraitContext::OpaqueTy(None) } else { ImplTraitContext::Disallowed(ImplTraitPosition::Binding) } @@ -3398,7 +3398,7 @@ impl<'a> LoweringContext<'a> { self.lower_ty( t, if self.sess.features_untracked().impl_trait_in_bindings { - ImplTraitContext::Existential(None) + ImplTraitContext::OpaqueTy(None) } else { ImplTraitContext::Disallowed(ImplTraitPosition::Binding) } @@ -3444,14 +3444,14 @@ impl<'a> LoweringContext<'a> { self.lower_ty(t, ImplTraitContext::disallowed()), self.lower_generics(generics, ImplTraitContext::disallowed()), ), - ItemKind::Existential(ref b, ref generics) => hir::ItemKind::Existential( - hir::ExistTy { + ItemKind::OpaqueTy(ref b, ref generics) => hir::ItemKind::OpaqueTy( + hir::OpaqueTy { generics: self.lower_generics(generics, - ImplTraitContext::Existential(None)), + ImplTraitContext::OpaqueTy(None)), bounds: self.lower_param_bounds(b, - ImplTraitContext::Existential(None)), + ImplTraitContext::OpaqueTy(None)), impl_trait_fn: None, - origin: hir::ExistTyOrigin::ExistentialType, + origin: hir::OpaqueTyOrigin::TypeAlias, }, ), ItemKind::Enum(ref enum_definition, ref generics) => { @@ -3918,9 +3918,9 @@ impl<'a> LoweringContext<'a> { self.lower_generics(&i.generics, ImplTraitContext::disallowed()), hir::ImplItemKind::Type(self.lower_ty(ty, ImplTraitContext::disallowed())), ), - ImplItemKind::Existential(ref bounds) => ( + ImplItemKind::OpaqueTy(ref bounds) => ( self.lower_generics(&i.generics, ImplTraitContext::disallowed()), - hir::ImplItemKind::Existential( + hir::ImplItemKind::OpaqueTy( self.lower_param_bounds(bounds, ImplTraitContext::disallowed()), ), ), @@ -3951,7 +3951,7 @@ impl<'a> LoweringContext<'a> { kind: match i.node { ImplItemKind::Const(..) => hir::AssocItemKind::Const, ImplItemKind::Type(..) => hir::AssocItemKind::Type, - ImplItemKind::Existential(..) => hir::AssocItemKind::Existential, + ImplItemKind::OpaqueTy(..) => hir::AssocItemKind::OpaqueTy, ImplItemKind::Method(ref sig, _) => hir::AssocItemKind::Method { has_self: sig.decl.has_self(), }, diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs index d02aab54127..c44942a1626 100644 --- a/src/librustc/hir/map/def_collector.rs +++ b/src/librustc/hir/map/def_collector.rs @@ -92,7 +92,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { } ItemKind::Mod(..) | ItemKind::Trait(..) | ItemKind::TraitAlias(..) | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) | - ItemKind::Existential(..) | ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) | + ItemKind::OpaqueTy(..) | ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) | ItemKind::Ty(..) => DefPathData::TypeNs(i.ident.as_interned_str()), ItemKind::Fn( ref decl, @@ -223,7 +223,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { ImplItemKind::Method(..) | ImplItemKind::Const(..) => DefPathData::ValueNs(ii.ident.as_interned_str()), ImplItemKind::Type(..) | - ImplItemKind::Existential(..) => { + ImplItemKind::OpaqueTy(..) => { DefPathData::TypeNs(ii.ident.as_interned_str()) }, ImplItemKind::Macro(..) => return self.visit_macro_invoc(ii.id), diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 5a28d9e7b7d..b93961a1239 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -301,7 +301,7 @@ impl<'hir> Map<'hir> { ItemKind::Const(..) => DefKind::Const, ItemKind::Fn(..) => DefKind::Fn, ItemKind::Mod(..) => DefKind::Mod, - ItemKind::Existential(..) => DefKind::Existential, + ItemKind::OpaqueTy(..) => DefKind::OpaqueTy, ItemKind::Ty(..) => DefKind::TyAlias, ItemKind::Enum(..) => DefKind::Enum, ItemKind::Struct(..) => DefKind::Struct, @@ -334,7 +334,7 @@ impl<'hir> Map<'hir> { ImplItemKind::Const(..) => DefKind::AssocConst, ImplItemKind::Method(..) => DefKind::Method, ImplItemKind::Type(..) => DefKind::AssocTy, - ImplItemKind::Existential(..) => DefKind::AssocExistential, + ImplItemKind::OpaqueTy(..) => DefKind::AssocOpaqueTy, } } Node::Variant(_) => DefKind::Variant, @@ -816,7 +816,7 @@ impl<'hir> Map<'hir> { }, |_| false).ok() } - /// Returns the defining scope for an existential type definition. + /// Returns the defining scope for an opaque type definition. pub fn get_defining_scope(&self, id: HirId) -> Option<HirId> { let mut scope = id; loop { @@ -827,7 +827,7 @@ impl<'hir> Map<'hir> { match self.get(scope) { Node::Item(i) => { match i.node { - ItemKind::Existential(ExistTy { impl_trait_fn: None, .. }) => {} + ItemKind::OpaqueTy(OpaqueTy { impl_trait_fn: None, .. }) => {} _ => break, } } @@ -1270,7 +1270,7 @@ fn hir_id_to_string(map: &Map<'_>, id: HirId, include_id: bool) -> String { ItemKind::ForeignMod(..) => "foreign mod", ItemKind::GlobalAsm(..) => "global asm", ItemKind::Ty(..) => "ty", - ItemKind::Existential(..) => "existential type", + ItemKind::OpaqueTy(..) => "opaque type", ItemKind::Enum(..) => "enum", ItemKind::Struct(..) => "struct", ItemKind::Union(..) => "union", @@ -1294,8 +1294,8 @@ fn hir_id_to_string(map: &Map<'_>, id: HirId, include_id: bool) -> String { ImplItemKind::Type(_) => { format!("assoc type {} in {}{}", ii.ident, path_str(), id_str) } - ImplItemKind::Existential(_) => { - format!("assoc existential type {} in {}{}", ii.ident, path_str(), id_str) + ImplItemKind::OpaqueTy(_) => { + format!("assoc opaque type {} in {}{}", ii.ident, path_str(), id_str) } } } diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index f9a49447801..5fe8069e332 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -1815,7 +1815,7 @@ pub struct ImplItemId { pub hir_id: HirId, } -/// Represents anything within an `impl` block +/// Represents anything within an `impl` block. #[derive(RustcEncodable, RustcDecodable, Debug)] pub struct ImplItem { pub ident: Ident, @@ -1832,14 +1832,14 @@ pub struct ImplItem { #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)] pub enum ImplItemKind { /// An associated constant of the given type, set to the constant result - /// of the expression + /// of the expression. Const(P<Ty>, BodyId), - /// A method implementation with the given signature and body + /// A method implementation with the given signature and body. Method(MethodSig, BodyId), - /// An associated type + /// An associated type. Type(P<Ty>), - /// An associated existential type - Existential(GenericBounds), + /// An associated `type = impl Trait`. + OpaqueTy(GenericBounds), } /// Bind a type to an associated type (i.e., `A = Foo`). @@ -1922,20 +1922,20 @@ pub struct BareFnTy { } #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)] -pub struct ExistTy { +pub struct OpaqueTy { pub generics: Generics, pub bounds: GenericBounds, pub impl_trait_fn: Option<DefId>, - pub origin: ExistTyOrigin, + pub origin: OpaqueTyOrigin, } -/// Where the existential type came from +/// From whence the opaque type came. #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable)] -pub enum ExistTyOrigin { - /// `existential type Foo: Trait;` - ExistentialType, +pub enum OpaqueTyOrigin { + /// `type Foo = impl Trait;` + TypeAlias, /// `-> impl Trait` - ReturnImplTrait, + FnReturn, /// `async fn` AsyncFn, } @@ -1962,7 +1962,7 @@ pub enum TyKind { /// /// Type parameters may be stored in each `PathSegment`. Path(QPath), - /// A type definition itself. This is currently only used for the `existential type` + /// A type definition itself. This is currently only used for the `type Foo = impl Trait` /// item that `impl Trait` in return position desugars to. /// /// The generic argument list contains the lifetimes (and in the future possibly parameters) @@ -2421,17 +2421,17 @@ pub enum ItemKind { GlobalAsm(P<GlobalAsm>), /// A type alias, e.g., `type Foo = Bar<u8>` Ty(P<Ty>, Generics), - /// An existential type definition, e.g., `existential type Foo: Bar;` - Existential(ExistTy), + /// An opaque `impl Trait` type alias, e.g., `type Foo = impl Bar;` + OpaqueTy(OpaqueTy), /// An enum definition, e.g., `enum Foo<A, B> {C<A>, D<B>}` Enum(EnumDef, Generics), /// A struct definition, e.g., `struct Foo<A> {x: A}` Struct(VariantData, Generics), /// A union definition, e.g., `union Foo<A, B> {x: A, y: B}` Union(VariantData, Generics), - /// Represents a Trait Declaration + /// A trait definition Trait(IsAuto, Unsafety, Generics, GenericBounds, HirVec<TraitItemRef>), - /// Represents a Trait Alias Declaration + /// A trait alias TraitAlias(Generics, GenericBounds), /// An implementation, eg `impl<A> Trait for Foo { .. }` @@ -2456,7 +2456,7 @@ impl ItemKind { ItemKind::ForeignMod(..) => "foreign module", ItemKind::GlobalAsm(..) => "global asm", ItemKind::Ty(..) => "type alias", - ItemKind::Existential(..) => "existential type", + ItemKind::OpaqueTy(..) => "opaque type", ItemKind::Enum(..) => "enum", ItemKind::Struct(..) => "struct", ItemKind::Union(..) => "union", @@ -2479,7 +2479,7 @@ impl ItemKind { Some(match *self { ItemKind::Fn(_, _, ref generics, _) | ItemKind::Ty(_, ref generics) | - ItemKind::Existential(ExistTy { ref generics, impl_trait_fn: None, .. }) | + ItemKind::OpaqueTy(OpaqueTy { ref generics, impl_trait_fn: None, .. }) | ItemKind::Enum(_, ref generics) | ItemKind::Struct(_, ref generics) | ItemKind::Union(_, ref generics) | @@ -2528,7 +2528,7 @@ pub enum AssocItemKind { Const, Method { has_self: bool }, Type, - Existential, + OpaqueTy, } #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)] diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 9c32831cf88..a8760438fc0 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -450,6 +450,24 @@ impl<'a> State<'a> { self.s.word(";") } + fn print_item_type( + &mut self, + item: &hir::Item, + generics: &hir::Generics, + inner: impl Fn(&mut Self), + ) { + self.head(visibility_qualified(&item.vis, "type")); + self.print_ident(item.ident); + self.print_generic_params(&generics.params); + self.end(); // end the inner ibox + + self.print_where_clause(&generics.where_clause); + self.s.space(); + inner(self); + self.s.word(";"); + self.end(); // end the outer ibox + } + /// Pretty-print an item pub fn print_item(&mut self, item: &hir::Item) { self.hardbreak_if_not_bol(); @@ -553,43 +571,28 @@ impl<'a> State<'a> { self.end() } hir::ItemKind::Ty(ref ty, ref generics) => { - self.head(visibility_qualified(&item.vis, "type")); - self.print_ident(item.ident); - self.print_generic_params(&generics.params); - self.end(); // end the inner ibox - - self.print_where_clause(&generics.where_clause); - self.s.space(); - self.word_space("="); - self.print_type(&ty); - self.s.word(";"); - self.end(); // end the outer ibox + self.print_item_type(item, &generics, |state| { + state.word_space("="); + state.print_type(&ty); + }); } - hir::ItemKind::Existential(ref exist) => { - self.head(visibility_qualified(&item.vis, "existential type")); - self.print_ident(item.ident); - self.print_generic_params(&exist.generics.params); - self.end(); // end the inner ibox - - self.print_where_clause(&exist.generics.where_clause); - self.s.space(); - let mut real_bounds = Vec::with_capacity(exist.bounds.len()); - for b in exist.bounds.iter() { - if let GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = *b { - self.s.space(); - self.word_space("for ?"); - self.print_trait_ref(&ptr.trait_ref); - } else { - real_bounds.push(b); + hir::ItemKind::OpaqueTy(ref opaque_ty) => { + self.print_item_type(item, &opaque_ty.generics, |state| { + let mut real_bounds = Vec::with_capacity(opaque_ty.bounds.len()); + for b in opaque_ty.bounds.iter() { + if let GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = *b { + state.s.space(); + state.word_space("for ?"); + state.print_trait_ref(&ptr.trait_ref); + } else { + real_bounds.push(b); + } } - } - self.print_bounds(":", real_bounds); - self.s.word(";"); - self.end(); // end the outer ibox + state.print_bounds("= impl", real_bounds); + }); } hir::ItemKind::Enum(ref enum_definition, ref params) => { - self.print_enum_def(enum_definition, params, item.ident.name, item.span, - &item.vis); + self.print_enum_def(enum_definition, params, item.ident.name, item.span, &item.vis); } hir::ItemKind::Struct(ref struct_def, ref generics) => { self.head(visibility_qualified(&item.vis, "struct")); @@ -908,9 +911,11 @@ impl<'a> State<'a> { hir::ImplItemKind::Type(ref ty) => { self.print_associated_type(ii.ident, None, Some(ty)); } - hir::ImplItemKind::Existential(ref bounds) => { - self.word_space("existential"); - self.print_associated_type(ii.ident, Some(bounds), None); + hir::ImplItemKind::OpaqueTy(ref 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/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs index e0e7988a744..0c9c9adcf9d 100644 --- a/src/librustc/ich/impls_syntax.rs +++ b/src/librustc/ich/impls_syntax.rs @@ -418,7 +418,7 @@ impl_stable_hash_for!(enum ::syntax_pos::hygiene::DesugaringKind { Async, Await, QuestionMark, - ExistentialType, + OpaqueTy, ForLoop, TryBlock }); diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index cbfb048c064..f92e0336244 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -269,7 +269,7 @@ impl<'tcx> TyCtxt<'tcx> { match item.node { hir::ImplItemKind::Method(..) => "method body", hir::ImplItemKind::Const(..) - | hir::ImplItemKind::Existential(..) + | hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::Type(..) => "associated item", } } diff --git a/src/librustc/infer/opaque_types/mod.rs b/src/librustc/infer/opaque_types/mod.rs index 73a76ebcb74..5c62f76e3bb 100644 --- a/src/librustc/infer/opaque_types/mod.rs +++ b/src/librustc/infer/opaque_types/mod.rs @@ -18,19 +18,19 @@ use syntax_pos::Span; pub type OpaqueTypeMap<'tcx> = DefIdMap<OpaqueTypeDecl<'tcx>>; -/// Information about the opaque, abstract types whose values we +/// Information about the opaque types whose values we /// are inferring in this function (these are the `impl Trait` that /// appear in the return type). #[derive(Copy, Clone, Debug)] pub struct OpaqueTypeDecl<'tcx> { - /// The substitutions that we apply to the abstract that this + /// The substitutions that we apply to the opaque type that this /// `impl Trait` desugars to. e.g., if: /// /// fn foo<'a, 'b, T>() -> impl Trait<'a> /// /// winds up desugared to: /// - /// abstract type Foo<'x, X>: Trait<'x> + /// type Foo<'x, X> = impl Trait<'x> /// fn foo<'a, 'b, T>() -> Foo<'a, T> /// /// then `substs` would be `['a, T]`. @@ -40,7 +40,7 @@ pub struct OpaqueTypeDecl<'tcx> { /// for example: /// /// ``` - /// existential type Foo; + /// type Foo = impl Baz; /// fn bar() -> Foo { /// ^^^ This is the span we are looking for! /// ``` @@ -50,7 +50,7 @@ pub struct OpaqueTypeDecl<'tcx> { /// over-approximated, but better than nothing. pub definition_span: Span, - /// The type variable that represents the value of the abstract type + /// The type variable that represents the value of the opaque type /// that we require. In other words, after we compile this function, /// we will be created a constraint like: /// @@ -87,8 +87,8 @@ pub struct OpaqueTypeDecl<'tcx> { /// check.) pub has_required_region_bounds: bool, - /// The origin of the existential type - pub origin: hir::ExistTyOrigin, + /// The origin of the opaque type. + pub origin: hir::OpaqueTyOrigin, } impl<'a, 'tcx> InferCtxt<'a, 'tcx> { @@ -143,8 +143,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { InferOk { value: (value, instantiator.opaque_types), obligations: instantiator.obligations } } - /// Given the map `opaque_types` containing the existential `impl - /// Trait` types whose underlying, hidden types are being + /// Given the map `opaque_types` containing the opaque + /// `impl Trait` types whose underlying, hidden types are being /// inferred, this method adds constraints to the regions /// appearing in those underlying hidden types to ensure that they /// at least do not refer to random scopes within the current @@ -164,12 +164,12 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { /// Here, we have two `impl Trait` types whose values are being /// inferred (the `impl Bar<'a>` and the `impl /// Bar<'b>`). Conceptually, this is sugar for a setup where we - /// define underlying abstract types (`Foo1`, `Foo2`) and then, in + /// define underlying opaque types (`Foo1`, `Foo2`) and then, in /// the return type of `foo`, we *reference* those definitions: /// /// ```text - /// abstract type Foo1<'x>: Bar<'x>; - /// abstract type Foo2<'x>: Bar<'x>; + /// type Foo1<'x> = impl Bar<'x>; + /// type Foo2<'x> = impl Bar<'x>; /// fn foo<'a, 'b>(..) -> (Foo1<'a>, Foo2<'b>) { .. } /// // ^^^^ ^^ /// // | | @@ -228,7 +228,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { /// /// This is actually a bit of a tricky constraint in general. We /// want to say that each variable (e.g., `'0`) can only take on - /// values that were supplied as arguments to the abstract type + /// values that were supplied as arguments to the opaque type /// (e.g., `'a` for `Foo1<'a>`) or `'static`, which is always in /// scope. We don't have a constraint quite of this kind in the current /// region checker. @@ -265,24 +265,24 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { /// } /// /// // Equivalent to: - /// existential type FooReturn<'a, T>: Foo<'a>; + /// type FooReturn<'a, T> = impl Foo<'a>; /// fn foo<'a, T>(..) -> FooReturn<'a, T> { .. } /// ``` /// /// then the hidden type `Tc` would be `(&'0 u32, T)` (where `'0` /// is an inference variable). If we generated a constraint that /// `Tc: 'a`, then this would incorrectly require that `T: 'a` -- - /// but this is not necessary, because the existential type we + /// but this is not necessary, because the opaque type we /// create will be allowed to reference `T`. So we only generate a /// constraint that `'0: 'a`. /// /// # The `free_region_relations` parameter /// /// The `free_region_relations` argument is used to find the - /// "minimum" of the regions supplied to a given abstract type. + /// "minimum" of the regions supplied to a given opaque type. /// It must be a relation that can answer whether `'a <= 'b`, /// where `'a` and `'b` are regions that appear in the "substs" - /// for the abstract type references (the `<'a>` in `Foo1<'a>`). + /// for the opaque type references (the `<'a>` in `Foo1<'a>`). /// /// Note that we do not impose the constraints based on the /// generic regions from the `Foo1` definition (e.g., `'x`). This @@ -298,7 +298,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { /// /// Here, the fact that `'b: 'a` is known only because of the /// implied bounds from the `&'a &'b u32` parameter, and is not - /// "inherent" to the abstract type definition. + /// "inherent" to the opaque type definition. /// /// # Parameters /// @@ -361,7 +361,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { // There were no `required_region_bounds`, // so we have to search for a `least_region`. // Go through all the regions used as arguments to the - // abstract type. These are the parameters to the abstract + // opaque type. These are the parameters to the opaque // type; so in our example above, `substs` would contain // `['a]` for the first impl trait and `'b` for the // second. @@ -492,11 +492,11 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { // Without a feature-gate, we only generate member-constraints for async-await. let context_name = match opaque_defn.origin { // No feature-gate required for `async fn`. - hir::ExistTyOrigin::AsyncFn => return false, + hir::OpaqueTyOrigin::AsyncFn => return false, // Otherwise, generate the label we'll use in the error message. - hir::ExistTyOrigin::ExistentialType => "existential type", - hir::ExistTyOrigin::ReturnImplTrait => "impl Trait", + hir::OpaqueTyOrigin::TypeAlias => "impl Trait", + hir::OpaqueTyOrigin::FnReturn => "impl Trait", }; let msg = format!("ambiguous lifetime bound in `{}`", context_name); let mut err = self.tcx.sess.struct_span_err(span, &msg); @@ -528,12 +528,12 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { /// Given the fully resolved, instantiated type for an opaque /// type, i.e., the value of an inference variable like C1 or C2 - /// (*), computes the "definition type" for an abstract type + /// (*), computes the "definition type" for an opaque type /// definition -- that is, the inferred value of `Foo1<'x>` or /// `Foo2<'x>` that we would conceptually use in its definition: /// - /// abstract type Foo1<'x>: Bar<'x> = AAA; <-- this type AAA - /// abstract type Foo2<'x>: Bar<'x> = BBB; <-- or this type BBB + /// type Foo1<'x> = impl Bar<'x> = AAA; <-- this type AAA + /// type Foo2<'x> = impl Bar<'x> = BBB; <-- or this type BBB /// fn foo<'a, 'b>(..) -> (Foo1<'a>, Foo2<'b>) { .. } /// /// Note that these values are defined in terms of a distinct set of @@ -842,12 +842,12 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> { self.tcx.sess .struct_span_err( self.span, - "non-defining existential type use in defining scope" + "non-defining opaque type use in defining scope" ) .span_label( self.span, format!("lifetime `{}` is part of concrete type but not used in \ - parameter list of existential type", r), + parameter list of the `impl Trait` type alias", r), ) .emit(); @@ -863,7 +863,7 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> { // we encounter a closure here, it is always a closure // from within the function that we are currently // type-checking -- one that is now being encapsulated - // in an existential abstract type. Ideally, we would + // in an opaque type. Ideally, we would // go through the types/lifetimes that it references // and treat them just like we would any other type, // which means we would error out if we find any @@ -918,7 +918,7 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> { // Look it up in the substitution list. match self.map.get(&ty.into()).map(|k| k.unpack()) { // Found it in the substitution list; replace with the parameter from the - // existential type. + // opaque type. Some(UnpackedKind::Type(t1)) => t1, Some(u) => panic!("type mapped to unexpected kind: {:?}", u), None => { @@ -926,7 +926,8 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> { .struct_span_err( self.span, &format!("type parameter `{}` is part of concrete type but not \ - used in parameter list for existential type", ty), + used in parameter list for the `impl Trait` type alias", + ty), ) .emit(); @@ -947,7 +948,7 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> { // Look it up in the substitution list. match self.map.get(&ct.into()).map(|k| k.unpack()) { // Found it in the substitution list, replace with the parameter from the - // existential type. + // opaque type. Some(UnpackedKind::Const(c1)) => c1, Some(u) => panic!("const mapped to unexpected kind: {:?}", u), None => { @@ -955,7 +956,8 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> { .struct_span_err( self.span, &format!("const parameter `{}` is part of concrete type but not \ - used in parameter list for existential type", ct) + used in parameter list for the `impl Trait` type alias", + ct) ) .emit(); @@ -992,15 +994,15 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { // value we are inferring. At present, this is // always true during the first phase of // type-check, but not always true later on during - // NLL. Once we support named abstract types more fully, + // NLL. Once we support named opaque types more fully, // this same scenario will be able to arise during all phases. // - // Here is an example using `abstract type` that indicates - // the distinction we are checking for: + // Here is an example using type alias `impl Trait` + // that indicates the distinction we are checking for: // // ```rust // mod a { - // pub abstract type Foo: Iterator; + // pub type Foo = impl Iterator; // pub fn make_foo() -> Foo { .. } // } // @@ -1031,36 +1033,40 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { let (in_definition_scope, origin) = match tcx.hir().find(opaque_hir_id) { Some(Node::Item(item)) => match item.node { // Anonymous `impl Trait` - hir::ItemKind::Existential(hir::ExistTy { + hir::ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: Some(parent), origin, .. }) => (parent == self.parent_def_id, origin), - // Named `existential type` - hir::ItemKind::Existential(hir::ExistTy { + // Named `type Foo = impl Bar;` + hir::ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: None, origin, .. }) => ( - may_define_existential_type( + may_define_opaque_type( tcx, self.parent_def_id, opaque_hir_id, ), origin, ), - _ => (def_scope_default(), hir::ExistTyOrigin::ExistentialType), + _ => { + (def_scope_default(), hir::OpaqueTyOrigin::TypeAlias) + } }, Some(Node::ImplItem(item)) => match item.node { - hir::ImplItemKind::Existential(_) => ( - may_define_existential_type( + hir::ImplItemKind::OpaqueTy(_) => ( + may_define_opaque_type( tcx, self.parent_def_id, opaque_hir_id, ), - hir::ExistTyOrigin::ExistentialType, + hir::OpaqueTyOrigin::TypeAlias, ), - _ => (def_scope_default(), hir::ExistTyOrigin::ExistentialType), + _ => { + (def_scope_default(), hir::OpaqueTyOrigin::TypeAlias) + } }, _ => bug!( "expected (impl) item, found {}", @@ -1092,7 +1098,7 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { ty: Ty<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, - origin: hir::ExistTyOrigin, + origin: hir::OpaqueTyOrigin, ) -> Ty<'tcx> { let infcx = self.infcx; let tcx = infcx.tcx; @@ -1123,7 +1129,7 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { debug!("instantiate_opaque_types: required_region_bounds={:?}", required_region_bounds); // Make sure that we are in fact defining the *entire* type - // (e.g., `existential type Foo<T: Bound>: Bar;` needs to be + // (e.g., `type Foo<T: Bound> = impl Bar;` needs to be // defined by a function like `fn foo<T: Bound>() -> Foo<T>`). debug!("instantiate_opaque_types: param_env={:#?}", self.param_env,); debug!("instantiate_opaque_types: generics={:#?}", tcx.generics_of(def_id),); @@ -1171,7 +1177,9 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { /// ```rust /// pub mod foo { /// pub mod bar { -/// pub existential type Baz; +/// pub trait Bar { .. } +/// +/// pub type Baz = impl Bar; /// /// fn f1() -> Baz { .. } /// } @@ -1180,18 +1188,17 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { /// } /// ``` /// -/// Here, `def_id` is the `DefId` of the defining use of the existential type (e.g., `f1` or `f2`), -/// and `opaque_hir_id` is the `HirId` of the definition of the existential type `Baz`. +/// Here, `def_id` is the `DefId` of the defining use of the opaque type (e.g., `f1` or `f2`), +/// and `opaque_hir_id` is the `HirId` of the definition of the opaque type `Baz`. /// For the above example, this function returns `true` for `f1` and `false` for `f2`. -pub fn may_define_existential_type( +pub fn may_define_opaque_type( tcx: TyCtxt<'_>, def_id: DefId, opaque_hir_id: hir::HirId, ) -> bool { let mut hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); - - // Named existential types can be defined by any siblings or children of siblings. + // Named opaque types can be defined by any siblings or children of siblings. let scope = tcx.hir().get_defining_scope(opaque_hir_id).expect("could not get defining scope"); // We walk up the node tree until we hit the root or the scope of the opaque type. while hir_id != scope && hir_id != hir::CRATE_HIR_ID { @@ -1200,7 +1207,7 @@ pub fn may_define_existential_type( // Syntactically, we are allowed to define the concrete type if: let res = hir_id == scope; trace!( - "may_define_existential_type(def={:?}, opaque_node={:?}) = {}", + "may_define_opaque_type(def={:?}, opaque_node={:?}) = {}", tcx.hir().get(hir_id), tcx.hir().get(opaque_hir_id), res diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 88de77829a6..1e4e3531e5f 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -638,7 +638,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> { } self.visit_nested_body(body_id) } - hir::ImplItemKind::Existential(..) | + hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::Type(..) => {} } } diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index b9a95219d31..233cec2ef7d 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -188,7 +188,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { } } } - hir::ImplItemKind::Existential(..) | + hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::Type(_) => false, } } @@ -263,7 +263,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { // worklist, as determined by the privacy pass hir::ItemKind::ExternCrate(_) | hir::ItemKind::Use(..) | - hir::ItemKind::Existential(..) | + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Ty(..) | hir::ItemKind::Static(..) | hir::ItemKind::Mod(..) | @@ -301,7 +301,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { self.visit_nested_body(body) } } - hir::ImplItemKind::Existential(..) | + hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::Type(_) => {} } } diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index f6c62d191fa..80f85bec879 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -268,17 +268,17 @@ enum Scope<'a> { track_lifetime_uses: bool, /// Whether or not this binder would serve as the parent - /// binder for abstract types introduced within. For example: + /// binder for opaque types introduced within. For example: /// /// fn foo<'a>() -> impl for<'b> Trait<Item = impl Trait2<'a>> /// - /// Here, the abstract types we create for the `impl Trait` + /// Here, the opaque types we create for the `impl Trait` /// and `impl Trait2` references will both have the `foo` item /// as their parent. When we get to `impl Trait2`, we find /// that it is nested within the `for<>` binder -- this flag /// allows us to skip that when looking for the parent binder - /// of the resulting abstract type. - abstract_type_parent: bool, + /// of the resulting opaque type. + opaque_type_parent: bool, s: ScopeRef<'a>, }, @@ -480,16 +480,16 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { }; self.with(scope, |_, this| intravisit::walk_item(this, item)); } - hir::ItemKind::Existential(hir::ExistTy { + hir::ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: Some(_), .. }) => { - // currently existential type declarations are just generated from impl Trait - // items. doing anything on this node is irrelevant, as we currently don't need + // Currently opaque type declarations are just generated from `impl Trait` + // items. Doing anything on this node is irrelevant, as we currently don't need // it. } hir::ItemKind::Ty(_, ref generics) - | hir::ItemKind::Existential(hir::ExistTy { + | hir::ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: None, ref generics, .. @@ -526,7 +526,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { let scope = Scope::Binder { lifetimes, next_early_index: index + non_lifetime_count, - abstract_type_parent: true, + opaque_type_parent: true, track_lifetime_uses, s: ROOT_SCOPE, }; @@ -574,7 +574,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { s: self.scope, next_early_index, track_lifetime_uses: true, - abstract_type_parent: false, + opaque_type_parent: false, }; self.with(scope, |old_scope, this| { // a bare fn has no bounds, so everything @@ -622,14 +622,14 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { hir::TyKind::Def(item_id, ref lifetimes) => { // Resolve the lifetimes in the bounds to the lifetime defs in the generics. // `fn foo<'a>() -> impl MyTrait<'a> { ... }` desugars to - // `abstract type MyAnonTy<'b>: MyTrait<'b>;` - // ^ ^ this gets resolved in the scope of - // the exist_ty generics + // `type MyAnonTy<'b> = impl MyTrait<'b>;` + // ^ ^ this gets resolved in the scope of + // the opaque_ty generics let (generics, bounds) = match self.tcx.hir().expect_item(item_id.id).node { - // named existential types are reached via TyKind::Path - // this arm is for `impl Trait` in the types of statics, constants and locals - hir::ItemKind::Existential(hir::ExistTy { + // Named opaque `impl Trait` types are reached via `TyKind::Path`. + // This arm is for `impl Trait` in the types of statics, constants and locals. + hir::ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: None, .. }) => { @@ -637,15 +637,15 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { return; } // RPIT (return position impl trait) - hir::ItemKind::Existential(hir::ExistTy { + hir::ItemKind::OpaqueTy(hir::OpaqueTy { ref generics, ref bounds, .. }) => (generics, bounds), - ref i => bug!("impl Trait pointed to non-existential type?? {:#?}", i), + ref i => bug!("`impl Trait` pointed to non-opaque type?? {:#?}", i), }; - // Resolve the lifetimes that are applied to the existential type. + // Resolve the lifetimes that are applied to the opaque type. // These are resolved in the current scope. // `fn foo<'a>() -> impl MyTrait<'a> { ... }` desugars to // `fn foo<'a>() -> MyAnonTy<'a> { ... }` @@ -687,7 +687,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { // We want to start our early-bound indices at the end of the parent scope, // not including any parent `impl Trait`s. - let mut index = self.next_early_index_for_abstract_type(); + let mut index = self.next_early_index_for_opaque_type(); debug!("visit_ty: index = {}", index); let mut elision = None; @@ -728,7 +728,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { next_early_index, s: this.scope, track_lifetime_uses: true, - abstract_type_parent: false, + opaque_type_parent: false, }; this.with(scope, |_old_scope, this| { this.visit_generics(generics); @@ -743,7 +743,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { next_early_index, s: self.scope, track_lifetime_uses: true, - abstract_type_parent: false, + opaque_type_parent: false, }; self.with(scope, |_old_scope, this| { this.visit_generics(generics); @@ -796,7 +796,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { next_early_index: index + non_lifetime_count, s: self.scope, track_lifetime_uses: true, - abstract_type_parent: true, + opaque_type_parent: true, }; self.with(scope, |_old_scope, this| { this.visit_generics(generics); @@ -848,14 +848,14 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { next_early_index: index + non_lifetime_count, s: self.scope, track_lifetime_uses: true, - abstract_type_parent: true, + opaque_type_parent: true, }; self.with(scope, |_old_scope, this| { this.visit_generics(generics); this.visit_ty(ty); }); } - Existential(ref bounds) => { + OpaqueTy(ref bounds) => { let generics = &impl_item.generics; let mut index = self.next_early_index(); let mut next_early_index = index; @@ -879,7 +879,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { next_early_index, s: self.scope, track_lifetime_uses: true, - abstract_type_parent: true, + opaque_type_parent: true, }; self.with(scope, |_old_scope, this| { this.visit_generics(generics); @@ -967,7 +967,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { s: self.scope, next_early_index, track_lifetime_uses: true, - abstract_type_parent: false, + opaque_type_parent: false, }; let result = self.with(scope, |old_scope, this| { this.check_lifetime_params(old_scope, &bound_generic_params); @@ -1037,7 +1037,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { s: self.scope, next_early_index, track_lifetime_uses: true, - abstract_type_parent: false, + opaque_type_parent: false, }; self.with(scope, |old_scope, this| { this.check_lifetime_params(old_scope, &trait_ref.bound_generic_params); @@ -1254,7 +1254,7 @@ fn compute_object_lifetime_defaults(tcx: TyCtxt<'_>) -> HirIdMap<Vec<ObjectLifet hir::ItemKind::Struct(_, ref generics) | hir::ItemKind::Union(_, ref generics) | hir::ItemKind::Enum(_, ref generics) - | hir::ItemKind::Existential(hir::ExistTy { + | hir::ItemKind::OpaqueTy(hir::OpaqueTy { ref generics, impl_trait_fn: None, .. @@ -1753,7 +1753,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { lifetimes, next_early_index, s: self.scope, - abstract_type_parent: true, + opaque_type_parent: true, track_lifetime_uses: false, }; self.with(scope, move |old_scope, this| { @@ -1762,7 +1762,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { }); } - fn next_early_index_helper(&self, only_abstract_type_parent: bool) -> u32 { + fn next_early_index_helper(&self, only_opaque_type_parent: bool) -> u32 { let mut scope = self.scope; loop { match *scope { @@ -1770,9 +1770,9 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { Scope::Binder { next_early_index, - abstract_type_parent, + opaque_type_parent, .. - } if (!only_abstract_type_parent || abstract_type_parent) => + } if (!only_opaque_type_parent || opaque_type_parent) => { return next_early_index } @@ -1792,10 +1792,10 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { } /// Returns the next index one would use for an `impl Trait` that - /// is being converted into an `abstract type`. This will be the + /// is being converted into an opaque type alias `impl Trait`. This will be the /// next early index from the enclosing item, for the most - /// part. See the `abstract_type_parent` field for more info. - fn next_early_index_for_abstract_type(&self) -> u32 { + /// part. See the `opaque_type_parent` field for more info. + fn next_early_index_for_opaque_type(&self) -> u32 { self.next_early_index_helper(false) } diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs index 20acf443406..38263f26a59 100644 --- a/src/librustc/traits/project.rs +++ b/src/librustc/traits/project.rs @@ -1492,7 +1492,7 @@ fn confirm_impl_candidate<'cx, 'tcx>( }; } let substs = translate_substs(selcx.infcx(), param_env, impl_def_id, substs, assoc_ty.node); - let ty = if let ty::AssocKind::Existential = assoc_ty.item.kind { + 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 { diff --git a/src/librustc/traits/specialize/specialization_graph.rs b/src/librustc/traits/specialize/specialization_graph.rs index f736c5ef9b1..b43881defdb 100644 --- a/src/librustc/traits/specialize/specialization_graph.rs +++ b/src/librustc/traits/specialize/specialization_graph.rs @@ -484,13 +484,13 @@ impl<'tcx> Ancestors<'tcx> { | (Const, Const) | (Method, Method) | (Type, Type) - | (Type, Existential) + | (Type, OpaqueTy) => tcx.hygienic_eq(impl_item.ident, trait_item_name, trait_def_id), | (Const, _) | (Method, _) | (Type, _) - | (Existential, _) + | (OpaqueTy, _) => false, }).map(move |item| NodeItem { node: node, item: item }) }) diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 46b8114030f..ca6603b5853 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -281,14 +281,14 @@ impl<'a, V> LocalTableInContextMut<'a, V> { } } -/// All information necessary to validate and reveal an `impl Trait` or `existential Type` +/// All information necessary to validate and reveal an `impl Trait`. #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)] pub struct ResolvedOpaqueTy<'tcx> { /// The revealed type as seen by this function. pub concrete_type: Ty<'tcx>, /// Generic parameters on the opaque type as passed by this function. - /// For `existential type Foo<A, B>; fn foo<T, U>() -> Foo<T, U> { .. }` this is `[T, U]`, not - /// `[A, B]` + /// For `type Foo<A, B> = impl Bar<A, B>; fn foo<T, U>() -> Foo<T, U> { .. }` + /// this is `[T, U]`, not `[A, B]`. pub substs: SubstsRef<'tcx>, } @@ -392,9 +392,9 @@ pub struct TypeckTables<'tcx> { /// read-again by borrowck. pub free_region_map: FreeRegionMap<'tcx>, - /// All the existential types that are restricted to concrete types - /// by this function - pub concrete_existential_types: FxHashMap<DefId, ResolvedOpaqueTy<'tcx>>, + /// All the opaque types that are restricted to concrete types + /// by this function. + pub concrete_opaque_types: FxHashMap<DefId, ResolvedOpaqueTy<'tcx>>, /// Given the closure ID this map provides the list of UpvarIDs used by it. /// The upvarID contains the HIR node ID and it also contains the full path @@ -424,7 +424,7 @@ impl<'tcx> TypeckTables<'tcx> { used_trait_imports: Lrc::new(Default::default()), tainted_by_errors: false, free_region_map: Default::default(), - concrete_existential_types: Default::default(), + concrete_opaque_types: Default::default(), upvar_list: Default::default(), } } @@ -733,7 +733,7 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx> { ref used_trait_imports, tainted_by_errors, ref free_region_map, - ref concrete_existential_types, + ref concrete_opaque_types, ref upvar_list, } = *self; @@ -777,7 +777,7 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx> { used_trait_imports.hash_stable(hcx, hasher); tainted_by_errors.hash_stable(hcx, hasher); free_region_map.hash_stable(hcx, hasher); - concrete_existential_types.hash_stable(hcx, hasher); + concrete_opaque_types.hash_stable(hcx, hasher); upvar_list.hash_stable(hcx, hasher); }) } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 44897c8e903..8e170578227 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -185,7 +185,7 @@ pub struct AssocItem { pub enum AssocKind { Const, Method, - Existential, + OpaqueTy, Type } @@ -195,7 +195,7 @@ impl AssocItem { AssocKind::Const => DefKind::AssocConst, AssocKind::Method => DefKind::Method, AssocKind::Type => DefKind::AssocTy, - AssocKind::Existential => DefKind::AssocExistential, + AssocKind::OpaqueTy => DefKind::AssocOpaqueTy, } } @@ -203,7 +203,7 @@ impl AssocItem { /// for ! pub fn relevant_for_never(&self) -> bool { match self.kind { - AssocKind::Existential | + AssocKind::OpaqueTy | AssocKind::Const | AssocKind::Type => true, // FIXME(canndrew): Be more thorough here, check if any argument is uninhabited. @@ -221,7 +221,8 @@ impl AssocItem { tcx.fn_sig(self.def_id).skip_binder().to_string() } ty::AssocKind::Type => format!("type {};", self.ident), - ty::AssocKind::Existential => format!("existential 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)) } @@ -2822,7 +2823,7 @@ impl<'tcx> TyCtxt<'tcx> { (ty::AssocKind::Method, has_self) } hir::AssocItemKind::Type => (ty::AssocKind::Type, false), - hir::AssocItemKind::Existential => bug!("only impls can have existentials"), + hir::AssocItemKind::OpaqueTy => bug!("only impls can have opaque types"), }; AssocItem { @@ -2848,7 +2849,7 @@ impl<'tcx> TyCtxt<'tcx> { (ty::AssocKind::Method, has_self) } hir::AssocItemKind::Type => (ty::AssocKind::Type, false), - hir::AssocItemKind::Existential => (ty::AssocKind::Existential, false), + hir::AssocItemKind::OpaqueTy => (ty::AssocKind::OpaqueTy, false), }; AssocItem { @@ -3213,8 +3214,8 @@ fn trait_of_item(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> { pub fn is_impl_trait_defn(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> { if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) { if let Node::Item(item) = tcx.hir().get(hir_id) { - if let hir::ItemKind::Existential(ref exist_ty) = item.node { - return exist_ty.impl_trait_fn; + if let hir::ItemKind::OpaqueTy(ref opaque_ty) = item.node { + return opaque_ty.impl_trait_fn; } } } diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 77b8ebba216..b8533424740 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -185,7 +185,7 @@ pub enum TyKind<'tcx> { /// Opaque (`impl Trait`) type found in a return type. /// The `DefId` comes either from /// * the `impl Trait` ast::Ty node, - /// * or the `existential type` declaration + /// * or the `type Foo = impl Trait` declaration /// The substitutions are for the generics of the function in question. /// After typeck, the concrete type can be found in the `types` map. Opaque(DefId, SubstsRef<'tcx>), diff --git a/src/librustc/ty/wf.rs b/src/librustc/ty/wf.rs index 1979b4317a7..d32c32af29e 100644 --- a/src/librustc/ty/wf.rs +++ b/src/librustc/ty/wf.rs @@ -362,7 +362,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> { // should've been checked by the instantiation // of whatever returned this exact `impl Trait`. - // for named existential types we still need to check them + // for named opaque `impl Trait` types we still need to check them if super::is_impl_trait_defn(self.infcx.tcx, did).is_none() { let obligations = self.nominal_obligations(did, substs); self.out.extend(obligations); diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index aa98ebae543..e621101324d 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -406,7 +406,7 @@ impl DirtyCleanVisitor<'tcx> { ImplItemKind::Method(..) => ("Node::ImplItem", LABELS_FN_IN_IMPL), ImplItemKind::Const(..) => ("NodeImplConst", LABELS_CONST_IN_IMPL), ImplItemKind::Type(..) => ("NodeImplType", LABELS_CONST_IN_IMPL), - ImplItemKind::Existential(..) => ("NodeImplType", LABELS_CONST_IN_IMPL), + ImplItemKind::OpaqueTy(..) => ("NodeImplType", LABELS_CONST_IN_IMPL), } }, _ => self.tcx.sess.span_fatal( diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 6ac68e86e4b..08a8d400779 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -461,7 +461,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { hir::ImplItemKind::Const(..) => "an associated constant", hir::ImplItemKind::Method(..) => "a method", hir::ImplItemKind::Type(_) => "an associated type", - hir::ImplItemKind::Existential(_) => "an associated existential type", + hir::ImplItemKind::OpaqueTy(_) => "an associated `impl Trait` type", }; self.check_missing_docs_attrs(cx, Some(impl_item.hir_id), diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index 8e76dbb882e..335ce868894 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -413,9 +413,9 @@ impl<'tcx> EntryKind<'tcx> { EntryKind::Type => DefKind::TyAlias, EntryKind::TypeParam => DefKind::TyParam, EntryKind::ConstParam => DefKind::ConstParam, - EntryKind::Existential => DefKind::Existential, + EntryKind::OpaqueTy => DefKind::OpaqueTy, EntryKind::AssocType(_) => DefKind::AssocTy, - EntryKind::AssocExistential(_) => DefKind::AssocExistential, + EntryKind::AssocOpaqueTy(_) => DefKind::AssocOpaqueTy, EntryKind::Mod(_) => DefKind::Mod, EntryKind::Variant(_) => DefKind::Variant, EntryKind::Trait(_) => DefKind::Trait, @@ -910,8 +910,8 @@ impl<'a, 'tcx> CrateMetadata { EntryKind::AssocType(container) => { (ty::AssocKind::Type, container, false) } - EntryKind::AssocExistential(container) => { - (ty::AssocKind::Existential, container, false) + EntryKind::AssocOpaqueTy(container) => { + (ty::AssocKind::OpaqueTy, container, false) } _ => bug!("cannot get associated-item of `{:?}`", def_key) }; diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index 567b6b1a891..28252117dd2 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -868,8 +868,7 @@ impl EncodeContext<'tcx> { })) } ty::AssocKind::Type => EntryKind::AssocType(container), - ty::AssocKind::Existential => - span_bug!(ast_item.span, "existential type in trait"), + ty::AssocKind::OpaqueTy => span_bug!(ast_item.span, "opaque type in trait"), }; Entry { @@ -893,7 +892,7 @@ impl EncodeContext<'tcx> { None } } - ty::AssocKind::Existential => unreachable!(), + ty::AssocKind::OpaqueTy => unreachable!(), }, inherent_impls: LazySeq::empty(), variances: if trait_item.kind == ty::AssocKind::Method { @@ -964,7 +963,7 @@ impl EncodeContext<'tcx> { has_self: impl_item.method_has_self_argument, })) } - ty::AssocKind::Existential => EntryKind::AssocExistential(container), + ty::AssocKind::OpaqueTy => EntryKind::AssocOpaqueTy(container), ty::AssocKind::Type => EntryKind::AssocType(container) }; @@ -980,7 +979,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::Existential(..) | + hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::Type(..) => false, }; @@ -1096,7 +1095,7 @@ impl EncodeContext<'tcx> { hir::ItemKind::ForeignMod(_) => EntryKind::ForeignMod, hir::ItemKind::GlobalAsm(..) => EntryKind::GlobalAsm, hir::ItemKind::Ty(..) => EntryKind::Type, - hir::ItemKind::Existential(..) => EntryKind::Existential, + hir::ItemKind::OpaqueTy(..) => EntryKind::OpaqueTy, hir::ItemKind::Enum(..) => EntryKind::Enum(get_repr_options(tcx, def_id)), hir::ItemKind::Struct(ref struct_def, _) => { let variant = tcx.adt_def(def_id).non_enum_variant(); @@ -1229,7 +1228,7 @@ impl EncodeContext<'tcx> { hir::ItemKind::Const(..) | hir::ItemKind::Fn(..) | hir::ItemKind::Ty(..) | - hir::ItemKind::Existential(..) | + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Enum(..) | hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) | @@ -1253,7 +1252,7 @@ impl EncodeContext<'tcx> { hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) | hir::ItemKind::Impl(..) | - hir::ItemKind::Existential(..) | + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Trait(..) => Some(self.encode_generics(def_id)), hir::ItemKind::TraitAlias(..) => Some(self.encode_generics(def_id)), _ => None, @@ -1267,7 +1266,7 @@ impl EncodeContext<'tcx> { hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) | hir::ItemKind::Impl(..) | - hir::ItemKind::Existential(..) | + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) => Some(self.encode_predicates(def_id)), _ => None, @@ -1763,7 +1762,7 @@ impl EncodeContext<'tcx> { hir::ItemKind::ExternCrate(..) | hir::ItemKind::Use(..) | hir::ItemKind::Ty(..) | - hir::ItemKind::Existential(..) | + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::TraitAlias(..) => { // no sub-item recording needed in these cases } diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs index b7dd1d03e44..c0ac6915933 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -239,7 +239,7 @@ pub enum EntryKind<'tcx> { Type, TypeParam, ConstParam, - Existential, + OpaqueTy, Enum(ReprOptions), Field, Variant(Lazy<VariantData<'tcx>>), @@ -255,7 +255,7 @@ pub enum EntryKind<'tcx> { Impl(Lazy<ImplData<'tcx>>), Method(Lazy<MethodData<'tcx>>), AssocType(AssocContainer), - AssocExistential(AssocContainer), + AssocOpaqueTy(AssocContainer), AssocConst(AssocContainer, ConstQualif, Lazy<RenderedConst>), TraitAlias(Lazy<TraitAliasData<'tcx>>), } diff --git a/src/librustc_mir/borrow_check/nll/type_check/input_output.rs b/src/librustc_mir/borrow_check/nll/type_check/input_output.rs index 3954d62ad5c..99661b1f737 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/input_output.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/input_output.rs @@ -1,7 +1,7 @@ //! This module contains code to equate the input/output types appearing //! in the MIR with the expected input/output types from the function //! signature. This requires a bit of processing, as the expected types -//! are supplied to us before normalization and may contain existential +//! are supplied to us before normalization and may contain opaque //! `impl Trait` instances. In contrast, the input/output types found in //! the MIR (specifically, in the special local variables for the //! `RETURN_PLACE` the MIR arguments) are always fully normalized (and @@ -113,8 +113,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { self.equate_normalized_input_or_output(ur_yield_ty, mir_yield_ty, yield_span); } - // Return types are a bit more complex. They may contain existential `impl Trait` - // types. + // Return types are a bit more complex. They may contain opaque `impl Trait` types. let mir_output_ty = body.local_decls[RETURN_PLACE].ty; let output_span = body.local_decls[RETURN_PLACE].source_info.span; if let Err(terr) = self.eq_opaque_type_and_type( diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs index f10d505fe89..b27be43dda2 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs @@ -1291,10 +1291,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { concrete_is_opaque ); - // concrete_is_opaque is `true` when we're using an existential + // concrete_is_opaque is `true` when we're using an opaque `impl Trait` // type without 'revealing' it. For example, code like this: // - // existential type Foo: Debug; + // type Foo = impl Debug; // fn foo1() -> Foo { ... } // fn foo2() -> Foo { foo1() } // @@ -1303,8 +1303,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { // // When this occurs, we do *not* want to try to equate // the concrete type with the underlying defining type - // of the existential type - this will always fail, since - // the defining type of an existential type is always + // of the opaque type - this will always fail, since + // the defining type of an opaque type is always // some other type (e.g. not itself) // Essentially, none of the normal obligations apply here - // we're just passing around some unknown opaque type, diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index ee0f9119544..b378dadce58 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -972,7 +972,7 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { hir::ItemKind::Ty(..) | hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) | - hir::ItemKind::Existential(..) | + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Mod(..) => { // Nothing to do, just keep recursing... } diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs index 7ad37e65f71..3c31bcef32b 100644 --- a/src/librustc_passes/ast_validation.rs +++ b/src/librustc_passes/ast_validation.rs @@ -667,7 +667,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> { "unions cannot have zero fields"); } } - ItemKind::Existential(ref bounds, _) => { + ItemKind::OpaqueTy(ref bounds, _) => { if !bounds.iter() .any(|b| if let GenericBound::Trait(..) = *b { true } else { false }) { let msp = MultiSpan::from_spans(bounds.iter() diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index e291f40ffd2..ac18f0e440b 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -533,7 +533,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { hir::ItemKind::GlobalAsm(..) | hir::ItemKind::Fn(..) | hir::ItemKind::Mod(..) | hir::ItemKind::Static(..) | hir::ItemKind::Struct(..) | hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) | - hir::ItemKind::Existential(..) | + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Ty(..) | hir::ItemKind::Union(..) | hir::ItemKind::Use(..) => { if item.vis.node.is_pub() { self.prev_level } else { None } } @@ -584,7 +584,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { } } } - hir::ItemKind::Existential(..) | + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Use(..) | hir::ItemKind::Static(..) | hir::ItemKind::Const(..) | @@ -612,7 +612,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { } // The interface is empty. hir::ItemKind::GlobalAsm(..) => {} - hir::ItemKind::Existential(..) => { + hir::ItemKind::OpaqueTy(..) => { // FIXME: This is some serious pessimization intended to workaround deficiencies // in the reachability pass (`middle/reachable.rs`). Types are marked as link-time // reachable if they are returned via `impl Trait`, even from private functions. @@ -1113,7 +1113,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> { DefKind::Method | DefKind::AssocConst | DefKind::AssocTy - | DefKind::AssocExistential + | DefKind::AssocOpaqueTy | DefKind::Static => true, _ => false, } @@ -1370,7 +1370,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { self.access_levels.is_reachable( impl_item_ref.id.hir_id) } - hir::ImplItemKind::Existential(..) | + hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::Type(_) => false, } }); @@ -1707,9 +1707,9 @@ impl<'a, 'tcx> PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> { let (check_ty, is_assoc_ty) = match assoc_item_kind { AssocItemKind::Const | AssocItemKind::Method { .. } => (true, false), AssocItemKind::Type => (defaultness.has_value(), true), - // `ty()` for existential types is the underlying type, + // `ty()` for opaque types is the underlying type, // it's not a part of interface, so we skip it. - AssocItemKind::Existential => (false, true), + AssocItemKind::OpaqueTy => (false, true), }; check.in_assoc_ty = is_assoc_ty; check.generics().predicates(); @@ -1742,8 +1742,8 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> hir::ItemKind::Fn(..) | hir::ItemKind::Ty(..) => { self.check(item.hir_id, item_visibility).generics().predicates().ty(); } - hir::ItemKind::Existential(..) => { - // `ty()` for existential types is the underlying type, + hir::ItemKind::OpaqueTy(..) => { + // `ty()` for opaque types is the underlying type, // it's not a part of interface, so we skip it. self.check(item.hir_id, item_visibility).generics().predicates(); } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 41349cf72a1..b66cc9e57f7 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -464,8 +464,8 @@ impl<'a> Resolver<'a> { self.define(parent, ident, TypeNS, (res, vis, sp, expansion)); } - ItemKind::Existential(_, _) => { - let res = Res::Def(DefKind::Existential, self.definitions.local_def_id(item.id)); + ItemKind::OpaqueTy(_, _) => { + let res = Res::Def(DefKind::OpaqueTy, self.definitions.local_def_id(item.id)); self.define(parent, ident, TypeNS, (res, vis, sp, expansion)); } @@ -656,7 +656,7 @@ impl<'a> Resolver<'a> { Res::Def(DefKind::Variant, _) | Res::Def(DefKind::TyAlias, _) | Res::Def(DefKind::ForeignTy, _) - | Res::Def(DefKind::Existential, _) + | Res::Def(DefKind::OpaqueTy, _) | Res::Def(DefKind::TraitAlias, _) | Res::PrimTy(..) | Res::ToolMod => { diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index c8dd8282fd0..a49be7c27c9 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -605,7 +605,7 @@ impl<'a> PathSource<'a> { | Res::PrimTy(..) | Res::Def(DefKind::TyParam, _) | Res::SelfTy(..) - | Res::Def(DefKind::Existential, _) + | Res::Def(DefKind::OpaqueTy, _) | Res::Def(DefKind::ForeignTy, _) => true, _ => false, }, @@ -2710,7 +2710,7 @@ impl<'a> Resolver<'a> { match item.node { ItemKind::Ty(_, ref generics) | - ItemKind::Existential(_, ref generics) | + ItemKind::OpaqueTy(_, ref generics) | ItemKind::Fn(_, _, ref generics, _) => { self.with_generic_param_rib( HasGenericParams(generics, ItemRibKind), @@ -3089,7 +3089,7 @@ impl<'a> Resolver<'a> { this.visit_ty(ty); } - ImplItemKind::Existential(ref bounds) => { + ImplItemKind::OpaqueTy(ref bounds) => { // If this is a trait impl, ensure the type // exists in trait this.check_trait_item(impl_item.ident, diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index 6fce7ca1f33..3abec9307ee 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -1173,7 +1173,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> { // trait. self.visit_ty(ty) } - ast::ImplItemKind::Existential(ref bounds) => { + ast::ImplItemKind::OpaqueTy(ref bounds) => { // 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 // trait. @@ -1428,7 +1428,7 @@ impl<'l, 'tcx> Visitor<'l> for DumpVisitor<'l, 'tcx> { self.visit_ty(&ty); self.process_generic_params(ty_params, &qualname, item.id); } - Existential(ref _bounds, ref ty_params) => { + OpaqueTy(ref _bounds, ref ty_params) => { let qualname = format!("::{}", self.tcx.def_path_str(self.tcx.hir().local_def_id_from_node_id(item.id))); // FIXME do something with _bounds diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 634e8db9ea6..c699a8834e0 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -725,10 +725,10 @@ impl<'l, 'tcx> SaveContext<'l, 'tcx> { Res::Def(HirDefKind::TyAlias, def_id) | Res::Def(HirDefKind::ForeignTy, def_id) | Res::Def(HirDefKind::TraitAlias, def_id) | - Res::Def(HirDefKind::AssocExistential, def_id) | + Res::Def(HirDefKind::AssocOpaqueTy, def_id) | Res::Def(HirDefKind::AssocTy, def_id) | Res::Def(HirDefKind::Trait, def_id) | - Res::Def(HirDefKind::Existential, def_id) | + Res::Def(HirDefKind::OpaqueTy, def_id) | Res::Def(HirDefKind::TyParam, def_id) => { Some(Ref { kind: RefKind::Type, diff --git a/src/librustc_save_analysis/sig.rs b/src/librustc_save_analysis/sig.rs index db8b5eacd94..cbfaf91cdfc 100644 --- a/src/librustc_save_analysis/sig.rs +++ b/src/librustc_save_analysis/sig.rs @@ -438,18 +438,6 @@ impl Sig for ast::Item { refs: vec![], }) } - ast::ItemKind::Existential(ref bounds, ref generics) => { - let text = "existential type ".to_owned(); - let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?; - - if !bounds.is_empty() { - sig.text.push_str(": "); - sig.text.push_str(&pprust::bounds_to_string(bounds)); - } - sig.text.push(';'); - - Ok(sig) - } ast::ItemKind::Ty(ref ty, ref generics) => { let text = "type ".to_owned(); let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?; @@ -461,6 +449,16 @@ impl Sig for ast::Item { Ok(merge_sigs(sig.text.clone(), vec![sig, ty])) } + ast::ItemKind::OpaqueTy(ref bounds, ref generics) => { + let text = "type ".to_owned(); + let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?; + + sig.text.push_str(" = impl "); + sig.text.push_str(&pprust::bounds_to_string(bounds)); + sig.text.push(';'); + + Ok(sig) + } ast::ItemKind::Enum(_, ref generics) => { let text = "enum ".to_owned(); let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?; diff --git a/src/librustc_traits/lowering/mod.rs b/src/librustc_traits/lowering/mod.rs index c81b1dc8974..1558ce1bced 100644 --- a/src/librustc_traits/lowering/mod.rs +++ b/src/librustc_traits/lowering/mod.rs @@ -173,7 +173,7 @@ crate fn program_clauses_for(tcx: TyCtxt<'_>, def_id: DefId) -> Clauses<'_> { | Some(DefKind::Enum) | Some(DefKind::TyAlias) | Some(DefKind::Union) - | Some(DefKind::Existential) => program_clauses_for_type_def(tcx, def_id), + | Some(DefKind::OpaqueTy) => program_clauses_for_type_def(tcx, def_id), _ => List::empty(), }, DefPathData::Impl => program_clauses_for_impl(tcx, def_id), diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 5799e58a727..e8e0dd8425b 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -1956,7 +1956,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { let span = path.span; match path.res { - Res::Def(DefKind::Existential, did) => { + Res::Def(DefKind::OpaqueTy, did) => { // Check for desugared `impl Trait`. assert!(ty::is_impl_trait_defn(tcx, did).is_none()); let item_segment = path.segments.split_last().unwrap(); diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 75428efa73c..1c01c8408be 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -1489,7 +1489,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> { match self.mode { Mode::MethodCall => item.method_has_self_argument, Mode::Path => match item.kind { - ty::AssocKind::Existential | + ty::AssocKind::OpaqueTy | ty::AssocKind::Type => false, ty::AssocKind::Method | ty::AssocKind::Const => true }, diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 1b4dbfe4be6..8d6f9185962 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1330,10 +1330,10 @@ fn check_opaque<'tcx>( def_id: DefId, substs: SubstsRef<'tcx>, span: Span, - origin: &hir::ExistTyOrigin + origin: &hir::OpaqueTyOrigin ) { if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) { - if let hir::ExistTyOrigin::AsyncFn = origin { + if let hir::OpaqueTyOrigin::AsyncFn = origin { struct_span_err!( tcx.sess, span, E0733, "recursion in an `async fn` requires boxing", @@ -1403,7 +1403,7 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) { hir::ItemKind::Union(..) => { check_union(tcx, it.hir_id, it.span); } - hir::ItemKind::Existential(hir::ExistTy{origin, ..}) => { + hir::ItemKind::OpaqueTy(hir::OpaqueTy{origin, ..}) => { let def_id = tcx.hir().local_def_id(it.hir_id); let substs = InternalSubsts::identity_for_item(tcx, def_id); @@ -1542,7 +1542,7 @@ fn check_specialization_validity<'tcx>( let kind = match impl_item.node { hir::ImplItemKind::Const(..) => ty::AssocKind::Const, hir::ImplItemKind::Method(..) => ty::AssocKind::Method, - hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential, + hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy, hir::ImplItemKind::Type(_) => ty::AssocKind::Type }; @@ -1639,7 +1639,7 @@ fn check_impl_items_against_trait<'tcx>( err.emit() } } - hir::ImplItemKind::Existential(..) | + hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::Type(_) => { if ty_trait_item.kind == ty::AssocKind::Type { if ty_trait_item.defaultness.has_value() { diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 32f1f8c6188..c1d8fde3be1 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -8,7 +8,7 @@ use rustc::ty::subst::{Subst, InternalSubsts}; use rustc::util::nodemap::{FxHashSet, FxHashMap}; use rustc::mir::interpret::ConstValue; use rustc::middle::lang_items; -use rustc::infer::opaque_types::may_define_existential_type; +use rustc::infer::opaque_types::may_define_opaque_type; use syntax::ast; use syntax::feature_gate::{self, GateIssue}; @@ -218,8 +218,8 @@ fn check_associated_item( fcx.register_wf_obligation(ty, span, code.clone()); } } - ty::AssocKind::Existential => { - // do nothing, existential types check themselves + ty::AssocKind::OpaqueTy => { + // Do nothing: opaque types check themselves. } } @@ -560,7 +560,7 @@ fn check_where_clauses<'tcx, 'fcx>( let mut predicates = predicates.instantiate_identity(fcx.tcx); if let Some(return_ty) = return_ty { - predicates.predicates.extend(check_existential_types(tcx, fcx, def_id, span, return_ty)); + predicates.predicates.extend(check_opaque_types(tcx, fcx, def_id, span, return_ty)); } let predicates = fcx.normalize_associated_types_in(span, &predicates); @@ -605,14 +605,14 @@ fn check_fn_or_method<'fcx, 'tcx>( check_where_clauses(tcx, fcx, span, def_id, Some(sig.output())); } -/// Checks "defining uses" of existential types to ensure that they meet the restrictions laid for -/// "higher-order pattern unification". +/// Checks "defining uses" of opaque `impl Trait` types to ensure that they meet the restrictions +/// laid for "higher-order pattern unification". /// This ensures that inference is tractable. -/// In particular, definitions of existential types can only use other generics as arguments, +/// In particular, definitions of opaque types can only use other generics as arguments, /// and they cannot repeat an argument. Example: /// /// ```rust -/// existential type Foo<A, B>; +/// type Foo<A, B> = impl Bar<A, B>; /// /// // Okay -- `Foo` is applied to two distinct, generic types. /// fn a<T, U>() -> Foo<T, U> { .. } @@ -624,26 +624,26 @@ fn check_fn_or_method<'fcx, 'tcx>( /// fn b<T>() -> Foo<T, u32> { .. } /// ``` /// -fn check_existential_types<'fcx, 'tcx>( +fn check_opaque_types<'fcx, 'tcx>( tcx: TyCtxt<'tcx>, fcx: &FnCtxt<'fcx, 'tcx>, fn_def_id: DefId, span: Span, ty: Ty<'tcx>, ) -> Vec<ty::Predicate<'tcx>> { - trace!("check_existential_types(ty={:?})", ty); + trace!("check_opaque_types(ty={:?})", ty); let mut substituted_predicates = Vec::new(); ty.fold_with(&mut ty::fold::BottomUpFolder { tcx: fcx.tcx, ty_op: |ty| { if let ty::Opaque(def_id, substs) = ty.sty { - trace!("check_existential_types: opaque_ty, {:?}, {:?}", def_id, substs); + trace!("check_opaque_types: opaque_ty, {:?}, {:?}", def_id, substs); let generics = tcx.generics_of(def_id); - // Only check named existential types defined in this crate. + // Only check named `impl Trait` types defined in this crate. if generics.parent.is_none() && def_id.is_local() { let opaque_hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); - if may_define_existential_type(tcx, fn_def_id, opaque_hir_id) { - trace!("check_existential_types: may define, generics={:#?}", generics); + if may_define_opaque_type(tcx, fn_def_id, opaque_hir_id) { + trace!("check_opaque_types: may define, generics={:#?}", generics); let mut seen: FxHashMap<_, Vec<_>> = FxHashMap::default(); for (subst, param) in substs.iter().zip(&generics.params) { match subst.unpack() { @@ -654,7 +654,7 @@ fn check_existential_types<'fcx, 'tcx>( tcx.sess .struct_span_err( span, - "non-defining existential type use \ + "non-defining opaque type use \ in defining scope", ) .span_note( @@ -676,14 +676,14 @@ fn check_existential_types<'fcx, 'tcx>( .sess .struct_span_err( span, - "non-defining existential type use \ + "non-defining opaque type use \ in defining scope", ) .span_label( param_span, - "cannot use static lifetime, use a bound lifetime \ + "cannot use static lifetime; use a bound lifetime \ instead or remove the lifetime parameter from the \ - existential type", + opaque type", ) .emit(); } else { @@ -697,7 +697,7 @@ fn check_existential_types<'fcx, 'tcx>( tcx.sess .struct_span_err( span, - "non-defining existential type use \ + "non-defining opaque type use \ in defining scope", ) .span_note( @@ -719,7 +719,7 @@ fn check_existential_types<'fcx, 'tcx>( .sess .struct_span_err( span, - "non-defining existential type use \ + "non-defining opaque type use \ in defining scope", ). span_note( @@ -729,21 +729,21 @@ fn check_existential_types<'fcx, 'tcx>( .emit(); } } - } // if may_define_existential_type + } // if may_define_opaque_type - // Now register the bounds on the parameters of the existential type + // Now register the bounds on the parameters of the opaque type // so the parameters given by the function need to fulfill them. // - // existential type Foo<T: Bar>: 'static; + // type Foo<T: Bar> = impl Baz + 'static; // fn foo<U>() -> Foo<U> { .. *} // // becomes // - // existential type Foo<T: Bar>: 'static; + // type Foo<T: Bar> = impl Baz + 'static; // fn foo<U: Bar>() -> Foo<U> { .. *} let predicates = tcx.predicates_of(def_id); trace!( - "check_existential_types: may define, predicates={:#?}", + "check_opaque_types: may define, predicates={:#?}", predicates, ); for &(pred, _) in predicates.predicates.iter() { @@ -753,7 +753,7 @@ fn check_existential_types<'fcx, 'tcx>( substituted_predicates.push(substituted_pred); } } - } // if is_named_existential_type + } // if is_named_opaque_type } // if let Opaque ty }, diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index cfafdd02a6a..67a8ecaf1da 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -443,10 +443,10 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { // * `fn foo<T: Bound + Other>() -> Foo<T>` // from being defining. - // Also replace all generic params with the ones from the existential type + // Also replace all generic params with the ones from the opaque type // definition so that // ```rust - // existential type Foo<T>: 'static; + // type Foo<T> = impl Baz + 'static; // fn foo<U>() -> Foo<U> { .. } // ``` // figures out the concrete type with `U`, but the stored type is with `T`. @@ -464,8 +464,8 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { } if !opaque_defn.substs.has_local_value() { - // We only want to add an entry into `concrete_existential_types` - // if we actually found a defining usage of this existential type. + // We only want to add an entry into `concrete_opaque_types` + // if we actually found a defining usage of this opaque type. // Otherwise, we do nothing - we'll either find a defining usage // in some other location, or we'll end up emitting an error due // to the lack of defining usage @@ -476,14 +476,14 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { }; let old = self.tables - .concrete_existential_types + .concrete_opaque_types .insert(def_id, new); if let Some(old) = old { if old.concrete_type != definition_ty || old.substs != opaque_defn.substs { span_bug!( span, "visit_opaque_types tried to write different types for the same \ - existential type: {:?}, {:?}, {:?}, {:?}", + opaque type: {:?}, {:?}, {:?}, {:?}", def_id, definition_ty, opaque_defn, diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 395e266ae46..15687eaa943 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -294,7 +294,7 @@ fn type_param_predicates( ItemKind::Fn(.., ref generics, _) | ItemKind::Impl(_, _, _, ref generics, ..) | ItemKind::Ty(_, ref generics) - | ItemKind::Existential(ExistTy { + | ItemKind::OpaqueTy(OpaqueTy { ref generics, impl_trait_fn: None, .. @@ -456,12 +456,12 @@ fn convert_item(tcx: TyCtxt<'_>, item_id: hir::HirId) { } // Desugared from `impl Trait`, so visited by the function's return type. - hir::ItemKind::Existential(hir::ExistTy { + hir::ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: Some(_), .. }) => {} - hir::ItemKind::Existential(..) + hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Ty(..) | hir::ItemKind::Static(..) | hir::ItemKind::Const(..) @@ -896,7 +896,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { .. }) => Some(tcx.closure_base_def_id(def_id)), Node::Item(item) => match item.node { - ItemKind::Existential(hir::ExistTy { impl_trait_fn, .. }) => impl_trait_fn, + ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn, .. }) => impl_trait_fn, _ => None, }, _ => None, @@ -920,7 +920,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { ItemKind::Ty(_, ref generics) | ItemKind::Enum(_, ref generics) | ItemKind::Struct(_, ref generics) - | ItemKind::Existential(hir::ExistTy { ref generics, .. }) + | ItemKind::OpaqueTy(hir::OpaqueTy { ref generics, .. }) | ItemKind::Union(_, ref generics) => { allow_defaults = true; generics @@ -1210,7 +1210,7 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option<Ty< icx.to_ty(ty) } }, - ImplItemKind::Existential(_) => { + ImplItemKind::OpaqueTy(_) => { if tcx .impl_trait_ref(tcx.hir().get_parent_did(hir_id)) .is_none() @@ -1218,7 +1218,7 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option<Ty< report_assoc_ty_on_inherent_impl(tcx, item.span); } - find_existential_constraints(tcx, def_id) + find_opaque_ty_constraints(tcx, def_id) } ImplItemKind::Type(ref ty) => { if tcx @@ -1253,27 +1253,27 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option<Ty< let substs = InternalSubsts::identity_for_item(tcx, def_id); tcx.mk_adt(def, substs) } - ItemKind::Existential(hir::ExistTy { + ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: None, .. - }) => find_existential_constraints(tcx, def_id), - // Existential types desugared from `impl Trait`. - ItemKind::Existential(hir::ExistTy { + }) => find_opaque_ty_constraints(tcx, def_id), + // Opaque types desugared from `impl Trait`. + ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn: Some(owner), .. }) => { tcx.typeck_tables_of(owner) - .concrete_existential_types + .concrete_opaque_types .get(&def_id) .map(|opaque| opaque.concrete_type) .unwrap_or_else(|| { // This can occur if some error in the // owner fn prevented us from populating - // the `concrete_existential_types` table. + // the `concrete_opaque_types` table. tcx.sess.delay_span_bug( DUMMY_SP, &format!( - "owner {:?} has no existential type for {:?} in its tables", + "owner {:?} has no opaque type for {:?} in its tables", owner, def_id, ), ); @@ -1505,20 +1505,20 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option<Ty< }) } -fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { +fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { use rustc::hir::{ImplItem, Item, TraitItem}; - debug!("find_existential_constraints({:?})", def_id); + debug!("find_opaque_ty_constraints({:?})", def_id); struct ConstraintLocator<'tcx> { tcx: TyCtxt<'tcx>, def_id: DefId, - // (first found type span, actual type, mapping from the existential type's generic + // (first found type span, actual type, mapping from the opaque type's generic // parameters to the concrete type's generic parameters) // // The mapping is an index for each use site of a generic parameter in the concrete type // - // The indices index into the generic parameters on the existential type. + // The indices index into the generic parameters on the opaque type. found: Option<(Span, Ty<'tcx>, Vec<usize>)>, } @@ -1527,7 +1527,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { // Don't try to check items that cannot possibly constrain the type. if !self.tcx.has_typeck_tables(def_id) { debug!( - "find_existential_constraints: no constraint for `{:?}` at `{:?}`: no tables", + "find_opaque_ty_constraints: no constraint for `{:?}` at `{:?}`: no tables", self.def_id, def_id, ); @@ -1536,11 +1536,11 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { let ty = self .tcx .typeck_tables_of(def_id) - .concrete_existential_types + .concrete_opaque_types .get(&self.def_id); if let Some(ty::ResolvedOpaqueTy { concrete_type, substs }) = ty { debug!( - "find_existential_constraints: found constraint for `{:?}` at `{:?}`: {:?}", + "find_opaque_ty_constraints: found constraint for `{:?}` at `{:?}`: {:?}", self.def_id, def_id, ty, @@ -1561,7 +1561,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { self.tcx.sess.span_err( span, &format!( - "defining existential type use restricts existential \ + "defining opaque type use restricts opaque \ type by using the generic parameter `{}` twice", p.name ), @@ -1572,14 +1572,14 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { self.tcx.sess.delay_span_bug( span, &format!( - "non-defining exist ty use in defining scope: {:?}, {:?}", + "non-defining opaque ty use in defining scope: {:?}, {:?}", concrete_type, substs, ), ); } } } - // Compute the index within the existential type for each generic parameter used in + // Compute the index within the opaque type for each generic parameter used in // the concrete type. let indices = concrete_type .subst(self.tcx, substs) @@ -1595,7 +1595,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { if !substs.types().all(is_param) { self.tcx.sess.span_err( span, - "defining existential type use does not fully define existential type", + "defining opaque type use does not fully define opaque type", ); } else if let Some((prev_span, prev_ty, ref prev_indices)) = self.found { let mut ty = concrete_type.walk().fuse(); @@ -1608,11 +1608,11 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { _ => t == p, }); if !iter_eq || ty.next().is_some() || p_ty.next().is_some() { - debug!("find_existential_constraints: span={:?}", span); - // Found different concrete types for the existential type. + debug!("find_opaque_ty_constraints: span={:?}", span); + // Found different concrete types for the opaque type. let mut err = self.tcx.sess.struct_span_err( span, - "concrete type differs from previous defining existential type use", + "concrete type differs from previous defining opaque type use", ); err.span_label( span, @@ -1651,7 +1651,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { } } else { debug!( - "find_existential_constraints: no constraint for `{:?}` at `{:?}`", + "find_opaque_ty_constraints: no constraint for `{:?}` at `{:?}`", self.def_id, def_id, ); @@ -1666,7 +1666,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { fn visit_item(&mut self, it: &'tcx Item) { debug!("find_existential_constraints: visiting {:?}", it); let def_id = self.tcx.hir().local_def_id(it.hir_id); - // The existential type itself or its children are not within its reveal scope. + // The opaque type itself or its children are not within its reveal scope. if def_id != self.def_id { self.check(def_id); intravisit::walk_item(self, it); @@ -1675,7 +1675,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { fn visit_impl_item(&mut self, it: &'tcx ImplItem) { debug!("find_existential_constraints: visiting {:?}", it); let def_id = self.tcx.hir().local_def_id(it.hir_id); - // The existential type itself or its children are not within its reveal scope. + // The opaque type itself or its children are not within its reveal scope. if def_id != self.def_id { self.check(def_id); intravisit::walk_impl_item(self, it); @@ -1699,12 +1699,12 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { found: None, }; - debug!("find_existential_constraints: scope={:?}", scope); + debug!("find_opaque_ty_constraints: scope={:?}", scope); if scope == hir::CRATE_HIR_ID { intravisit::walk_crate(&mut locator, tcx.hir().krate()); } else { - debug!("find_existential_constraints: scope={:?}", tcx.hir().get(scope)); + debug!("find_opaque_ty_constraints: scope={:?}", tcx.hir().get(scope)); match tcx.hir().get(scope) { // We explicitly call `visit_*` methods, instead of using `intravisit::walk_*` methods // This allows our visitor to process the defining item itself, causing @@ -1713,7 +1713,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { // For example, this code: // ``` // fn foo() { - // existential type Blah: Debug; + // type Blah = impl Debug; // let my_closure = || -> Blah { true }; // } // ``` @@ -1724,7 +1724,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { Node::ImplItem(ref it) => locator.visit_impl_item(it), Node::TraitItem(ref it) => locator.visit_trait_item(it), other => bug!( - "{:?} is not a valid scope for an existential type item", + "{:?} is not a valid scope for an opaque type item", other ), } @@ -2010,7 +2010,7 @@ fn explicit_predicates_of( Node::TraitItem(item) => &item.generics, Node::ImplItem(item) => match item.node { - ImplItemKind::Existential(ref bounds) => { + ImplItemKind::OpaqueTy(ref bounds) => { let substs = InternalSubsts::identity_for_item(tcx, def_id); let opaque_ty = tcx.mk_opaque(def_id, substs); @@ -2051,7 +2051,7 @@ fn explicit_predicates_of( is_trait = Some((ty::TraitRef::identity(tcx, def_id), &empty_trait_items)); generics } - ItemKind::Existential(ExistTy { + ItemKind::OpaqueTy(OpaqueTy { ref bounds, impl_trait_fn, ref generics, @@ -2077,7 +2077,7 @@ fn explicit_predicates_of( predicates: bounds_predicates, }); } else { - // named existential types + // named opaque types predicates.extend(bounds_predicates); generics } diff --git a/src/librustc_typeck/namespace.rs b/src/librustc_typeck/namespace.rs index 9b6c5bd9f42..732f0d3ebf2 100644 --- a/src/librustc_typeck/namespace.rs +++ b/src/librustc_typeck/namespace.rs @@ -11,7 +11,7 @@ pub enum Namespace { impl From<ty::AssocKind> for Namespace { fn from(a_kind: ty::AssocKind) -> Self { match a_kind { - ty::AssocKind::Existential | + ty::AssocKind::OpaqueTy | ty::AssocKind::Type => Namespace::Type, ty::AssocKind::Const | ty::AssocKind::Method => Namespace::Value, @@ -22,7 +22,7 @@ impl From<ty::AssocKind> for Namespace { impl<'a> From <&'a hir::ImplItemKind> for Namespace { fn from(impl_kind: &'a hir::ImplItemKind) -> Self { match *impl_kind { - hir::ImplItemKind::Existential(..) | + hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::Type(..) => Namespace::Type, hir::ImplItemKind::Const(..) | hir::ImplItemKind::Method(..) => Namespace::Value, diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 30419d3d3c6..a41b12e29b0 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -538,7 +538,7 @@ pub enum ItemEnum { FunctionItem(Function), ModuleItem(Module), TypedefItem(Typedef, bool /* is associated type */), - ExistentialItem(Existential, bool /* is associated type */), + OpaqueTyItem(OpaqueTy, bool /* is associated type */), StaticItem(Static), ConstantItem(Constant), TraitItem(Trait), @@ -574,7 +574,7 @@ impl ItemEnum { ItemEnum::EnumItem(ref e) => &e.generics, ItemEnum::FunctionItem(ref f) => &f.generics, ItemEnum::TypedefItem(ref t, _) => &t.generics, - ItemEnum::ExistentialItem(ref t, _) => &t.generics, + ItemEnum::OpaqueTyItem(ref t, _) => &t.generics, ItemEnum::TraitItem(ref t) => &t.generics, ItemEnum::ImplItem(ref i) => &i.generics, ItemEnum::TyMethodItem(ref i) => &i.generics, @@ -623,7 +623,7 @@ impl Clean<Item> for doctree::Module<'_> { items.extend(self.foreigns.iter().map(|x| x.clean(cx))); items.extend(self.mods.iter().map(|x| x.clean(cx))); items.extend(self.typedefs.iter().map(|x| x.clean(cx))); - items.extend(self.existentials.iter().map(|x| x.clean(cx))); + items.extend(self.opaque_tys.iter().map(|x| x.clean(cx))); items.extend(self.statics.iter().map(|x| x.clean(cx))); items.extend(self.constants.iter().map(|x| x.clean(cx))); items.extend(self.traits.iter().map(|x| x.clean(cx))); @@ -2257,7 +2257,7 @@ impl Clean<Item> for hir::ImplItem { type_: ty.clean(cx), generics: Generics::default(), }, true), - hir::ImplItemKind::Existential(ref bounds) => ExistentialItem(Existential { + hir::ImplItemKind::OpaqueTy(ref bounds) => OpaqueTyItem(OpaqueTy { bounds: bounds.clean(cx), generics: Generics::default(), }, true), @@ -2415,7 +2415,7 @@ impl Clean<Item> for ty::AssocItem { }, true) } } - ty::AssocKind::Existential => unimplemented!(), + ty::AssocKind::OpaqueTy => unimplemented!(), }; let visibility = match self.container { @@ -2776,7 +2776,7 @@ impl Clean<Type> for hir::Ty { TyKind::Tup(ref tys) => Tuple(tys.clean(cx)), TyKind::Def(item_id, _) => { let item = cx.tcx.hir().expect_item(item_id.id); - if let hir::ItemKind::Existential(ref ty) = item.node { + if let hir::ItemKind::OpaqueTy(ref ty) = item.node { ImplTrait(ty.bounds.clean(cx)) } else { unreachable!() @@ -3648,12 +3648,12 @@ impl Clean<Item> for doctree::Typedef<'_> { } #[derive(Clone, Debug)] -pub struct Existential { +pub struct OpaqueTy { pub bounds: Vec<GenericBound>, pub generics: Generics, } -impl Clean<Item> for doctree::Existential<'_> { +impl Clean<Item> for doctree::OpaqueTy<'_> { fn clean(&self, cx: &DocContext<'_>) -> Item { Item { name: Some(self.name.clean(cx)), @@ -3663,9 +3663,9 @@ impl Clean<Item> for doctree::Existential<'_> { visibility: self.vis.clean(cx), stability: self.stab.clean(cx), deprecation: self.depr.clean(cx), - inner: ExistentialItem(Existential { - bounds: self.exist_ty.bounds.clean(cx), - generics: self.exist_ty.generics.clean(cx), + inner: OpaqueTyItem(OpaqueTy { + bounds: self.opaque_ty.bounds.clean(cx), + generics: self.opaque_ty.generics.clean(cx), }, false), } } diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index 45a3c8a3c22..ec60241a92d 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -26,7 +26,7 @@ pub struct Module<'hir> { pub mods: Vec<Module<'hir>>, pub id: NodeId, pub typedefs: Vec<Typedef<'hir>>, - pub existentials: Vec<Existential<'hir>>, + pub opaque_tys: Vec<OpaqueTy<'hir>>, pub statics: Vec<Static<'hir>>, pub constants: Vec<Constant<'hir>>, pub traits: Vec<Trait<'hir>>, @@ -64,7 +64,7 @@ impl Module<'hir> { fns : Vec::new(), mods : Vec::new(), typedefs : Vec::new(), - existentials: Vec::new(), + opaque_tys : Vec::new(), statics : Vec::new(), constants : Vec::new(), traits : Vec::new(), @@ -162,8 +162,8 @@ pub struct Typedef<'hir> { pub depr: Option<attr::Deprecation>, } -pub struct Existential<'hir> { - pub exist_ty: &'hir hir::ExistTy, +pub struct OpaqueTy<'hir> { + pub opaque_ty: &'hir hir::OpaqueTy, pub name: Name, pub id: hir::HirId, pub attrs: &'hir hir::HirVec<ast::Attribute>, diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs index 9affc08141d..cf51a4eb5a5 100644 --- a/src/librustdoc/html/item_type.rs +++ b/src/librustdoc/html/item_type.rs @@ -39,7 +39,7 @@ pub enum ItemType { Union = 19, ForeignType = 20, Keyword = 21, - Existential = 22, + OpaqueTy = 22, ProcAttribute = 23, ProcDerive = 24, TraitAlias = 25, @@ -70,7 +70,7 @@ impl<'a> From<&'a clean::Item> for ItemType { clean::EnumItem(..) => ItemType::Enum, clean::FunctionItem(..) => ItemType::Function, clean::TypedefItem(..) => ItemType::Typedef, - clean::ExistentialItem(..) => ItemType::Existential, + clean::OpaqueTyItem(..) => ItemType::OpaqueTy, clean::StaticItem(..) => ItemType::Static, clean::ConstantItem(..) => ItemType::Constant, clean::TraitItem(..) => ItemType::Trait, @@ -144,7 +144,7 @@ impl ItemType { ItemType::AssocConst => "associatedconstant", ItemType::ForeignType => "foreigntype", ItemType::Keyword => "keyword", - ItemType::Existential => "existential", + ItemType::OpaqueTy => "opaque", ItemType::ProcAttribute => "attr", ItemType::ProcDerive => "derive", ItemType::TraitAlias => "traitalias", @@ -161,7 +161,7 @@ impl ItemType { ItemType::Trait | ItemType::Primitive | ItemType::AssocType | - ItemType::Existential | + ItemType::OpaqueTy | ItemType::TraitAlias | ItemType::ForeignType => NameSpace::Type, diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index c7bda534d07..2774f2b4751 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1886,7 +1886,7 @@ struct AllTypes { macros: FxHashSet<ItemEntry>, functions: FxHashSet<ItemEntry>, typedefs: FxHashSet<ItemEntry>, - existentials: FxHashSet<ItemEntry>, + opaque_tys: FxHashSet<ItemEntry>, statics: FxHashSet<ItemEntry>, constants: FxHashSet<ItemEntry>, keywords: FxHashSet<ItemEntry>, @@ -1907,7 +1907,7 @@ impl AllTypes { macros: new_set(100), functions: new_set(100), typedefs: new_set(100), - existentials: new_set(100), + opaque_tys: new_set(100), statics: new_set(100), constants: new_set(100), keywords: new_set(100), @@ -1932,7 +1932,7 @@ impl AllTypes { ItemType::Macro => self.macros.insert(ItemEntry::new(new_url, name)), ItemType::Function => self.functions.insert(ItemEntry::new(new_url, name)), ItemType::Typedef => self.typedefs.insert(ItemEntry::new(new_url, name)), - ItemType::Existential => self.existentials.insert(ItemEntry::new(new_url, name)), + ItemType::OpaqueTy => self.opaque_tys.insert(ItemEntry::new(new_url, name)), ItemType::Static => self.statics.insert(ItemEntry::new(new_url, name)), ItemType::Constant => self.constants.insert(ItemEntry::new(new_url, name)), ItemType::ProcAttribute => self.attributes.insert(ItemEntry::new(new_url, name)), @@ -1982,7 +1982,7 @@ impl fmt::Display for AllTypes { print_entries(f, &self.functions, "Functions", "functions")?; print_entries(f, &self.typedefs, "Typedefs", "typedefs")?; print_entries(f, &self.trait_aliases, "Trait Aliases", "trait-aliases")?; - print_entries(f, &self.existentials, "Existentials", "existentials")?; + print_entries(f, &self.opaque_tys, "Opaque Types", "opaque-types")?; print_entries(f, &self.statics, "Statics", "statics")?; print_entries(f, &self.constants, "Constants", "constants") } @@ -2480,7 +2480,7 @@ impl<'a> fmt::Display for Item<'a> { clean::ConstantItem(..) => write!(fmt, "Constant ")?, clean::ForeignTypeItem => write!(fmt, "Foreign Type ")?, clean::KeywordItem(..) => write!(fmt, "Keyword ")?, - clean::ExistentialItem(..) => write!(fmt, "Existential Type ")?, + clean::OpaqueTyItem(..) => write!(fmt, "Opaque Type ")?, clean::TraitAliasItem(..) => write!(fmt, "Trait Alias ")?, _ => { // We don't generate pages for any other type. @@ -2519,7 +2519,7 @@ impl<'a> fmt::Display for Item<'a> { clean::ConstantItem(ref c) => item_constant(fmt, self.cx, self.item, c), clean::ForeignTypeItem => item_foreign_type(fmt, self.cx, self.item), clean::KeywordItem(ref k) => item_keyword(fmt, self.cx, self.item, k), - clean::ExistentialItem(ref e, _) => item_existential(fmt, self.cx, self.item, e), + clean::OpaqueTyItem(ref e, _) => item_opaque_ty(fmt, self.cx, self.item, e), clean::TraitAliasItem(ref ta) => item_trait_alias(fmt, self.cx, self.item, ta), _ => { // We don't generate pages for any other type. @@ -4390,15 +4390,15 @@ fn render_impl(w: &mut fmt::Formatter<'_>, cx: &Context, i: &Impl, link: AssocIt Ok(()) } -fn item_existential( +fn item_opaque_ty( w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item, - t: &clean::Existential, + t: &clean::OpaqueTy, ) -> fmt::Result { - write!(w, "<pre class='rust existential'>")?; + write!(w, "<pre class='rust opaque'>")?; render_attributes(w, it, false)?; - write!(w, "existential type {}{}{where_clause}: {bounds};</pre>", + write!(w, "type {}{}{where_clause} = impl {bounds};</pre>", it.name.as_ref().unwrap(), t.generics, where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true }, @@ -4986,7 +4986,7 @@ fn item_ty_to_strs(ty: &ItemType) -> (&'static str, &'static str) { ItemType::AssocConst => ("associated-consts", "Associated Constants"), ItemType::ForeignType => ("foreign-types", "Foreign Types"), ItemType::Keyword => ("keywords", "Keywords"), - ItemType::Existential => ("existentials", "Existentials"), + ItemType::OpaqueTy => ("opaque-types", "Opaque Types"), ItemType::ProcAttribute => ("attributes", "Attribute Macros"), ItemType::ProcDerive => ("derives", "Derive Macros"), ItemType::TraitAlias => ("trait-aliases", "Trait aliases"), diff --git a/src/librustdoc/passes/mod.rs b/src/librustdoc/passes/mod.rs index 8fc6b9fdbe6..ca40d6d02f8 100644 --- a/src/librustdoc/passes/mod.rs +++ b/src/librustdoc/passes/mod.rs @@ -159,7 +159,7 @@ impl<'a> DocFolder for Stripper<'a> { return ret; } // These items can all get re-exported - clean::ExistentialItem(..) + clean::OpaqueTyItem(..) | clean::TypedefItem(..) | clean::StaticItem(..) | clean::StructItem(..) diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 4a3743bdf7c..098cecef95c 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -472,9 +472,9 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { }; om.typedefs.push(t); }, - hir::ItemKind::Existential(ref exist_ty) => { - let t = Existential { - exist_ty, + hir::ItemKind::OpaqueTy(ref opaque_ty) => { + let t = OpaqueTy { + opaque_ty, name: ident.name, id: item.hir_id, attrs: &item.attrs, @@ -483,7 +483,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { stab: self.stability(item.hir_id), depr: self.deprecation(item.hir_id), }; - om.existentials.push(t); + om.opaque_tys.push(t); }, hir::ItemKind::Static(ref type_, mutability, expr) => { let s = Static { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 87113b4b98e..60db7a16a77 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1488,6 +1488,7 @@ pub enum TraitItemKind { Macro(Mac), } +/// Represents anything within an `impl` block. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ImplItem { pub id: NodeId, @@ -1502,12 +1503,13 @@ pub struct ImplItem { pub tokens: Option<TokenStream>, } +/// Represents various kinds of content within an `impl`. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum ImplItemKind { Const(P<Ty>, P<Expr>), Method(MethodSig, P<Block>), Type(P<Ty>), - Existential(GenericBounds), + OpaqueTy(GenericBounds), Macro(Mac), } @@ -1710,7 +1712,7 @@ pub enum TyKind { /// /// The `NodeId` exists to prevent lowering from having to /// generate `NodeId`s on the fly, which would complicate - /// the generation of `existential type` items significantly. + /// the generation of opaque `type Foo = impl Trait` items significantly. ImplTrait(NodeId, GenericBounds), /// No-op; kept solely so that we can pretty-print faithfully. Paren(P<Ty>), @@ -2334,10 +2336,10 @@ pub enum ItemKind { /// /// E.g., `type Foo = Bar<u8>;`. Ty(P<Ty>, Generics), - /// An existential type declaration (`existential type`). + /// An opaque `impl Trait` type alias. /// - /// E.g., `existential type Foo: Bar + Boo;`. - Existential(GenericBounds, Generics), + /// E.g., `type Foo = impl Bar + Boo;`. + OpaqueTy(GenericBounds, Generics), /// An enum definition (`enum` or `pub enum`). /// /// E.g., `enum Foo<A, B> { C<A>, D<B> }`. @@ -2391,7 +2393,7 @@ impl ItemKind { ItemKind::ForeignMod(..) => "foreign module", ItemKind::GlobalAsm(..) => "global asm", ItemKind::Ty(..) => "type alias", - ItemKind::Existential(..) => "existential type", + ItemKind::OpaqueTy(..) => "opaque type", ItemKind::Enum(..) => "enum", ItemKind::Struct(..) => "struct", ItemKind::Union(..) => "union", diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 4f637a23e69..33d10b269e1 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -453,9 +453,6 @@ declare_features! ( // Allows `#[doc(alias = "...")]`. (active, doc_alias, "1.27.0", Some(50146), None), - // Allows defining `existential type`s. - (active, existential_type, "1.28.0", Some(63063), None), - // Allows inconsistent bounds in where clauses. (active, trivial_bounds, "1.28.0", Some(48214), None), @@ -560,6 +557,9 @@ declare_features! ( // Allows `[x; N]` where `x` is a constant (RFC 2203). (active, const_in_array_repeat_expressions, "1.37.0", Some(49147), None), + // Allows `impl Trait` to be used inside type aliases (RFC 2515). + (active, type_alias_impl_trait, "1.38.0", Some(63063), None), + // ------------------------------------------------------------------------- // feature-group-end: actual feature gates // ------------------------------------------------------------------------- @@ -625,6 +625,9 @@ declare_features! ( (removed, dropck_parametricity, "1.38.0", Some(28498), None, None), (removed, await_macro, "1.38.0", Some(50547), None, Some("subsumed by `.await` syntax")), + // Allows defining `existential type`s. + (removed, existential_type, "1.38.0", Some(63063), None, + Some("removed in favor of `#![feature(type_alias_impl_trait)]`")), // ------------------------------------------------------------------------- // feature-group-end: removed features @@ -2014,12 +2017,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { gate_feature_post!(&self, decl_macro, i.span, msg); } - ast::ItemKind::Existential(..) => { + ast::ItemKind::OpaqueTy(..) => { gate_feature_post!( &self, - existential_type, + type_alias_impl_trait, i.span, - "existential types are unstable" + "`impl Trait` in type aliases is unstable" ); } @@ -2243,12 +2246,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { match ii.node { ast::ImplItemKind::Method(..) => {} - ast::ImplItemKind::Existential(..) => { + ast::ImplItemKind::OpaqueTy(..) => { gate_feature_post!( &self, - existential_type, + type_alias_impl_trait, ii.span, - "existential types are unstable" + "`impl Trait` in type aliases is unstable" ); } ast::ImplItemKind::Type(_) => { diff --git a/src/libsyntax/mut_visit.rs b/src/libsyntax/mut_visit.rs index a5085c5f879..176bcf1959a 100644 --- a/src/libsyntax/mut_visit.rs +++ b/src/libsyntax/mut_visit.rs @@ -851,7 +851,7 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) { vis.visit_ty(ty); vis.visit_generics(generics); } - ItemKind::Existential(bounds, generics) => { + ItemKind::OpaqueTy(bounds, generics) => { visit_bounds(bounds, vis); vis.visit_generics(generics); } @@ -934,7 +934,7 @@ pub fn noop_flat_map_impl_item<T: MutVisitor>(mut item: ImplItem, visitor: &mut visitor.visit_block(body); } ImplItemKind::Type(ty) => visitor.visit_ty(ty), - ImplItemKind::Existential(bounds) => visit_bounds(bounds, visitor), + ImplItemKind::OpaqueTy(bounds) => visit_bounds(bounds, visitor), ImplItemKind::Macro(mac) => visitor.visit_mac(mac), } visitor.visit_span(span); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 8ca962a4419..eca1e218fca 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -62,12 +62,12 @@ use std::path::{self, Path, PathBuf}; use std::slice; #[derive(Debug)] -/// Whether the type alias or associated type is a concrete type or an existential type +/// Whether the type alias or associated type is a concrete type or an opaque type pub enum AliasKind { /// Just a new name for the same type Weak(P<Ty>), /// Only trait impls of the type will be usable, not the actual type itself - Existential(GenericBounds), + OpaqueTy(GenericBounds), } bitflags::bitflags! { @@ -4273,11 +4273,6 @@ impl<'a> Parser<'a> { self.token.is_keyword(kw::Crate) && self.look_ahead(1, |t| t != &token::ModSep) } - fn is_existential_type_decl(&self) -> bool { - self.token.is_keyword(kw::Existential) && - self.is_keyword_ahead(1, &[kw::Type]) - } - fn is_auto_trait_item(&self) -> bool { // auto trait (self.token.is_keyword(kw::Auto) && @@ -4375,7 +4370,6 @@ impl<'a> Parser<'a> { !self.token.is_qpath_start() && !self.is_union_item() && !self.is_crate_vis() && - !self.is_existential_type_decl() && !self.is_auto_trait_item() && !self.is_async_fn() { let path = self.parse_path(PathStyle::Expr)?; @@ -5694,7 +5688,7 @@ impl<'a> Parser<'a> { let (name, alias, generics) = type_?; let kind = match alias { AliasKind::Weak(typ) => ast::ImplItemKind::Type(typ), - AliasKind::Existential(bounds) => ast::ImplItemKind::Existential(bounds), + AliasKind::OpaqueTy(bounds) => ast::ImplItemKind::OpaqueTy(bounds), }; (name, kind, generics) } else if self.is_const_item() { @@ -6813,40 +6807,29 @@ impl<'a> Parser<'a> { Ok(self.mk_item(lo.to(prev_span), invalid, ItemKind::ForeignMod(m), visibility, attrs)) } - /// Parses `type Foo = Bar;` - /// or - /// `existential type Foo: Bar;` - /// or - /// `return `None`` + /// Parses `type Foo = Bar;` or returns `None` /// without modifying the parser state. fn eat_type(&mut self) -> Option<PResult<'a, (Ident, AliasKind, ast::Generics)>> { // This parses the grammar: // Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";" - if self.check_keyword(kw::Type) || - self.check_keyword(kw::Existential) && - self.is_keyword_ahead(1, &[kw::Type]) { - let existential = self.eat_keyword(kw::Existential); - assert!(self.eat_keyword(kw::Type)); - Some(self.parse_existential_or_alias(existential)) + if self.eat_keyword(kw::Type) { + Some(self.parse_type_alias()) } else { None } } - /// Parses a type alias or existential type. - fn parse_existential_or_alias( - &mut self, - existential: bool, - ) -> PResult<'a, (Ident, AliasKind, ast::Generics)> { + /// Parses a type alias or opaque type. + fn parse_type_alias(&mut self) -> PResult<'a, (Ident, AliasKind, ast::Generics)> { let ident = self.parse_ident()?; let mut tps = self.parse_generics()?; tps.where_clause = self.parse_where_clause()?; - let alias = if existential { - self.expect(&token::Colon)?; + self.expect(&token::Eq)?; + let alias = if self.check_keyword(kw::Impl) { + self.bump(); let bounds = self.parse_generic_bounds(Some(self.prev_span))?; - AliasKind::Existential(bounds) + AliasKind::OpaqueTy(bounds) } else { - self.expect(&token::Eq)?; let ty = self.parse_ty()?; AliasKind::Weak(ty) }; @@ -7268,7 +7251,7 @@ impl<'a> Parser<'a> { // TYPE ITEM let item_ = match alias { AliasKind::Weak(ty) => ItemKind::Ty(ty, generics), - AliasKind::Existential(bounds) => ItemKind::Existential(bounds, generics), + AliasKind::OpaqueTy(bounds) => ItemKind::OpaqueTy(bounds, generics), }; let prev_span = self.prev_span; let item = self.mk_item(lo.to(prev_span), diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 07b1aef337f..e61e1113dca 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1221,9 +1221,10 @@ impl<'a> State<'a> { self.s.word(";"); self.end(); // end the outer ibox } - ast::ItemKind::Existential(ref bounds, ref generics) => { - self.head(visibility_qualified(&item.vis, "existential type")); + ast::ItemKind::OpaqueTy(ref bounds, ref generics) => { + self.head(visibility_qualified(&item.vis, "type")); self.print_ident(item.ident); + self.word_space("= impl"); self.print_generic_params(&generics.params); self.end(); // end the inner ibox @@ -1581,9 +1582,12 @@ impl<'a> State<'a> { ast::ImplItemKind::Type(ref ty) => { self.print_associated_type(ii.ident, None, Some(ty)); } - ast::ImplItemKind::Existential(ref bounds) => { - self.word_space("existential"); - self.print_associated_type(ii.ident, Some(bounds), None); + ast::ImplItemKind::OpaqueTy(ref bounds) => { + self.word_space("type"); + self.print_ident(ii.ident); + self.word_space("= impl"); + self.print_type_bounds(":", bounds); + self.s.word(";"); } ast::ImplItemKind::Macro(ref mac) => { self.print_mac(mac); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 5fee8ed81ab..67226c2177f 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -259,7 +259,7 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) { visitor.visit_ty(typ); visitor.visit_generics(generics) } - ItemKind::Existential(ref bounds, ref generics) => { + ItemKind::OpaqueTy(ref bounds, ref generics) => { walk_list!(visitor, visit_param_bound, bounds); visitor.visit_generics(generics) } @@ -619,7 +619,7 @@ pub fn walk_impl_item<'a, V: Visitor<'a>>(visitor: &mut V, impl_item: &'a ImplIt ImplItemKind::Type(ref ty) => { visitor.visit_ty(ty); } - ImplItemKind::Existential(ref bounds) => { + ImplItemKind::OpaqueTy(ref bounds) => { walk_list!(visitor, visit_param_bound, bounds); } ImplItemKind::Macro(ref mac) => { diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs index f83979b9e9b..f91a2291544 100644 --- a/src/libsyntax_pos/hygiene.rs +++ b/src/libsyntax_pos/hygiene.rs @@ -744,9 +744,9 @@ pub enum DesugaringKind { QuestionMark, TryBlock, /// Desugaring of an `impl Trait` in return type position - /// to an `existential type Foo: Trait;` and replacing the + /// to an `type Foo = impl Trait;` and replacing the /// `impl Trait` with `Foo`. - ExistentialType, + OpaqueTy, Async, Await, ForLoop, @@ -761,7 +761,7 @@ impl DesugaringKind { DesugaringKind::Await => "`await` expression", DesugaringKind::QuestionMark => "operator `?`", DesugaringKind::TryBlock => "`try` block", - DesugaringKind::ExistentialType => "`existential type`", + DesugaringKind::OpaqueTy => "`impl Trait`", DesugaringKind::ForLoop => "`for` loop", } } diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs index 476368e8351..12c4ba059fe 100644 --- a/src/libsyntax_pos/symbol.rs +++ b/src/libsyntax_pos/symbol.rs @@ -98,7 +98,6 @@ symbols! { Auto: "auto", Catch: "catch", Default: "default", - Existential: "existential", Union: "union", } @@ -680,6 +679,7 @@ symbols! { tuple_indexing, Ty, ty, + type_alias_impl_trait, TyCtxt, TyKind, type_alias_enum_variants, diff --git a/src/test/rustdoc-ui/coverage/traits.rs b/src/test/rustdoc-ui/coverage/traits.rs index 40d68423f1b..97f73b4e1f2 100644 --- a/src/test/rustdoc-ui/coverage/traits.rs +++ b/src/test/rustdoc-ui/coverage/traits.rs @@ -29,9 +29,10 @@ impl ThisTrait for SomeStruct { /// but what about those aliases? i hear they're pretty exotic pub trait MyAlias = ThisTrait + Send + Sync; -// FIXME(58624): once rustdoc can process existential types, we need to make sure they're counted -// /// woah, getting all existential in here -// pub existential type ThisExists: ThisTrait; +// FIXME(58624): once rustdoc can process opaque `impl Trait` types, +// we need to make sure they're counted +// /// woah, getting all opaque in here +// pub type ThisExists = impl ThisTrait; // // /// why don't we get a little more concrete // pub fn defines() -> ThisExists { SomeStruct {} } diff --git a/src/test/ui/associated-type-bounds/bounds-on-assoc-in-trait.rs b/src/test/ui/associated-type-bounds/bounds-on-assoc-in-trait.rs index 8c9110d03ec..9db5233e21e 100644 --- a/src/test/ui/associated-type-bounds/bounds-on-assoc-in-trait.rs +++ b/src/test/ui/associated-type-bounds/bounds-on-assoc-in-trait.rs @@ -28,7 +28,7 @@ impl Case1 for S1 { type B = Range<u16>; } -// Ensure we don't have existential desugaring: +// Ensure we don't have opaque `impl Trait` desugaring: pub trait Foo { type Out: Baz<Assoc: Default>; } pub trait Baz { type Assoc; } diff --git a/src/test/ui/associated-type-bounds/duplicate.rs b/src/test/ui/associated-type-bounds/duplicate.rs index bee56d6f689..1f2d755ed71 100644 --- a/src/test/ui/associated-type-bounds/duplicate.rs +++ b/src/test/ui/associated-type-bounds/duplicate.rs @@ -3,7 +3,7 @@ // error-pattern:could not find defining uses #![feature(associated_type_bounds)] -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] #![feature(impl_trait_in_bindings)] #![feature(untagged_unions)] @@ -107,17 +107,17 @@ type TAW2<T> where T: Iterator<Item: Copy, Item: Copy> = T; type TAW3<T> where T: Iterator<Item: 'static, Item: 'static> = T; //~^ the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified [E0719] -existential type ETAI1<T: Iterator<Item: Copy, Item: Send>>: Copy; +type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy; //~^ the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified [E0719] -existential type ETAI2<T: Iterator<Item: Copy, Item: Copy>>: Copy; +type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy; //~^ the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified [E0719] -existential type ETAI3<T: Iterator<Item: 'static, Item: 'static>>: Copy; +type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy; //~^ the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified [E0719] -existential type ETAI4: Iterator<Item: Copy, Item: Send>; +type ETAI4 = impl Iterator<Item: Copy, Item: Send>; //~^ the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified [E0719] -existential type ETAI5: Iterator<Item: Copy, Item: Copy>; +type ETAI5 = impl Iterator<Item: Copy, Item: Copy>; //~^ the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified [E0719] -existential type ETAI6: Iterator<Item: 'static, Item: 'static>; +type ETAI6 = impl Iterator<Item: 'static, Item: 'static>; //~^ the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified [E0719] trait TRI1<T: Iterator<Item: Copy, Item: Send>> {} diff --git a/src/test/ui/associated-type-bounds/duplicate.stderr b/src/test/ui/associated-type-bounds/duplicate.stderr index 7f14a033688..7f3a65ab696 100644 --- a/src/test/ui/associated-type-bounds/duplicate.stderr +++ b/src/test/ui/associated-type-bounds/duplicate.stderr @@ -369,86 +369,86 @@ LL | type TAW3<T> where T: Iterator<Item: 'static, Item: 'static> = T; error: could not find defining uses --> $DIR/duplicate.rs:110:1 | -LL | existential type ETAI1<T: Iterator<Item: Copy, Item: Send>>: Copy; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0719]: the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified - --> $DIR/duplicate.rs:110:48 + --> $DIR/duplicate.rs:110:36 | -LL | existential type ETAI1<T: Iterator<Item: Copy, Item: Send>>: Copy; - | ---------- ^^^^^^^^^^ re-bound here - | | - | `Item` bound here first +LL | type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy; + | ---------- ^^^^^^^^^^ re-bound here + | | + | `Item` bound here first error: could not find defining uses --> $DIR/duplicate.rs:112:1 | -LL | existential type ETAI2<T: Iterator<Item: Copy, Item: Copy>>: Copy; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0719]: the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified - --> $DIR/duplicate.rs:112:48 + --> $DIR/duplicate.rs:112:36 | -LL | existential type ETAI2<T: Iterator<Item: Copy, Item: Copy>>: Copy; - | ---------- ^^^^^^^^^^ re-bound here - | | - | `Item` bound here first +LL | type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy; + | ---------- ^^^^^^^^^^ re-bound here + | | + | `Item` bound here first error: could not find defining uses --> $DIR/duplicate.rs:114:1 | -LL | existential type ETAI3<T: Iterator<Item: 'static, Item: 'static>>: Copy; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0719]: the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified - --> $DIR/duplicate.rs:114:51 + --> $DIR/duplicate.rs:114:39 | -LL | existential type ETAI3<T: Iterator<Item: 'static, Item: 'static>>: Copy; - | ------------- ^^^^^^^^^^^^^ re-bound here - | | - | `Item` bound here first +LL | type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy; + | ------------- ^^^^^^^^^^^^^ re-bound here + | | + | `Item` bound here first error: could not find defining uses --> $DIR/duplicate.rs:116:1 | -LL | existential type ETAI4: Iterator<Item: Copy, Item: Send>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type ETAI4 = impl Iterator<Item: Copy, Item: Send>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0719]: the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified - --> $DIR/duplicate.rs:116:46 + --> $DIR/duplicate.rs:116:40 | -LL | existential type ETAI4: Iterator<Item: Copy, Item: Send>; - | ---------- ^^^^^^^^^^ re-bound here - | | - | `Item` bound here first +LL | type ETAI4 = impl Iterator<Item: Copy, Item: Send>; + | ---------- ^^^^^^^^^^ re-bound here + | | + | `Item` bound here first error: could not find defining uses --> $DIR/duplicate.rs:118:1 | -LL | existential type ETAI5: Iterator<Item: Copy, Item: Copy>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type ETAI5 = impl Iterator<Item: Copy, Item: Copy>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0719]: the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified - --> $DIR/duplicate.rs:118:46 + --> $DIR/duplicate.rs:118:40 | -LL | existential type ETAI5: Iterator<Item: Copy, Item: Copy>; - | ---------- ^^^^^^^^^^ re-bound here - | | - | `Item` bound here first +LL | type ETAI5 = impl Iterator<Item: Copy, Item: Copy>; + | ---------- ^^^^^^^^^^ re-bound here + | | + | `Item` bound here first error: could not find defining uses --> $DIR/duplicate.rs:120:1 | -LL | existential type ETAI6: Iterator<Item: 'static, Item: 'static>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type ETAI6 = impl Iterator<Item: 'static, Item: 'static>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0719]: the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified - --> $DIR/duplicate.rs:120:49 + --> $DIR/duplicate.rs:120:43 | -LL | existential type ETAI6: Iterator<Item: 'static, Item: 'static>; - | ------------- ^^^^^^^^^^^^^ re-bound here - | | - | `Item` bound here first +LL | type ETAI6 = impl Iterator<Item: 'static, Item: 'static>; + | ------------- ^^^^^^^^^^^^^ re-bound here + | | + | `Item` bound here first error[E0719]: the value of the associated type `Item` (from the trait `std::iter::Iterator`) is already specified --> $DIR/duplicate.rs:123:36 diff --git a/src/test/ui/associated-type-bounds/dyn-existential-type.rs b/src/test/ui/associated-type-bounds/dyn-impl-trait-type.rs index dc0afaa934a..fd9e52a6ff2 100644 --- a/src/test/ui/associated-type-bounds/dyn-existential-type.rs +++ b/src/test/ui/associated-type-bounds/dyn-impl-trait-type.rs @@ -1,7 +1,6 @@ // run-pass #![feature(associated_type_bounds)] -#![feature(existential_type)] use std::ops::Add; diff --git a/src/test/ui/associated-type-bounds/existential-type.rs b/src/test/ui/associated-type-bounds/trait-alias-impl-trait.rs index 87046aec5c4..9ee33e4149a 100644 --- a/src/test/ui/associated-type-bounds/existential-type.rs +++ b/src/test/ui/associated-type-bounds/trait-alias-impl-trait.rs @@ -1,7 +1,7 @@ // run-pass #![feature(associated_type_bounds)] -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::ops::Add; @@ -17,15 +17,15 @@ struct S1; struct S2; impl Tr1 for S1 { type As1 = S2; fn mk(self) -> Self::As1 { S2 } } -existential type Et1: Tr1<As1: Copy>; +type Et1 = impl Tr1<As1: Copy>; fn def_et1() -> Et1 { S1 } pub fn use_et1() { assert_copy(def_et1().mk()); } -existential type Et2: Tr1<As1: 'static>; +type Et2 = impl Tr1<As1: 'static>; fn def_et2() -> Et2 { S1 } pub fn use_et2() { assert_static(def_et2().mk()); } -existential type Et3: Tr1<As1: Clone + Iterator<Item: Add<u8, Output: Into<u8>>>>; +type Et3 = impl Tr1<As1: Clone + Iterator<Item: Add<u8, Output: Into<u8>>>>; fn def_et3() -> Et3 { struct A; impl Tr1 for A { @@ -44,7 +44,7 @@ pub fn use_et3() { assert_eq!(s, (0..10).map(|x| x + 1).sum()); } -existential type Et4: Tr1<As1: for<'a> Tr2<'a>>; +type Et4 = impl Tr1<As1: for<'a> Tr2<'a>>; fn def_et4() -> Et4 { #[derive(Copy, Clone)] struct A; diff --git a/src/test/ui/async-await/async-await.rs b/src/test/ui/async-await/async-await.rs index 5ec99c5d183..8a15eb8c573 100644 --- a/src/test/ui/async-await/async-await.rs +++ b/src/test/ui/async-await/async-await.rs @@ -99,12 +99,10 @@ fn async_fn_with_impl_future_named_lifetime<'a>(x: &'a u8) -> impl Future<Output } } -/* FIXME(cramertj) support when `existential type T<'a, 'b>:;` works async fn async_fn_multiple_args(x: &u8, _y: &u8) -> u8 { - await!(wake_and_yield_once()); + wake_and_yield_once().await; *x } -*/ async fn async_fn_multiple_args_named_lifetime<'a>(x: &'a u8, _y: &'a u8) -> u8 { wake_and_yield_once().await; diff --git a/src/test/ui/async-await/issues/issue-60655-latebound-regions.rs b/src/test/ui/async-await/issues/issue-60655-latebound-regions.rs index 2328ceb144f..99213e64d16 100644 --- a/src/test/ui/async-await/issues/issue-60655-latebound-regions.rs +++ b/src/test/ui/async-await/issues/issue-60655-latebound-regions.rs @@ -1,13 +1,14 @@ -// Test that existential types are allowed to contain late-bound regions. +// Test that opaque `impl Trait` types are allowed to contain late-bound regions. // build-pass (FIXME(62277): could be check-pass?) // edition:2018 -#![feature(async_await, existential_type)] +#![feature(async_await)] +#![feature(type_alias_impl_trait)] use std::future::Future; -pub existential type Func: Sized; +pub type Func = impl Sized; // Late bound region should be allowed to escape the function, since it's bound // in the type. @@ -17,7 +18,7 @@ fn null_function_ptr() -> Func { async fn async_nop(_: &u8) {} -pub existential type ServeFut: Future<Output=()>; +pub type ServeFut = impl Future<Output=()>; // Late bound regions occur in the generator witness type here. fn serve() -> ServeFut { diff --git a/src/test/ui/existential-type/issue-52843-closure-constrain.rs b/src/test/ui/existential-type/issue-52843-closure-constrain.rs deleted file mode 100644 index b2bbc1f1549..00000000000 --- a/src/test/ui/existential-type/issue-52843-closure-constrain.rs +++ /dev/null @@ -1,12 +0,0 @@ -// Checks to ensure that we properly detect when a closure constrains an existential type -#![feature(existential_type)] - -use std::fmt::Debug; - -fn main() { - existential type Existential: Debug; - fn _unused() -> Existential { String::new() } - //~^ ERROR: concrete type differs from previous defining existential type use - let null = || -> Existential { 0 }; - println!("{:?}", null()); -} diff --git a/src/test/ui/existential-type/issue-52843-closure-constrain.stderr b/src/test/ui/existential-type/issue-52843-closure-constrain.stderr deleted file mode 100644 index 424d65a193c..00000000000 --- a/src/test/ui/existential-type/issue-52843-closure-constrain.stderr +++ /dev/null @@ -1,20 +0,0 @@ -error: concrete type differs from previous defining existential type use - --> $DIR/issue-52843-closure-constrain.rs:8:5 - | -LL | fn _unused() -> Existential { String::new() } - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, got `std::string::String` - | -note: previous use here - --> $DIR/issue-52843-closure-constrain.rs:6:1 - | -LL | / fn main() { -LL | | existential type Existential: Debug; -LL | | fn _unused() -> Existential { String::new() } -LL | | -LL | | let null = || -> Existential { 0 }; -LL | | println!("{:?}", null()); -LL | | } - | |_^ - -error: aborting due to previous error - diff --git a/src/test/ui/existential_types/auxiliary/cross_crate_ice.rs b/src/test/ui/existential_types/auxiliary/cross_crate_ice.rs deleted file mode 100644 index 96ab476061d..00000000000 --- a/src/test/ui/existential_types/auxiliary/cross_crate_ice.rs +++ /dev/null @@ -1,11 +0,0 @@ -// Crate that exports an existential type. Used for testing cross-crate. - -#![crate_type="rlib"] - -#![feature(existential_type)] - -pub existential type Foo: std::fmt::Debug; - -pub fn foo() -> Foo { - 5 -} diff --git a/src/test/ui/existential_types/declared_but_never_defined.rs b/src/test/ui/existential_types/declared_but_never_defined.rs deleted file mode 100644 index ff253391f2a..00000000000 --- a/src/test/ui/existential_types/declared_but_never_defined.rs +++ /dev/null @@ -1,6 +0,0 @@ -#![feature(existential_type)] - -fn main() {} - -// declared but never defined -existential type Bar: std::fmt::Debug; //~ ERROR could not find defining uses diff --git a/src/test/ui/existential_types/declared_but_not_defined_in_scope.rs b/src/test/ui/existential_types/declared_but_not_defined_in_scope.rs deleted file mode 100644 index a6311ee964d..00000000000 --- a/src/test/ui/existential_types/declared_but_not_defined_in_scope.rs +++ /dev/null @@ -1,12 +0,0 @@ -#![feature(existential_type)] - -fn main() {} - -mod boo { - // declared in module but not defined inside of it - pub existential type Boo: ::std::fmt::Debug; //~ ERROR could not find defining uses -} - -fn bomp() -> boo::Boo { - "" -} diff --git a/src/test/ui/existential_types/existential-types-with-cycle-error.stderr b/src/test/ui/existential_types/existential-types-with-cycle-error.stderr deleted file mode 100644 index 98a269d5271..00000000000 --- a/src/test/ui/existential_types/existential-types-with-cycle-error.stderr +++ /dev/null @@ -1,8 +0,0 @@ -error: could not find defining uses - --> $DIR/existential-types-with-cycle-error.rs:3:1 - | -LL | existential type Foo: Fn() -> Foo; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error: aborting due to previous error - diff --git a/src/test/ui/existential_types/existential-types-with-cycle-error2.stderr b/src/test/ui/existential_types/existential-types-with-cycle-error2.stderr deleted file mode 100644 index 830305d8631..00000000000 --- a/src/test/ui/existential_types/existential-types-with-cycle-error2.stderr +++ /dev/null @@ -1,8 +0,0 @@ -error: could not find defining uses - --> $DIR/existential-types-with-cycle-error2.rs:7:1 - | -LL | existential type Foo: Bar<Foo, Item = Foo>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error: aborting due to previous error - diff --git a/src/test/ui/existential_types/generic_duplicate_lifetime_param.rs b/src/test/ui/existential_types/generic_duplicate_lifetime_param.rs deleted file mode 100644 index e9943beddbf..00000000000 --- a/src/test/ui/existential_types/generic_duplicate_lifetime_param.rs +++ /dev/null @@ -1,9 +0,0 @@ -#![feature(existential_type)] - -fn main() {} - -existential type Two<'a, 'b>: std::fmt::Debug; - -fn one<'a>(t: &'a ()) -> Two<'a, 'a> { //~ ERROR non-defining existential type use - t -} diff --git a/src/test/ui/existential_types/unused_generic_param.stderr b/src/test/ui/existential_types/unused_generic_param.stderr deleted file mode 100644 index 9d628d069d3..00000000000 --- a/src/test/ui/existential_types/unused_generic_param.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error: at least one trait must be specified - --> $DIR/unused_generic_param.rs:6:39 - | -LL | existential type PartiallyDefined<T>: 'static; - | ^^^^^^^ - -error: at least one trait must be specified - --> $DIR/unused_generic_param.rs:13:40 - | -LL | existential type PartiallyDefined2<T>: 'static; - | ^^^^^^^ - -error: aborting due to 2 previous errors - diff --git a/src/test/ui/feature-gates/feature-gate-existential-type.rs b/src/test/ui/feature-gates/feature-gate-existential-type.rs deleted file mode 100644 index 6dfd2d10870..00000000000 --- a/src/test/ui/feature-gates/feature-gate-existential-type.rs +++ /dev/null @@ -1,17 +0,0 @@ -// Check that existential types must be ungated to use the `existential` keyword - -existential type Foo: std::fmt::Debug; //~ ERROR existential types are unstable - -trait Bar { - type Baa: std::fmt::Debug; - fn define() -> Self::Baa; -} - -impl Bar for () { - existential type Baa: std::fmt::Debug; //~ ERROR existential types are unstable - fn define() -> Self::Baa { 0 } -} - -fn define() -> Foo { 0 } - -fn main() {} diff --git a/src/test/ui/feature-gates/feature-gate-existential-type.stderr b/src/test/ui/feature-gates/feature-gate-existential-type.stderr deleted file mode 100644 index 30e25e55aff..00000000000 --- a/src/test/ui/feature-gates/feature-gate-existential-type.stderr +++ /dev/null @@ -1,21 +0,0 @@ -error[E0658]: existential types are unstable - --> $DIR/feature-gate-existential-type.rs:3:1 - | -LL | existential type Foo: std::fmt::Debug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: for more information, see https://github.com/rust-lang/rust/issues/63063 - = help: add `#![feature(existential_type)]` to the crate attributes to enable - -error[E0658]: existential types are unstable - --> $DIR/feature-gate-existential-type.rs:11:5 - | -LL | existential type Baa: std::fmt::Debug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: for more information, see https://github.com/rust-lang/rust/issues/63063 - = help: add `#![feature(existential_type)]` to the crate attributes to enable - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0658`. diff --git a/src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.rs b/src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.rs new file mode 100644 index 00000000000..4a0c8c52c4e --- /dev/null +++ b/src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.rs @@ -0,0 +1,15 @@ +type Foo = impl std::fmt::Debug; //~ ERROR `impl Trait` in type aliases is unstable + +trait Bar { + type Baa: std::fmt::Debug; + fn define() -> Self::Baa; +} + +impl Bar for () { + type Baa = impl std::fmt::Debug; //~ ERROR `impl Trait` in type aliases is unstable + fn define() -> Self::Baa { 0 } +} + +fn define() -> Foo { 0 } + +fn main() {} diff --git a/src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.stderr b/src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.stderr new file mode 100644 index 00000000000..2d0710ea37c --- /dev/null +++ b/src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.stderr @@ -0,0 +1,21 @@ +error[E0658]: `impl Trait` in type aliases is unstable + --> $DIR/feature-gate-type_alias_impl_trait.rs:1:1 + | +LL | type Foo = impl std::fmt::Debug; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/63063 + = help: add `#![feature(type_alias_impl_trait)]` to the crate attributes to enable + +error[E0658]: `impl Trait` in type aliases is unstable + --> $DIR/feature-gate-type_alias_impl_trait.rs:9:5 + | +LL | type Baa = impl std::fmt::Debug; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/63063 + = help: add `#![feature(type_alias_impl_trait)]` to the crate attributes to enable + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0658`. diff --git a/src/test/ui/impl-trait/associated-existential-type-generic-trait.rs b/src/test/ui/impl-trait/associated-impl-trait-type-generic-trait.rs index 130de9ccf62..6c7c46b0e3d 100644 --- a/src/test/ui/impl-trait/associated-existential-type-generic-trait.rs +++ b/src/test/ui/impl-trait/associated-impl-trait-type-generic-trait.rs @@ -1,4 +1,4 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] // build-pass (FIXME(62277): could be check-pass?) trait Bar {} @@ -11,7 +11,7 @@ trait Foo<T> { } impl<W> Foo<W> for i32 { - existential type Assoc: Bar; + type Assoc = impl Bar; fn foo(w: W) -> Self::Assoc { Dummy(w) } @@ -21,7 +21,7 @@ struct NonGeneric; impl Bar for NonGeneric {} impl<W> Foo<W> for u32 { - existential type Assoc: Bar; + type Assoc = impl Bar; fn foo(_: W) -> Self::Assoc { NonGeneric } diff --git a/src/test/ui/impl-trait/associated-existential-type-trivial.rs b/src/test/ui/impl-trait/associated-impl-trait-type-trivial.rs index 0e83b4084b6..cdda341cad8 100644 --- a/src/test/ui/impl-trait/associated-existential-type-trivial.rs +++ b/src/test/ui/impl-trait/associated-impl-trait-type-trivial.rs @@ -1,4 +1,4 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] // build-pass (FIXME(62277): could be check-pass?) trait Bar {} @@ -11,7 +11,7 @@ trait Foo { } impl Foo for i32 { - existential type Assoc: Bar; + type Assoc = impl Bar; fn foo() -> Self::Assoc { Dummy } diff --git a/src/test/ui/impl-trait/associated-existential-type.rs b/src/test/ui/impl-trait/associated-impl-trait-type.rs index 58966aefe1c..d0661d66f4b 100644 --- a/src/test/ui/impl-trait/associated-existential-type.rs +++ b/src/test/ui/impl-trait/associated-impl-trait-type.rs @@ -1,4 +1,4 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] // build-pass (FIXME(62277): could be check-pass?) trait Bar {} @@ -12,7 +12,7 @@ trait Foo { } impl Foo for i32 { - existential type Assoc: Bar; + type Assoc = impl Bar; fn foo() -> Self::Assoc { Dummy } diff --git a/src/test/ui/impl-trait/bound-normalization-fail.rs b/src/test/ui/impl-trait/bound-normalization-fail.rs index 476ae62fa0f..c33261bfd09 100644 --- a/src/test/ui/impl-trait/bound-normalization-fail.rs +++ b/src/test/ui/impl-trait/bound-normalization-fail.rs @@ -2,7 +2,6 @@ // edition:2018 #![feature(async_await)] -#![feature(existential_type)] #![feature(impl_trait_in_bindings)] //~^ WARNING the feature `impl_trait_in_bindings` is incomplete diff --git a/src/test/ui/impl-trait/bound-normalization-fail.stderr b/src/test/ui/impl-trait/bound-normalization-fail.stderr index 24a687491e5..aa306a7e08a 100644 --- a/src/test/ui/impl-trait/bound-normalization-fail.stderr +++ b/src/test/ui/impl-trait/bound-normalization-fail.stderr @@ -1,5 +1,5 @@ warning: the feature `impl_trait_in_bindings` is incomplete and may cause the compiler to crash - --> $DIR/bound-normalization-fail.rs:6:12 + --> $DIR/bound-normalization-fail.rs:5:12 | LL | #![feature(impl_trait_in_bindings)] | ^^^^^^^^^^^^^^^^^^^^^^ @@ -7,7 +7,7 @@ LL | #![feature(impl_trait_in_bindings)] = note: `#[warn(incomplete_features)]` on by default error[E0271]: type mismatch resolving `<Foo<()> as FooLike>::Output == <T as impl_trait::Trait>::Assoc` - --> $DIR/bound-normalization-fail.rs:30:32 + --> $DIR/bound-normalization-fail.rs:29:32 | LL | fn foo_fail<T: Trait>() -> impl FooLike<Output=T::Assoc> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), found associated type @@ -17,7 +17,7 @@ LL | fn foo_fail<T: Trait>() -> impl FooLike<Output=T::Assoc> { = note: the return type of a function must have a statically known size error[E0271]: type mismatch resolving `<Foo<()> as FooLike>::Output == <T as lifetimes::Trait<'static>>::Assoc` - --> $DIR/bound-normalization-fail.rs:47:41 + --> $DIR/bound-normalization-fail.rs:46:41 | LL | fn foo2_fail<'a, T: Trait<'a>>() -> impl FooLike<Output=T::Assoc> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), found associated type diff --git a/src/test/ui/impl-trait/bound-normalization-pass.rs b/src/test/ui/impl-trait/bound-normalization-pass.rs index 3fdd7c0ecb6..5b634e3106e 100644 --- a/src/test/ui/impl-trait/bound-normalization-pass.rs +++ b/src/test/ui/impl-trait/bound-normalization-pass.rs @@ -2,7 +2,7 @@ // edition:2018 #![feature(async_await)] -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] #![feature(impl_trait_in_bindings)] //~^ WARNING the feature `impl_trait_in_bindings` is incomplete @@ -81,9 +81,9 @@ mod impl_trait_in_bindings { } ///////////////////////////////////////////// -// The same applied to `existential type`s +// The same applied to `type Foo = impl Bar`s -mod existential_types { +mod opaque_types { trait Implemented { type Assoc; } @@ -99,7 +99,7 @@ mod existential_types { type Out = u8; } - existential type Ex: Trait<Out = <() as Implemented>::Assoc>; + type Ex = impl Trait<Out = <() as Implemented>::Assoc>; fn define() -> Ex { () diff --git a/src/test/ui/impl-trait/issue-55872-1.rs b/src/test/ui/impl-trait/issue-55872-1.rs index 5095b26f8a4..f99096b4d58 100644 --- a/src/test/ui/impl-trait/issue-55872-1.rs +++ b/src/test/ui/impl-trait/issue-55872-1.rs @@ -1,5 +1,5 @@ // ignore-tidy-linelength -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] pub trait Bar { @@ -9,12 +9,12 @@ pub trait Bar } impl<S: Default> Bar for S { - existential type E: Copy; + type E = impl Copy; //~^ ERROR the trait bound `S: std::marker::Copy` is not satisfied in `(S, T)` [E0277] //~^^ ERROR the trait bound `T: std::marker::Copy` is not satisfied in `(S, T)` [E0277] fn foo<T: Default>() -> Self::E { - //~^ ERROR type parameter `T` is part of concrete type but not used in parameter list for existential type + //~^ ERROR type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias (S::default(), T::default()) } } diff --git a/src/test/ui/impl-trait/issue-55872-1.stderr b/src/test/ui/impl-trait/issue-55872-1.stderr index 04b4d2d4a50..d5756c01559 100644 --- a/src/test/ui/impl-trait/issue-55872-1.stderr +++ b/src/test/ui/impl-trait/issue-55872-1.stderr @@ -1,8 +1,8 @@ error[E0277]: the trait bound `S: std::marker::Copy` is not satisfied in `(S, T)` --> $DIR/issue-55872-1.rs:12:5 | -LL | existential type E: Copy; - | ^^^^^^^^^^^^^^^^^^^^^^^^^ within `(S, T)`, the trait `std::marker::Copy` is not implemented for `S` +LL | type E = impl Copy; + | ^^^^^^^^^^^^^^^^^^^ within `(S, T)`, the trait `std::marker::Copy` is not implemented for `S` | = help: consider adding a `where S: std::marker::Copy` bound = note: required because it appears within the type `(S, T)` @@ -11,14 +11,14 @@ LL | existential type E: Copy; error[E0277]: the trait bound `T: std::marker::Copy` is not satisfied in `(S, T)` --> $DIR/issue-55872-1.rs:12:5 | -LL | existential type E: Copy; - | ^^^^^^^^^^^^^^^^^^^^^^^^^ within `(S, T)`, the trait `std::marker::Copy` is not implemented for `T` +LL | type E = impl Copy; + | ^^^^^^^^^^^^^^^^^^^ within `(S, T)`, the trait `std::marker::Copy` is not implemented for `T` | = help: consider adding a `where T: std::marker::Copy` bound = note: required because it appears within the type `(S, T)` = note: the return type of a function must have a statically known size -error: type parameter `T` is part of concrete type but not used in parameter list for existential type +error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias --> $DIR/issue-55872-1.rs:16:37 | LL | fn foo<T: Default>() -> Self::E { diff --git a/src/test/ui/impl-trait/issue-55872-2.rs b/src/test/ui/impl-trait/issue-55872-2.rs index 2bdeb14bdc3..dfee20ca649 100644 --- a/src/test/ui/impl-trait/issue-55872-2.rs +++ b/src/test/ui/impl-trait/issue-55872-2.rs @@ -1,6 +1,6 @@ // edition:2018 // ignore-tidy-linelength -#![feature(async_await, existential_type)] +#![feature(async_await, type_alias_impl_trait)] pub trait Bar { type E: Copy; @@ -9,10 +9,10 @@ pub trait Bar { } impl<S> Bar for S { - existential type E: Copy; + type E = impl Copy; //~^ ERROR the trait bound `impl std::future::Future: std::marker::Copy` is not satisfied [E0277] fn foo<T>() -> Self::E { - //~^ ERROR type parameter `T` is part of concrete type but not used in parameter list for existential type + //~^ ERROR type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias async {} } } diff --git a/src/test/ui/impl-trait/issue-55872-2.stderr b/src/test/ui/impl-trait/issue-55872-2.stderr index 2505a82ee23..676c3fe3d4c 100644 --- a/src/test/ui/impl-trait/issue-55872-2.stderr +++ b/src/test/ui/impl-trait/issue-55872-2.stderr @@ -1,12 +1,12 @@ error[E0277]: the trait bound `impl std::future::Future: std::marker::Copy` is not satisfied --> $DIR/issue-55872-2.rs:12:5 | -LL | existential type E: Copy; - | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Copy` is not implemented for `impl std::future::Future` +LL | type E = impl Copy; + | ^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Copy` is not implemented for `impl std::future::Future` | = note: the return type of a function must have a statically known size -error: type parameter `T` is part of concrete type but not used in parameter list for existential type +error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias --> $DIR/issue-55872-2.rs:14:28 | LL | fn foo<T>() -> Self::E { diff --git a/src/test/ui/impl-trait/issue-55872.rs b/src/test/ui/impl-trait/issue-55872.rs index 95604545c37..bc91aae70c7 100644 --- a/src/test/ui/impl-trait/issue-55872.rs +++ b/src/test/ui/impl-trait/issue-55872.rs @@ -1,5 +1,5 @@ // ignore-tidy-linelength -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] pub trait Bar { type E: Copy; @@ -8,10 +8,10 @@ pub trait Bar { } impl<S> Bar for S { - existential type E: Copy; + type E = impl Copy; fn foo<T>() -> Self::E { - //~^ ERROR type parameter `T` is part of concrete type but not used in parameter list for existential type + //~^ ERROR type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias || () } } diff --git a/src/test/ui/impl-trait/issue-55872.stderr b/src/test/ui/impl-trait/issue-55872.stderr index 487f276e317..60654ec3461 100644 --- a/src/test/ui/impl-trait/issue-55872.stderr +++ b/src/test/ui/impl-trait/issue-55872.stderr @@ -1,4 +1,4 @@ -error: type parameter `T` is part of concrete type but not used in parameter list for existential type +error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias --> $DIR/issue-55872.rs:13:28 | LL | fn foo<T>() -> Self::E { diff --git a/src/test/ui/impl-trait/issues/issue-53457.rs b/src/test/ui/impl-trait/issues/issue-53457.rs index 3f6a4fb2787..de8c579743f 100644 --- a/src/test/ui/impl-trait/issues/issue-53457.rs +++ b/src/test/ui/impl-trait/issues/issue-53457.rs @@ -1,8 +1,8 @@ // run-pass -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] -existential type X: Clone; +type X = impl Clone; fn bar<F: Fn(&i32) + Clone>(f: F) -> F { f diff --git a/src/test/ui/impl-trait/multiple-lifetimes/error-handling.rs b/src/test/ui/impl-trait/multiple-lifetimes/error-handling.rs index 61e858ee02d..b226cf058aa 100644 --- a/src/test/ui/impl-trait/multiple-lifetimes/error-handling.rs +++ b/src/test/ui/impl-trait/multiple-lifetimes/error-handling.rs @@ -1,14 +1,14 @@ // compile-flags:-Zborrowck=mir #![feature(member_constraints)] -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] #[derive(Clone)] struct CopyIfEq<T, U>(T, U); impl<T: Copy> Copy for CopyIfEq<T, T> {} -existential type E<'a, 'b>: Sized; +type E<'a, 'b> = impl Sized; fn foo<'a, 'b, 'c>(x: &'static i32, mut y: &'a i32) -> E<'b, 'c> { //~^ ERROR lifetime may not live long enough diff --git a/src/test/ui/impl-trait/multiple-lifetimes/error-handling.stderr b/src/test/ui/impl-trait/multiple-lifetimes/error-handling.stderr index b59dfbe9f2a..f27e6ff44a6 100644 --- a/src/test/ui/impl-trait/multiple-lifetimes/error-handling.stderr +++ b/src/test/ui/impl-trait/multiple-lifetimes/error-handling.stderr @@ -5,7 +5,7 @@ LL | fn foo<'a, 'b, 'c>(x: &'static i32, mut y: &'a i32) -> E<'b, 'c> { | -- lifetime `'a` defined here ^^^^^^^^^ opaque type requires that `'a` must outlive `'static` help: to allow this `impl Trait` to capture borrowed data with lifetime `'a`, add `'a` as a constraint | -LL | existential type E<'a, 'b>: Sized; + 'a +LL | type E<'a, 'b> = impl Sized; + 'a | error: aborting due to previous error diff --git a/src/test/ui/impl-trait/multiple-lifetimes/ordinary-bounds-pick-original-existential.rs b/src/test/ui/impl-trait/multiple-lifetimes/ordinary-bounds-pick-original-type-alias-impl-trait.rs index 43915e05e88..ae44b371f4f 100644 --- a/src/test/ui/impl-trait/multiple-lifetimes/ordinary-bounds-pick-original-existential.rs +++ b/src/test/ui/impl-trait/multiple-lifetimes/ordinary-bounds-pick-original-type-alias-impl-trait.rs @@ -4,7 +4,7 @@ //[mir]compile-flags: -Z borrowck=mir #![feature(member_constraints)] -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] trait Trait<'a, 'b> { } impl<T> Trait<'_, '_> for T { } @@ -12,7 +12,7 @@ impl<T> Trait<'_, '_> for T { } // Here we wind up selecting `'a` and `'b` in the hidden type because // those are the types that appear in the original values. -existential type Foo<'a, 'b>: Trait<'a, 'b>; +type Foo<'a, 'b> = impl Trait<'a, 'b>; fn upper_bounds<'a, 'b>(a: &'a u8, b: &'b u8) -> Foo<'a, 'b> { // In this simple case, you have a hidden type `(&'0 u8, &'1 u8)` and constraints like diff --git a/src/test/ui/impl-trait/existential-minimal.rs b/src/test/ui/impl-trait/return-position-impl-trait-minimal.rs index 6d3c0692970..6d3c0692970 100644 --- a/src/test/ui/impl-trait/existential-minimal.rs +++ b/src/test/ui/impl-trait/return-position-impl-trait-minimal.rs diff --git a/src/test/ui/impl-trait/existential_type_in_fn_body.rs b/src/test/ui/impl-trait/type-alias-impl-trait-in-fn-body.rs index 32fc4a97ef4..91be4efd56a 100644 --- a/src/test/ui/impl-trait/existential_type_in_fn_body.rs +++ b/src/test/ui/impl-trait/type-alias-impl-trait-in-fn-body.rs @@ -1,11 +1,11 @@ // build-pass (FIXME(62277): could be check-pass?) -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() { - existential type Existential: Debug; + type Existential = impl Debug; fn f() -> Existential {} println!("{:?}", f()); diff --git a/src/test/ui/impl-trait/where-allowed.rs b/src/test/ui/impl-trait/where-allowed.rs index 31bc9f449a0..9eac6b714de 100644 --- a/src/test/ui/impl-trait/where-allowed.rs +++ b/src/test/ui/impl-trait/where-allowed.rs @@ -120,7 +120,8 @@ trait DummyTrait { } impl DummyTrait for () { type Out = impl Debug; - //~^ ERROR `impl Trait` not allowed outside of function and inherent method return types + //~^ ERROR `impl Trait` in type aliases is unstable + //~^^ ERROR could not find defining uses fn in_trait_impl_parameter(_: impl Debug) { } // Allowed @@ -155,7 +156,8 @@ extern "C" fn in_extern_fn_return() -> impl Debug { } type InTypeAlias<R> = impl Debug; -//~^ ERROR `impl Trait` not allowed outside of function and inherent method return types +//~^ ERROR `impl Trait` in type aliases is unstable +//~^^ ERROR could not find defining uses type InReturnInTypeAlias<R> = fn() -> impl Debug; //~^ ERROR `impl Trait` not allowed outside of function and inherent method return types diff --git a/src/test/ui/impl-trait/where-allowed.stderr b/src/test/ui/impl-trait/where-allowed.stderr index 9895b028a4e..1332fff84f5 100644 --- a/src/test/ui/impl-trait/where-allowed.stderr +++ b/src/test/ui/impl-trait/where-allowed.stderr @@ -16,6 +16,24 @@ LL | fn in_impl_Fn_parameter_in_return() -> &'static impl Fn(impl Debug) { panic | | nested `impl Trait` here | outer `impl Trait` +error[E0658]: `impl Trait` in type aliases is unstable + --> $DIR/where-allowed.rs:122:5 + | +LL | type Out = impl Debug; + | ^^^^^^^^^^^^^^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/63063 + = help: add `#![feature(type_alias_impl_trait)]` to the crate attributes to enable + +error[E0658]: `impl Trait` in type aliases is unstable + --> $DIR/where-allowed.rs:158:1 + | +LL | type InTypeAlias<R> = impl Debug; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/63063 + = help: add `#![feature(type_alias_impl_trait)]` to the crate attributes to enable + error[E0562]: `impl Trait` not allowed outside of function and inherent method return types --> $DIR/where-allowed.rs:18:40 | @@ -137,97 +155,85 @@ LL | fn in_return() -> impl Debug; | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:122:16 - | -LL | type Out = impl Debug; - | ^^^^^^^^^^ - -error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:128:34 + --> $DIR/where-allowed.rs:129:34 | LL | fn in_trait_impl_return() -> impl Debug { () } | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:141:33 + --> $DIR/where-allowed.rs:142:33 | LL | fn in_foreign_parameters(_: impl Debug); | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:144:31 + --> $DIR/where-allowed.rs:145:31 | LL | fn in_foreign_return() -> impl Debug; | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:157:23 - | -LL | type InTypeAlias<R> = impl Debug; - | ^^^^^^^^^^ - -error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:160:39 + --> $DIR/where-allowed.rs:162:39 | LL | type InReturnInTypeAlias<R> = fn() -> impl Debug; | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:164:16 + --> $DIR/where-allowed.rs:166:16 | LL | impl PartialEq<impl Debug> for () { | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:169:24 + --> $DIR/where-allowed.rs:171:24 | LL | impl PartialEq<()> for impl Debug { | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:174:6 + --> $DIR/where-allowed.rs:176:6 | LL | impl impl Debug { | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:180:24 + --> $DIR/where-allowed.rs:182:24 | LL | impl InInherentImplAdt<impl Debug> { | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:186:11 + --> $DIR/where-allowed.rs:188:11 | LL | where impl Debug: Debug | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:193:15 + --> $DIR/where-allowed.rs:195:15 | LL | where Vec<impl Debug>: Debug | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:200:24 + --> $DIR/where-allowed.rs:202:24 | LL | where T: PartialEq<impl Debug> | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:207:17 + --> $DIR/where-allowed.rs:209:17 | LL | where T: Fn(impl Debug) | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:214:22 + --> $DIR/where-allowed.rs:216:22 | LL | where T: Fn() -> impl Debug | ^^^^^^^^^^ error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:220:29 + --> $DIR/where-allowed.rs:222:29 | LL | let _in_local_variable: impl Fn() = || {}; | ^^^^^^^^^ @@ -235,11 +241,24 @@ LL | let _in_local_variable: impl Fn() = || {}; = help: add `#![feature(impl_trait_in_bindings)]` to the crate attributes to enable error[E0562]: `impl Trait` not allowed outside of function and inherent method return types - --> $DIR/where-allowed.rs:222:46 + --> $DIR/where-allowed.rs:224:46 | LL | let _in_return_in_local_variable = || -> impl Fn() { || {} }; | ^^^^^^^^^ -error: aborting due to 39 previous errors +error: could not find defining uses + --> $DIR/where-allowed.rs:158:1 + | +LL | type InTypeAlias<R> = impl Debug; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: could not find defining uses + --> $DIR/where-allowed.rs:122:5 + | +LL | type Out = impl Debug; + | ^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 41 previous errors -For more information about this error, try `rustc --explain E0562`. +Some errors have detailed explanations: E0562, E0658. +For more information about an error, try `rustc --explain E0562`. diff --git a/src/test/ui/in-band-lifetimes.rs b/src/test/ui/in-band-lifetimes.rs index c9f7d28699e..9b2e1fe83c1 100644 --- a/src/test/ui/in-band-lifetimes.rs +++ b/src/test/ui/in-band-lifetimes.rs @@ -77,19 +77,19 @@ fn impl_trait_in_band(x: &impl MyTrait<'a>) {} trait FunkyTrait<'a> { } impl<'a, T> FunkyTrait<'a> for T { } -fn existential_impl_trait_in_band_outlives(x: &'a u32) -> impl ::std::fmt::Debug + 'a { +fn ret_pos_impl_trait_in_band_outlives(x: &'a u32) -> impl ::std::fmt::Debug + 'a { x } -fn existential_impl_trait_in_band_param(x: &'a u32) -> impl FunkyTrait<'a> { +fn ret_pos_impl_trait_in_band_param(x: &'a u32) -> impl FunkyTrait<'a> { x } -fn existential_impl_trait_in_band_param_static(x: &'a u32) -> impl FunkyTrait<'static> + 'a { +fn ret_pos_impl_trait_in_band_param_static(x: &'a u32) -> impl FunkyTrait<'static> + 'a { x } -fn existential_impl_trait_in_band_param_outlives(x: &'a u32) -> impl FunkyTrait<'a> + 'a { +fn ret_pos_impl_trait_in_band_param_outlives(x: &'a u32) -> impl FunkyTrait<'a> + 'a { x } -fn existential_impl_trait_in_band_higher_ranked(x: &'a u32) -> impl for<'b> FunkyTrait<'b> + 'a { +fn ret_pos_impl_trait_in_band_higher_ranked(x: &'a u32) -> impl for<'b> FunkyTrait<'b> + 'a { x } diff --git a/src/test/ui/issues/issue-58856-2.rs b/src/test/ui/issues/issue-58856-2.rs index acc38e4c201..745f0300bd5 100644 --- a/src/test/ui/issues/issue-58856-2.rs +++ b/src/test/ui/issues/issue-58856-2.rs @@ -9,6 +9,6 @@ impl Howness for () { Empty } } -//~^ ERROR expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, +//~^ ERROR expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, fn main() {} diff --git a/src/test/ui/issues/issue-58856-2.stderr b/src/test/ui/issues/issue-58856-2.stderr index b760fd6768a..a83dd674a87 100644 --- a/src/test/ui/issues/issue-58856-2.stderr +++ b/src/test/ui/issues/issue-58856-2.stderr @@ -7,11 +7,11 @@ LL | fn how_are_you(&self -> Empty { | | help: `)` may belong here | unclosed delimiter -error: expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, `unsafe`, or `}`, found `)` +error: expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, `unsafe`, or `}`, found `)` --> $DIR/issue-58856-2.rs:11:1 | LL | } - | - expected one of 11 possible tokens here + | - expected one of 10 possible tokens here LL | } | ^ unexpected token diff --git a/src/test/ui/issues/issue-60662.rs b/src/test/ui/issues/issue-60662.rs index dca1e5979ef..dcf935c5780 100644 --- a/src/test/ui/issues/issue-60662.rs +++ b/src/test/ui/issues/issue-60662.rs @@ -1,11 +1,11 @@ // build-pass (FIXME(62277): could be check-pass?) // compile-flags: -Z unpretty=hir -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] trait Animal { } fn main() { - pub existential type ServeFut: Animal; + pub type ServeFut = impl Animal; } diff --git a/src/test/ui/issues/issue-60662.stdout b/src/test/ui/issues/issue-60662.stdout index 139808974c6..e2a88dec97f 100644 --- a/src/test/ui/issues/issue-60662.stdout +++ b/src/test/ui/issues/issue-60662.stdout @@ -1,7 +1,7 @@ // build-pass (FIXME(62277): could be check-pass?) // compile-flags: -Z unpretty=hir -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] #[prelude_import] use ::std::prelude::v1::*; #[macro_use] @@ -10,5 +10,5 @@ extern crate std; trait Animal { } fn main() { - pub existential type ServeFut : Animal; + pub type ServeFut = impl Animal; } diff --git a/src/test/ui/parser/default.stderr b/src/test/ui/parser/default.stderr index ded088acfc4..e199045134e 100644 --- a/src/test/ui/parser/default.stderr +++ b/src/test/ui/parser/default.stderr @@ -1,8 +1,8 @@ -error: expected one of `async`, `const`, `existential`, `extern`, `fn`, `type`, or `unsafe`, found `pub` +error: expected one of `async`, `const`, `extern`, `fn`, `type`, or `unsafe`, found `pub` --> $DIR/default.rs:22:13 | LL | default pub fn foo<T: Default>() -> T { T::default() } - | ^^^ expected one of 7 possible tokens here + | ^^^ expected one of `async`, `const`, `extern`, `fn`, `type`, or `unsafe` here error[E0449]: unnecessary visibility qualifier --> $DIR/default.rs:16:5 diff --git a/src/test/ui/parser/issue-20711-2.rs b/src/test/ui/parser/issue-20711-2.rs index 49b8de03c37..0063a334182 100644 --- a/src/test/ui/parser/issue-20711-2.rs +++ b/src/test/ui/parser/issue-20711-2.rs @@ -1,11 +1,9 @@ -// ignore-tidy-linelength - struct Foo; impl Foo { fn foo() {} #[stable(feature = "rust1", since = "1.0.0")] -} //~ ERROR expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, or +} //~ ERROR expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, or fn main() {} diff --git a/src/test/ui/parser/issue-20711-2.stderr b/src/test/ui/parser/issue-20711-2.stderr index f67dfa09aca..56749c107d1 100644 --- a/src/test/ui/parser/issue-20711-2.stderr +++ b/src/test/ui/parser/issue-20711-2.stderr @@ -1,8 +1,8 @@ -error: expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}` - --> $DIR/issue-20711-2.rs:9:1 +error: expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}` + --> $DIR/issue-20711-2.rs:7:1 | LL | #[stable(feature = "rust1", since = "1.0.0")] - | - expected one of 10 possible tokens here + | - expected one of 9 possible tokens here LL | } | ^ unexpected token diff --git a/src/test/ui/parser/issue-20711.rs b/src/test/ui/parser/issue-20711.rs index 8d8401da61a..dc216167b8a 100644 --- a/src/test/ui/parser/issue-20711.rs +++ b/src/test/ui/parser/issue-20711.rs @@ -1,9 +1,7 @@ -// ignore-tidy-linelength - struct Foo; impl Foo { #[stable(feature = "rust1", since = "1.0.0")] -} //~ ERROR expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, or +} //~ ERROR expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, or fn main() {} diff --git a/src/test/ui/parser/issue-20711.stderr b/src/test/ui/parser/issue-20711.stderr index 26b819fa298..f7b99a91b51 100644 --- a/src/test/ui/parser/issue-20711.stderr +++ b/src/test/ui/parser/issue-20711.stderr @@ -1,8 +1,8 @@ -error: expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}` - --> $DIR/issue-20711.rs:7:1 +error: expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}` + --> $DIR/issue-20711.rs:5:1 | LL | #[stable(feature = "rust1", since = "1.0.0")] - | - expected one of 10 possible tokens here + | - expected one of 9 possible tokens here LL | } | ^ unexpected token diff --git a/src/test/ui/parser/issue-41155.stderr b/src/test/ui/parser/issue-41155.stderr index 719845e6999..624d1a3d11e 100644 --- a/src/test/ui/parser/issue-41155.stderr +++ b/src/test/ui/parser/issue-41155.stderr @@ -1,8 +1,8 @@ -error: expected one of `(`, `async`, `const`, `default`, `existential`, `extern`, `fn`, `type`, or `unsafe`, found `}` +error: expected one of `(`, `async`, `const`, `default`, `extern`, `fn`, `type`, or `unsafe`, found `}` --> $DIR/issue-41155.rs:5:1 | LL | pub - | - expected one of 9 possible tokens here + | - expected one of 8 possible tokens here LL | } | ^ unexpected token diff --git a/src/test/ui/parser/removed-syntax-static-fn.rs b/src/test/ui/parser/removed-syntax-static-fn.rs index df3964196b8..0caddb9855d 100644 --- a/src/test/ui/parser/removed-syntax-static-fn.rs +++ b/src/test/ui/parser/removed-syntax-static-fn.rs @@ -1,10 +1,8 @@ -// ignore-tidy-linelength - struct S; impl S { static fn f() {} + //~^ ERROR expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, } -//~^^ ERROR expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, fn main() {} diff --git a/src/test/ui/parser/removed-syntax-static-fn.stderr b/src/test/ui/parser/removed-syntax-static-fn.stderr index 84e0432c48c..21cb71df657 100644 --- a/src/test/ui/parser/removed-syntax-static-fn.stderr +++ b/src/test/ui/parser/removed-syntax-static-fn.stderr @@ -1,8 +1,8 @@ -error: expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, `unsafe`, or `}`, found `static` - --> $DIR/removed-syntax-static-fn.rs:6:5 +error: expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, `unsafe`, or `}`, found `static` + --> $DIR/removed-syntax-static-fn.rs:4:5 | LL | impl S { - | - expected one of 11 possible tokens here + | - expected one of 10 possible tokens here LL | static fn f() {} | ^^^^^^ unexpected token diff --git a/src/test/ui/privacy/private-in-public-assoc-ty.rs b/src/test/ui/privacy/private-in-public-assoc-ty.rs index 81d23959fd4..3c42f24d5ff 100644 --- a/src/test/ui/privacy/private-in-public-assoc-ty.rs +++ b/src/test/ui/privacy/private-in-public-assoc-ty.rs @@ -1,7 +1,8 @@ // Private types and traits are not allowed in interfaces of associated types. // This test also ensures that the checks are performed even inside private modules. -#![feature(associated_type_defaults, existential_type)] +#![feature(associated_type_defaults)] +#![feature(type_alias_impl_trait)] mod m { struct Priv; @@ -31,7 +32,7 @@ mod m { type Alias1 = Priv; //~^ ERROR private type `m::Priv` in public interface - existential type Exist: PrivTr; + type Exist = impl PrivTr; //~^ ERROR private trait `m::PrivTr` in public interface fn infer_exist() -> Self::Exist { Priv } } diff --git a/src/test/ui/privacy/private-in-public-assoc-ty.stderr b/src/test/ui/privacy/private-in-public-assoc-ty.stderr index 0b32e4cd306..158862f9228 100644 --- a/src/test/ui/privacy/private-in-public-assoc-ty.stderr +++ b/src/test/ui/privacy/private-in-public-assoc-ty.stderr @@ -1,5 +1,5 @@ warning: private trait `m::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-assoc-ty.rs:15:5 + --> $DIR/private-in-public-assoc-ty.rs:16:5 | LL | / pub trait PubTr { LL | | @@ -15,7 +15,7 @@ LL | | } = note: for more information, see issue #34537 <https://github.com/rust-lang/rust/issues/34537> warning: private type `m::Priv` in public interface (error E0446) - --> $DIR/private-in-public-assoc-ty.rs:15:5 + --> $DIR/private-in-public-assoc-ty.rs:16:5 | LL | / pub trait PubTr { LL | | @@ -30,7 +30,7 @@ LL | | } = note: for more information, see issue #34537 <https://github.com/rust-lang/rust/issues/34537> error[E0446]: private type `m::Priv` in public interface - --> $DIR/private-in-public-assoc-ty.rs:24:9 + --> $DIR/private-in-public-assoc-ty.rs:25:9 | LL | struct Priv; | - `m::Priv` declared as private @@ -39,7 +39,7 @@ LL | type Alias4 = Priv; | ^^^^^^^^^^^^^^^^^^^ can't leak private type error[E0446]: private type `m::Priv` in public interface - --> $DIR/private-in-public-assoc-ty.rs:31:9 + --> $DIR/private-in-public-assoc-ty.rs:32:9 | LL | struct Priv; | - `m::Priv` declared as private @@ -48,13 +48,13 @@ LL | type Alias1 = Priv; | ^^^^^^^^^^^^^^^^^^^ can't leak private type error[E0445]: private trait `m::PrivTr` in public interface - --> $DIR/private-in-public-assoc-ty.rs:34:9 + --> $DIR/private-in-public-assoc-ty.rs:35:9 | LL | trait PrivTr {} | - `m::PrivTr` declared as private ... -LL | existential type Exist: PrivTr; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't leak private trait +LL | type Exist = impl PrivTr; + | ^^^^^^^^^^^^^^^^^^^^^^^^^ can't leak private trait error: aborting due to 3 previous errors diff --git a/src/test/ui/privacy/private-in-public-existential.rs b/src/test/ui/privacy/private-in-public-type-alias-impl-trait.rs index ef50875dcf6..40bba720b0f 100644 --- a/src/test/ui/privacy/private-in-public-existential.rs +++ b/src/test/ui/privacy/private-in-public-type-alias-impl-trait.rs @@ -1,9 +1,9 @@ // build-pass (FIXME(62277): could be check-pass?) -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] #![deny(private_in_public)] -pub existential type Pub: Default; +pub type Pub = impl Default; #[derive(Default)] struct Priv; @@ -18,7 +18,7 @@ pub trait Trait { } impl Trait for u8 { - existential type Pub: Default; + type Pub = impl Default; fn method() -> Self::Pub { Priv } } diff --git a/src/test/ui/traits/trait-bounds-in-arc.rs b/src/test/ui/traits/trait-bounds-in-arc.rs index a45d834297e..941f66c0561 100644 --- a/src/test/ui/traits/trait-bounds-in-arc.rs +++ b/src/test/ui/traits/trait-bounds-in-arc.rs @@ -1,6 +1,6 @@ // run-pass #![allow(unused_must_use)] -// Tests that a heterogeneous list of existential types can be put inside an Arc +// Tests that a heterogeneous list of existential `dyn` types can be put inside an Arc // and shared between threads as long as all types fulfill Send. // ignore-emscripten no threads support diff --git a/src/test/ui/existential_types/existential-associated-type.rs b/src/test/ui/type-alias-impl-trait/associated-type-alias-impl-trait.rs index bfb91f68ffd..42f07d49ffe 100644 --- a/src/test/ui/existential_types/existential-associated-type.rs +++ b/src/test/ui/type-alias-impl-trait/associated-type-alias-impl-trait.rs @@ -1,4 +1,4 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] // build-pass (FIXME(62277): could be check-pass?) trait Bar {} @@ -11,7 +11,7 @@ trait Foo { fn bar() -> Self::Assoc; } -existential type Helper: Bar; +type Helper = impl Bar; impl Foo for i32 { type Assoc = Helper; diff --git a/src/test/ui/type-alias-impl-trait/auxiliary/cross_crate_ice.rs b/src/test/ui/type-alias-impl-trait/auxiliary/cross_crate_ice.rs new file mode 100644 index 00000000000..f61807cbdbd --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/auxiliary/cross_crate_ice.rs @@ -0,0 +1,11 @@ +// Crate that exports an opaque `impl Trait` type. Used for testing cross-crate. + +#![crate_type="rlib"] + +#![feature(type_alias_impl_trait)] + +pub type Foo = impl std::fmt::Debug; + +pub fn foo() -> Foo { + 5 +} diff --git a/src/test/ui/existential_types/auxiliary/cross_crate_ice2.rs b/src/test/ui/type-alias-impl-trait/auxiliary/cross_crate_ice2.rs index 39ec5394feb..00823456267 100644 --- a/src/test/ui/existential_types/auxiliary/cross_crate_ice2.rs +++ b/src/test/ui/type-alias-impl-trait/auxiliary/cross_crate_ice2.rs @@ -1,8 +1,8 @@ -// Crate that exports an existential type. Used for testing cross-crate. +// Crate that exports an opaque `impl Trait` type. Used for testing cross-crate. #![crate_type="rlib"] -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] pub trait View { type Tmp: Iterator<Item = u32>; @@ -13,7 +13,7 @@ pub trait View { pub struct X; impl View for X { - existential type Tmp: Iterator<Item = u32>; + type Tmp = impl Iterator<Item = u32>; fn test(&self) -> Self::Tmp { vec![1,2,3].into_iter() diff --git a/src/test/ui/existential_types/bound_reduction.rs b/src/test/ui/type-alias-impl-trait/bound_reduction.rs index 46bc17293bc..18c840d8ed9 100644 --- a/src/test/ui/existential_types/bound_reduction.rs +++ b/src/test/ui/type-alias-impl-trait/bound_reduction.rs @@ -2,12 +2,12 @@ #![allow(warnings)] -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() { } -existential type Foo<V>: std::fmt::Debug; +type Foo<V> = impl std::fmt::Debug; trait Trait<U> {} diff --git a/src/test/ui/existential_types/bound_reduction2.rs b/src/test/ui/type-alias-impl-trait/bound_reduction2.rs index 542e076d88d..919446877a1 100644 --- a/src/test/ui/existential_types/bound_reduction2.rs +++ b/src/test/ui/type-alias-impl-trait/bound_reduction2.rs @@ -1,4 +1,4 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() { } @@ -7,7 +7,7 @@ trait TraitWithAssoc { type Assoc; } -existential type Foo<V>: Trait<V>; +type Foo<V> = impl Trait<V>; //~^ ERROR could not find defining uses trait Trait<U> {} diff --git a/src/test/ui/existential_types/bound_reduction2.stderr b/src/test/ui/type-alias-impl-trait/bound_reduction2.stderr index b8bad7db6b6..886d17aca36 100644 --- a/src/test/ui/existential_types/bound_reduction2.stderr +++ b/src/test/ui/type-alias-impl-trait/bound_reduction2.stderr @@ -1,4 +1,4 @@ -error: defining existential type use does not fully define existential type +error: defining opaque type use does not fully define opaque type --> $DIR/bound_reduction2.rs:17:1 | LL | / fn foo_desugared<T: TraitWithAssoc>(_: T) -> Foo<T::Assoc> { @@ -9,8 +9,8 @@ LL | | } error: could not find defining uses --> $DIR/bound_reduction2.rs:10:1 | -LL | existential type Foo<V>: Trait<V>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type Foo<V> = impl Trait<V>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 2 previous errors diff --git a/src/test/ui/existential_types/cross_crate_ice.rs b/src/test/ui/type-alias-impl-trait/cross_crate_ice.rs index c30608176aa..c30608176aa 100644 --- a/src/test/ui/existential_types/cross_crate_ice.rs +++ b/src/test/ui/type-alias-impl-trait/cross_crate_ice.rs diff --git a/src/test/ui/existential_types/cross_crate_ice2.rs b/src/test/ui/type-alias-impl-trait/cross_crate_ice2.rs index 3a7e490260f..3a7e490260f 100644 --- a/src/test/ui/existential_types/cross_crate_ice2.rs +++ b/src/test/ui/type-alias-impl-trait/cross_crate_ice2.rs diff --git a/src/test/ui/type-alias-impl-trait/declared_but_never_defined.rs b/src/test/ui/type-alias-impl-trait/declared_but_never_defined.rs new file mode 100644 index 00000000000..c4bf56a9197 --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/declared_but_never_defined.rs @@ -0,0 +1,6 @@ +#![feature(type_alias_impl_trait)] + +fn main() {} + +// declared but never defined +type Bar = impl std::fmt::Debug; //~ ERROR could not find defining uses diff --git a/src/test/ui/existential_types/declared_but_never_defined.stderr b/src/test/ui/type-alias-impl-trait/declared_but_never_defined.stderr index 7294a074db6..ae0fee4333b 100644 --- a/src/test/ui/existential_types/declared_but_never_defined.stderr +++ b/src/test/ui/type-alias-impl-trait/declared_but_never_defined.stderr @@ -1,8 +1,8 @@ error: could not find defining uses --> $DIR/declared_but_never_defined.rs:6:1 | -LL | existential type Bar: std::fmt::Debug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type Bar = impl std::fmt::Debug; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.rs b/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.rs new file mode 100644 index 00000000000..09873a8c8c3 --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.rs @@ -0,0 +1,12 @@ +#![feature(type_alias_impl_trait)] + +fn main() {} + +mod boo { + // declared in module but not defined inside of it + pub type Boo = impl ::std::fmt::Debug; //~ ERROR could not find defining uses +} + +fn bomp() -> boo::Boo { + "" +} diff --git a/src/test/ui/existential_types/declared_but_not_defined_in_scope.stderr b/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.stderr index a72709f7194..0642407aba3 100644 --- a/src/test/ui/existential_types/declared_but_not_defined_in_scope.stderr +++ b/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.stderr @@ -1,8 +1,8 @@ error: could not find defining uses --> $DIR/declared_but_not_defined_in_scope.rs:7:5 | -LL | pub existential type Boo: ::std::fmt::Debug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | pub type Boo = impl ::std::fmt::Debug; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/existential_types/different_defining_uses.rs b/src/test/ui/type-alias-impl-trait/different_defining_uses.rs index a8670cc07f2..2d7780a126c 100644 --- a/src/test/ui/existential_types/different_defining_uses.rs +++ b/src/test/ui/type-alias-impl-trait/different_defining_uses.rs @@ -1,9 +1,9 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} // two definitions with different types -existential type Foo: std::fmt::Debug; +type Foo = impl std::fmt::Debug; fn foo() -> Foo { "" diff --git a/src/test/ui/existential_types/different_defining_uses.stderr b/src/test/ui/type-alias-impl-trait/different_defining_uses.stderr index fddba584798..87ed997ec59 100644 --- a/src/test/ui/existential_types/different_defining_uses.stderr +++ b/src/test/ui/type-alias-impl-trait/different_defining_uses.stderr @@ -1,4 +1,4 @@ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/different_defining_uses.rs:12:1 | LL | / fn bar() -> Foo { diff --git a/src/test/ui/existential_types/different_defining_uses_never_type.rs b/src/test/ui/type-alias-impl-trait/different_defining_uses_never_type.rs index 13ada63e4bc..289b97b00ad 100644 --- a/src/test/ui/existential_types/different_defining_uses_never_type.rs +++ b/src/test/ui/type-alias-impl-trait/different_defining_uses_never_type.rs @@ -1,9 +1,9 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} // two definitions with different types -existential type Foo: std::fmt::Debug; +type Foo = impl std::fmt::Debug; fn foo() -> Foo { "" diff --git a/src/test/ui/existential_types/different_defining_uses_never_type.stderr b/src/test/ui/type-alias-impl-trait/different_defining_uses_never_type.stderr index 14b7a810be2..5be656e8f44 100644 --- a/src/test/ui/existential_types/different_defining_uses_never_type.stderr +++ b/src/test/ui/type-alias-impl-trait/different_defining_uses_never_type.stderr @@ -1,4 +1,4 @@ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/different_defining_uses_never_type.rs:12:1 | LL | / fn bar() -> Foo { @@ -14,7 +14,7 @@ LL | | "" LL | | } | |_^ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/different_defining_uses_never_type.rs:16:1 | LL | / fn boo() -> Foo { diff --git a/src/test/ui/existential_types/different_defining_uses_never_type2.rs b/src/test/ui/type-alias-impl-trait/different_defining_uses_never_type2.rs index 0f02cfaad7e..8549687ea78 100644 --- a/src/test/ui/existential_types/different_defining_uses_never_type2.rs +++ b/src/test/ui/type-alias-impl-trait/different_defining_uses_never_type2.rs @@ -1,11 +1,11 @@ // build-pass (FIXME(62277): could be check-pass?) -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} // two definitions with different types -existential type Foo: std::fmt::Debug; +type Foo = impl std::fmt::Debug; fn foo() -> Foo { "" diff --git a/src/test/ui/existential_types/generic_different_defining_uses.rs b/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.rs index ce3ab88a1c0..ac87c2d446a 100644 --- a/src/test/ui/existential_types/generic_different_defining_uses.rs +++ b/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.rs @@ -1,8 +1,8 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} -existential type MyIter<T>: Iterator<Item = T>; +type MyIter<T> = impl Iterator<Item = T>; fn my_iter<T>(t: T) -> MyIter<T> { std::iter::once(t) diff --git a/src/test/ui/existential_types/generic_different_defining_uses.stderr b/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.stderr index e5b1539ccbb..4bcd2e1cb12 100644 --- a/src/test/ui/existential_types/generic_different_defining_uses.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.stderr @@ -1,4 +1,4 @@ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/generic_different_defining_uses.rs:11:1 | LL | / fn my_iter2<T>(t: T) -> MyIter<T> { diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.rs new file mode 100644 index 00000000000..c18a7116758 --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.rs @@ -0,0 +1,9 @@ +#![feature(type_alias_impl_trait)] + +fn main() {} + +type Two<'a, 'b> = impl std::fmt::Debug; + +fn one<'a>(t: &'a ()) -> Two<'a, 'a> { //~ ERROR non-defining opaque type use + t +} diff --git a/src/test/ui/existential_types/generic_duplicate_lifetime_param.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.stderr index 29bd252babe..a4d9a672154 100644 --- a/src/test/ui/existential_types/generic_duplicate_lifetime_param.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.stderr @@ -1,4 +1,4 @@ -error: non-defining existential type use in defining scope +error: non-defining opaque type use in defining scope --> $DIR/generic_duplicate_lifetime_param.rs:7:1 | LL | / fn one<'a>(t: &'a ()) -> Two<'a, 'a> { @@ -7,10 +7,10 @@ LL | | } | |_^ | note: lifetime used multiple times - --> $DIR/generic_duplicate_lifetime_param.rs:5:22 + --> $DIR/generic_duplicate_lifetime_param.rs:5:10 | -LL | existential type Two<'a, 'b>: std::fmt::Debug; - | ^^ ^^ +LL | type Two<'a, 'b> = impl std::fmt::Debug; + | ^^ ^^ error: aborting due to previous error diff --git a/src/test/ui/existential_types/generic_duplicate_param_use.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use.rs index 3f8753333aa..165e320be5e 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use.rs @@ -1,14 +1,14 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} // test that unused generic parameters are ok -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; //~^ could not find defining uses fn one<T: Debug>(t: T) -> Two<T, T> { -//~^ ERROR defining existential type use restricts existential type +//~^ ERROR defining opaque type use restricts opaque type t } diff --git a/src/test/ui/existential_types/generic_duplicate_param_use.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use.stderr index a3827943b6d..e1794034e20 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use.stderr @@ -1,4 +1,4 @@ -error: defining existential type use restricts existential type by using the generic parameter `T` twice +error: defining opaque type use restricts opaque type by using the generic parameter `T` twice --> $DIR/generic_duplicate_param_use.rs:11:1 | LL | / fn one<T: Debug>(t: T) -> Two<T, T> { @@ -10,8 +10,8 @@ LL | | } error: could not find defining uses --> $DIR/generic_duplicate_param_use.rs:8:1 | -LL | existential type Two<T, U>: Debug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type Two<T, U> = impl Debug; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 2 previous errors diff --git a/src/test/ui/existential_types/generic_duplicate_param_use10.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use10.rs index 0d9c7cdfe71..898dab1b0b9 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use10.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use10.rs @@ -1,11 +1,11 @@ // build-pass (FIXME(62277): could be check-pass?) -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; fn two<T: Debug, U: Debug>(t: T, _: U) -> Two<T, U> { (t, 4u32) diff --git a/src/test/ui/existential_types/generic_duplicate_param_use2.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use2.rs index 3842292decd..0adce817c5c 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use2.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use2.rs @@ -1,14 +1,14 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} // test that unused generic parameters are ok -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; fn one<T: Debug>(t: T) -> Two<T, T> { -//~^ defining existential type use restricts existential type +//~^ defining opaque type use restricts opaque type t } diff --git a/src/test/ui/existential_types/generic_duplicate_param_use2.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr index 74f2802449a..a9a51fa0b4b 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use2.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr @@ -1,4 +1,4 @@ -error: defining existential type use restricts existential type by using the generic parameter `T` twice +error: defining opaque type use restricts opaque type by using the generic parameter `T` twice --> $DIR/generic_duplicate_param_use2.rs:10:1 | LL | / fn one<T: Debug>(t: T) -> Two<T, T> { diff --git a/src/test/ui/existential_types/generic_duplicate_param_use3.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.rs index 05c77c89473..8d3e7f9f424 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use3.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.rs @@ -1,14 +1,14 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} // test that unused generic parameters are ok -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; fn one<T: Debug>(t: T) -> Two<T, T> { -//~^ defining existential type use restricts existential type +//~^ defining opaque type use restricts opaque type t } diff --git a/src/test/ui/existential_types/generic_duplicate_param_use3.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.stderr index 22d5467c363..04dcdc295f9 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use3.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.stderr @@ -1,4 +1,4 @@ -error: defining existential type use restricts existential type by using the generic parameter `T` twice +error: defining opaque type use restricts opaque type by using the generic parameter `T` twice --> $DIR/generic_duplicate_param_use3.rs:10:1 | LL | / fn one<T: Debug>(t: T) -> Two<T, T> { diff --git a/src/test/ui/existential_types/generic_duplicate_param_use4.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use4.rs index 609dbe06cd7..65f7d7f485d 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use4.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use4.rs @@ -1,14 +1,14 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} // test that unused generic parameters are ok -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; fn one<T: Debug>(t: T) -> Two<T, T> { -//~^ ERROR defining existential type use restricts existential type +//~^ ERROR defining opaque type use restricts opaque type t } diff --git a/src/test/ui/existential_types/generic_duplicate_param_use4.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr index d7e695578d3..082177b8212 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use4.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr @@ -1,4 +1,4 @@ -error: defining existential type use restricts existential type by using the generic parameter `T` twice +error: defining opaque type use restricts opaque type by using the generic parameter `T` twice --> $DIR/generic_duplicate_param_use4.rs:10:1 | LL | / fn one<T: Debug>(t: T) -> Two<T, T> { diff --git a/src/test/ui/existential_types/generic_duplicate_param_use5.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.rs index 3f4a23b8b41..ac877310414 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use5.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.rs @@ -1,11 +1,11 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} // test that unused generic parameters are ok -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; fn two<T: Debug, U: Debug>(t: T, u: U) -> Two<T, U> { (t, u) diff --git a/src/test/ui/existential_types/generic_duplicate_param_use5.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.stderr index cf4535d6c2c..589ea749319 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use5.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.stderr @@ -1,4 +1,4 @@ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/generic_duplicate_param_use5.rs:14:1 | LL | / fn three<T: Debug, U: Debug>(t: T, u: U) -> Two<T, U> { diff --git a/src/test/ui/existential_types/generic_duplicate_param_use6.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.rs index 3b8c56352bd..59e7de413a2 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use6.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.rs @@ -1,11 +1,11 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} // test that unused generic parameters are ok -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; fn two<T: Debug, U: Debug>(t: T, u: U) -> Two<T, U> { (t, t) diff --git a/src/test/ui/existential_types/generic_duplicate_param_use6.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.stderr index 1f767dacea8..66649413d38 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use6.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.stderr @@ -1,4 +1,4 @@ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/generic_duplicate_param_use6.rs:14:1 | LL | / fn three<T: Debug, U: Debug>(t: T, u: U) -> Two<T, U> { diff --git a/src/test/ui/existential_types/generic_duplicate_param_use7.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use7.rs index 56e1528c213..712a6539f01 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use7.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use7.rs @@ -1,11 +1,11 @@ // build-pass (FIXME(62277): could be check-pass?) -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} -existential type Two<A, B>: Debug; +type Two<A, B> = impl Debug; fn two<T: Debug + Copy, U>(t: T, u: U) -> Two<T, U> { (t, t) diff --git a/src/test/ui/existential_types/generic_duplicate_param_use8.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.rs index 83501ad8c41..777ded52609 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use8.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.rs @@ -1,10 +1,10 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; fn two<T: Debug, U: Debug>(t: T, _: U) -> Two<T, U> { (t, 4u32) diff --git a/src/test/ui/existential_types/generic_duplicate_param_use8.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.stderr index 58f4f97b241..8f4cf4c6084 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use8.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.stderr @@ -1,4 +1,4 @@ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/generic_duplicate_param_use8.rs:13:1 | LL | / fn three<T: Debug, U: Debug>(_: T, u: U) -> Two<T, U> { diff --git a/src/test/ui/existential_types/generic_duplicate_param_use9.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.rs index 4c6897298c4..491e6647f45 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use9.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.rs @@ -1,10 +1,10 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} -existential type Two<A, B>: Debug; +type Two<A, B> = impl Debug; trait Foo { type Bar: Debug; diff --git a/src/test/ui/existential_types/generic_duplicate_param_use9.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.stderr index fe4ae6cfdd0..4d0b03ba5ed 100644 --- a/src/test/ui/existential_types/generic_duplicate_param_use9.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.stderr @@ -1,4 +1,4 @@ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/generic_duplicate_param_use9.rs:18:1 | LL | / fn three<T: Debug, U: Debug>(t: T, u: U) -> Two<T, U> { diff --git a/src/test/ui/existential_types/generic_lifetime_param.rs b/src/test/ui/type-alias-impl-trait/generic_lifetime_param.rs index 1ea01f17b70..e109c38c986 100644 --- a/src/test/ui/existential_types/generic_lifetime_param.rs +++ b/src/test/ui/type-alias-impl-trait/generic_lifetime_param.rs @@ -1,10 +1,10 @@ // build-pass (FIXME(62277): could be check-pass?) -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} -existential type Region<'a>: std::fmt::Debug; +type Region<'a> = impl std::fmt::Debug; fn region<'b>(a: &'b ()) -> Region<'b> { a diff --git a/src/test/ui/existential_types/generic_nondefining_use.rs b/src/test/ui/type-alias-impl-trait/generic_nondefining_use.rs index ffc965aca47..60106eba175 100644 --- a/src/test/ui/existential_types/generic_nondefining_use.rs +++ b/src/test/ui/type-alias-impl-trait/generic_nondefining_use.rs @@ -1,13 +1,13 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} -existential type Cmp<T>: 'static; +type Cmp<T> = impl 'static; //~^ ERROR could not find defining uses //~^^ ERROR: at least one trait must be specified // not a defining use, because it doesn't define *all* possible generics -fn cmp() -> Cmp<u32> { //~ ERROR defining existential type use does not fully define +fn cmp() -> Cmp<u32> { //~ ERROR defining opaque type use does not fully define 5u32 } diff --git a/src/test/ui/existential_types/generic_nondefining_use.stderr b/src/test/ui/type-alias-impl-trait/generic_nondefining_use.stderr index d205d44c68c..d98d349be3c 100644 --- a/src/test/ui/existential_types/generic_nondefining_use.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_nondefining_use.stderr @@ -1,10 +1,10 @@ error: at least one trait must be specified - --> $DIR/generic_nondefining_use.rs:5:26 + --> $DIR/generic_nondefining_use.rs:5:20 | -LL | existential type Cmp<T>: 'static; - | ^^^^^^^ +LL | type Cmp<T> = impl 'static; + | ^^^^^^^ -error: defining existential type use does not fully define existential type +error: defining opaque type use does not fully define opaque type --> $DIR/generic_nondefining_use.rs:11:1 | LL | / fn cmp() -> Cmp<u32> { @@ -15,8 +15,8 @@ LL | | } error: could not find defining uses --> $DIR/generic_nondefining_use.rs:5:1 | -LL | existential type Cmp<T>: 'static; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type Cmp<T> = impl 'static; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 3 previous errors diff --git a/src/test/ui/existential_types/generic_not_used.rs b/src/test/ui/type-alias-impl-trait/generic_not_used.rs index 054e6f5f2ad..ace52dc83ad 100644 --- a/src/test/ui/existential_types/generic_not_used.rs +++ b/src/test/ui/type-alias-impl-trait/generic_not_used.rs @@ -1,8 +1,8 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} -existential type WrongGeneric<T: 'static>: 'static; +type WrongGeneric<T: 'static> = impl 'static; //~^ ERROR: at least one trait must be specified fn wrong_generic<U: 'static, V: 'static>(_: U, v: V) -> WrongGeneric<U> { diff --git a/src/test/ui/existential_types/generic_not_used.stderr b/src/test/ui/type-alias-impl-trait/generic_not_used.stderr index d243233992b..fe353f6e3d2 100644 --- a/src/test/ui/existential_types/generic_not_used.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_not_used.stderr @@ -1,10 +1,10 @@ error: at least one trait must be specified - --> $DIR/generic_not_used.rs:5:44 + --> $DIR/generic_not_used.rs:5:38 | -LL | existential type WrongGeneric<T: 'static>: 'static; - | ^^^^^^^ +LL | type WrongGeneric<T: 'static> = impl 'static; + | ^^^^^^^ -error: type parameter `V` is part of concrete type but not used in parameter list for existential type +error: type parameter `V` is part of concrete type but not used in parameter list for the `impl Trait` type alias --> $DIR/generic_not_used.rs:8:73 | LL | fn wrong_generic<U: 'static, V: 'static>(_: U, v: V) -> WrongGeneric<U> { diff --git a/src/test/ui/existential_types/generic_type_does_not_live_long_enough.nll.stderr b/src/test/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.nll.stderr index f316644156d..3f25d5fbd9c 100644 --- a/src/test/ui/existential_types/generic_type_does_not_live_long_enough.nll.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.nll.stderr @@ -1,8 +1,8 @@ error: at least one trait must be specified - --> $DIR/generic_type_does_not_live_long_enough.rs:9:35 + --> $DIR/generic_type_does_not_live_long_enough.rs:9:29 | -LL | existential type WrongGeneric<T>: 'static; - | ^^^^^^^ +LL | type WrongGeneric<T> = impl 'static; + | ^^^^^^^ error[E0308]: mismatched types --> $DIR/generic_type_does_not_live_long_enough.rs:6:18 diff --git a/src/test/ui/existential_types/generic_type_does_not_live_long_enough.rs b/src/test/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.rs index d9eedd6dca7..c0f939a5048 100644 --- a/src/test/ui/existential_types/generic_type_does_not_live_long_enough.rs +++ b/src/test/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.rs @@ -1,4 +1,4 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() { let y = 42; @@ -6,7 +6,7 @@ fn main() { let z: i32 = x; //~ ERROR mismatched types } -existential type WrongGeneric<T>: 'static; +type WrongGeneric<T> = impl 'static; //~^ ERROR the parameter type `T` may not live long enough //~^^ ERROR: at least one trait must be specified diff --git a/src/test/ui/existential_types/generic_type_does_not_live_long_enough.stderr b/src/test/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.stderr index 2f76eea4460..12569211df3 100644 --- a/src/test/ui/existential_types/generic_type_does_not_live_long_enough.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.stderr @@ -1,8 +1,8 @@ error: at least one trait must be specified - --> $DIR/generic_type_does_not_live_long_enough.rs:9:35 + --> $DIR/generic_type_does_not_live_long_enough.rs:9:29 | -LL | existential type WrongGeneric<T>: 'static; - | ^^^^^^^ +LL | type WrongGeneric<T> = impl 'static; + | ^^^^^^^ error[E0308]: mismatched types --> $DIR/generic_type_does_not_live_long_enough.rs:6:18 @@ -16,8 +16,8 @@ LL | let z: i32 = x; error[E0310]: the parameter type `T` may not live long enough --> $DIR/generic_type_does_not_live_long_enough.rs:9:1 | -LL | existential type WrongGeneric<T>: 'static; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type WrongGeneric<T> = impl 'static; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ... LL | fn wrong_generic<T>(t: T) -> WrongGeneric<T> { | - help: consider adding an explicit lifetime bound `T: 'static`... @@ -25,8 +25,8 @@ LL | fn wrong_generic<T>(t: T) -> WrongGeneric<T> { note: ...so that the type `T` will meet its required lifetime bounds --> $DIR/generic_type_does_not_live_long_enough.rs:9:1 | -LL | existential type WrongGeneric<T>: 'static; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type WrongGeneric<T> = impl 'static; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 3 previous errors diff --git a/src/test/ui/existential_types/generic_underconstrained.rs b/src/test/ui/type-alias-impl-trait/generic_underconstrained.rs index cc0db893c6a..589612d5ed6 100644 --- a/src/test/ui/existential_types/generic_underconstrained.rs +++ b/src/test/ui/type-alias-impl-trait/generic_underconstrained.rs @@ -1,9 +1,9 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} trait Trait {} -existential type Underconstrained<T: Trait>: 'static; //~ ERROR the trait bound `T: Trait` +type Underconstrained<T: Trait> = impl 'static; //~ ERROR the trait bound `T: Trait` //~^ ERROR: at least one trait must be specified // no `Trait` bound diff --git a/src/test/ui/existential_types/generic_underconstrained.stderr b/src/test/ui/type-alias-impl-trait/generic_underconstrained.stderr index 35083a53eb3..dd90dd1b06f 100644 --- a/src/test/ui/existential_types/generic_underconstrained.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_underconstrained.stderr @@ -1,14 +1,14 @@ error: at least one trait must be specified - --> $DIR/generic_underconstrained.rs:6:46 + --> $DIR/generic_underconstrained.rs:6:40 | -LL | existential type Underconstrained<T: Trait>: 'static; - | ^^^^^^^ +LL | type Underconstrained<T: Trait> = impl 'static; + | ^^^^^^^ error[E0277]: the trait bound `T: Trait` is not satisfied --> $DIR/generic_underconstrained.rs:6:1 | -LL | existential type Underconstrained<T: Trait>: 'static; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `T` +LL | type Underconstrained<T: Trait> = impl 'static; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `T` | = help: consider adding a `where T: Trait` bound = note: the return type of a function must have a statically known size diff --git a/src/test/ui/existential_types/generic_underconstrained2.rs b/src/test/ui/type-alias-impl-trait/generic_underconstrained2.rs index c6263eacd53..87b8aaad957 100644 --- a/src/test/ui/existential_types/generic_underconstrained2.rs +++ b/src/test/ui/type-alias-impl-trait/generic_underconstrained2.rs @@ -1,8 +1,8 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} -existential type Underconstrained<T: std::fmt::Debug>: 'static; +type Underconstrained<T: std::fmt::Debug> = impl 'static; //~^ ERROR `U` doesn't implement `std::fmt::Debug` //~^^ ERROR: at least one trait must be specified @@ -11,7 +11,7 @@ fn underconstrained<U>(_: U) -> Underconstrained<U> { 5u32 } -existential type Underconstrained2<T: std::fmt::Debug>: 'static; +type Underconstrained2<T: std::fmt::Debug> = impl 'static; //~^ ERROR `V` doesn't implement `std::fmt::Debug` //~^^ ERROR: at least one trait must be specified diff --git a/src/test/ui/existential_types/generic_underconstrained2.stderr b/src/test/ui/type-alias-impl-trait/generic_underconstrained2.stderr index 6ff783f33b9..574432bdcf6 100644 --- a/src/test/ui/existential_types/generic_underconstrained2.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_underconstrained2.stderr @@ -1,20 +1,20 @@ error: at least one trait must be specified - --> $DIR/generic_underconstrained2.rs:5:56 + --> $DIR/generic_underconstrained2.rs:5:50 | -LL | existential type Underconstrained<T: std::fmt::Debug>: 'static; - | ^^^^^^^ +LL | type Underconstrained<T: std::fmt::Debug> = impl 'static; + | ^^^^^^^ error: at least one trait must be specified - --> $DIR/generic_underconstrained2.rs:14:57 + --> $DIR/generic_underconstrained2.rs:14:51 | -LL | existential type Underconstrained2<T: std::fmt::Debug>: 'static; - | ^^^^^^^ +LL | type Underconstrained2<T: std::fmt::Debug> = impl 'static; + | ^^^^^^^ error[E0277]: `U` doesn't implement `std::fmt::Debug` --> $DIR/generic_underconstrained2.rs:5:1 | -LL | existential type Underconstrained<T: std::fmt::Debug>: 'static; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `U` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` +LL | type Underconstrained<T: std::fmt::Debug> = impl 'static; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `U` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `U` = help: consider adding a `where U: std::fmt::Debug` bound @@ -23,8 +23,8 @@ LL | existential type Underconstrained<T: std::fmt::Debug>: 'static; error[E0277]: `V` doesn't implement `std::fmt::Debug` --> $DIR/generic_underconstrained2.rs:14:1 | -LL | existential type Underconstrained2<T: std::fmt::Debug>: 'static; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `V` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` +LL | type Underconstrained2<T: std::fmt::Debug> = impl 'static; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `V` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `V` = help: consider adding a `where V: std::fmt::Debug` bound diff --git a/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.rs b/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.rs new file mode 100644 index 00000000000..a102d16078b --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.rs @@ -0,0 +1,13 @@ +// Checks to ensure that we properly detect when a closure constrains an opaque type + +#![feature(type_alias_impl_trait)] + +use std::fmt::Debug; + +fn main() { + type Opaque = impl Debug; + fn _unused() -> Opaque { String::new() } + //~^ ERROR: concrete type differs from previous defining opaque type use + let null = || -> Opaque { 0 }; + println!("{:?}", null()); +} diff --git a/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr b/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr new file mode 100644 index 00000000000..c994eb5986c --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr @@ -0,0 +1,20 @@ +error: concrete type differs from previous defining opaque type use + --> $DIR/issue-52843-closure-constrain.rs:9:5 + | +LL | fn _unused() -> Opaque { String::new() } + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, got `std::string::String` + | +note: previous use here + --> $DIR/issue-52843-closure-constrain.rs:7:1 + | +LL | / fn main() { +LL | | type Opaque = impl Debug; +LL | | fn _unused() -> Opaque { String::new() } +LL | | +LL | | let null = || -> Opaque { 0 }; +LL | | println!("{:?}", null()); +LL | | } + | |_^ + +error: aborting due to previous error + diff --git a/src/test/ui/existential_types/issue-53678-generator-and-const-fn.rs b/src/test/ui/type-alias-impl-trait/issue-53678-generator-and-const-fn.rs index d964f2b74ff..e7f93732430 100644 --- a/src/test/ui/existential_types/issue-53678-generator-and-const-fn.rs +++ b/src/test/ui/type-alias-impl-trait/issue-53678-generator-and-const-fn.rs @@ -1,10 +1,10 @@ // check-pass -#![feature(const_fn, generators, generator_trait, existential_type)] +#![feature(const_fn, generators, generator_trait, type_alias_impl_trait)] use std::ops::Generator; -existential type GenOnce<Y, R>: Generator<Yield = Y, Return = R>; +type GenOnce<Y, R> = impl Generator<Yield = Y, Return = R>; const fn const_generator<Y, R>(yielding: Y, returning: R) -> GenOnce<Y, R> { move || { diff --git a/src/test/ui/existential_types/issue-58887.rs b/src/test/ui/type-alias-impl-trait/issue-58887.rs index f038648ec21..92ba50ae6cf 100644 --- a/src/test/ui/existential_types/issue-58887.rs +++ b/src/test/ui/type-alias-impl-trait/issue-58887.rs @@ -1,4 +1,4 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] trait UnwrapItemsExt { type Iter; @@ -10,7 +10,7 @@ where I: Iterator<Item = Result<T, E>>, E: std::fmt::Debug, { - existential type Iter: Iterator<Item = T>; + type Iter = impl Iterator<Item = T>; //~^ ERROR: could not find defining uses fn unwrap_items(self) -> Self::Iter { diff --git a/src/test/ui/existential_types/issue-58887.stderr b/src/test/ui/type-alias-impl-trait/issue-58887.stderr index 800f4b7e059..7e2895711d3 100644 --- a/src/test/ui/existential_types/issue-58887.stderr +++ b/src/test/ui/type-alias-impl-trait/issue-58887.stderr @@ -1,4 +1,4 @@ -error: type parameter `T` is part of concrete type but not used in parameter list for existential type +error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias --> $DIR/issue-58887.rs:16:41 | LL | fn unwrap_items(self) -> Self::Iter { @@ -9,7 +9,7 @@ LL | | self.map(|x| x.unwrap()) LL | | } | |_____^ -error: type parameter `E` is part of concrete type but not used in parameter list for existential type +error: type parameter `E` is part of concrete type but not used in parameter list for the `impl Trait` type alias --> $DIR/issue-58887.rs:16:41 | LL | fn unwrap_items(self) -> Self::Iter { @@ -23,8 +23,8 @@ LL | | } error: could not find defining uses --> $DIR/issue-58887.rs:13:5 | -LL | existential type Iter: Iterator<Item = T>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type Iter = impl Iterator<Item = T>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 3 previous errors diff --git a/src/test/ui/existential_types/issue-58951.rs b/src/test/ui/type-alias-impl-trait/issue-58951.rs index 410dcdfe347..3416c6745bb 100644 --- a/src/test/ui/existential_types/issue-58951.rs +++ b/src/test/ui/type-alias-impl-trait/issue-58951.rs @@ -1,8 +1,11 @@ // check-pass -#![feature(existential_type)] -existential type A: Iterator; +#![feature(type_alias_impl_trait)] + +type A = impl Iterator; + fn def_a() -> A { 0..1 } + pub fn use_a() { def_a().map(|x| x); } diff --git a/src/test/ui/existential_types/issue-60371.rs b/src/test/ui/type-alias-impl-trait/issue-60371.rs index f9def11d193..50b9d1ac793 100644 --- a/src/test/ui/existential_types/issue-60371.rs +++ b/src/test/ui/type-alias-impl-trait/issue-60371.rs @@ -5,7 +5,7 @@ trait Bug { } impl Bug for &() { - existential type Item: Bug; //~ ERROR existential types are unstable + type Item = impl Bug; //~ ERROR `impl Trait` in type aliases is unstable //~^ ERROR the trait bound `(): Bug` is not satisfied //~^^ ERROR could not find defining uses diff --git a/src/test/ui/existential_types/issue-60371.stderr b/src/test/ui/type-alias-impl-trait/issue-60371.stderr index 092cb31f97d..1e9b12ebc39 100644 --- a/src/test/ui/existential_types/issue-60371.stderr +++ b/src/test/ui/type-alias-impl-trait/issue-60371.stderr @@ -1,17 +1,17 @@ -error[E0658]: existential types are unstable +error[E0658]: `impl Trait` in type aliases is unstable --> $DIR/issue-60371.rs:8:5 | -LL | existential type Item: Bug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type Item = impl Bug; + | ^^^^^^^^^^^^^^^^^^^^^ | = note: for more information, see https://github.com/rust-lang/rust/issues/63063 - = help: add `#![feature(existential_type)]` to the crate attributes to enable + = help: add `#![feature(type_alias_impl_trait)]` to the crate attributes to enable error[E0277]: the trait bound `(): Bug` is not satisfied --> $DIR/issue-60371.rs:8:5 | -LL | existential type Item: Bug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bug` is not implemented for `()` +LL | type Item = impl Bug; + | ^^^^^^^^^^^^^^^^^^^^^ the trait `Bug` is not implemented for `()` | = help: the following implementations were found: <&() as Bug> @@ -20,8 +20,8 @@ LL | existential type Item: Bug; error: could not find defining uses --> $DIR/issue-60371.rs:8:5 | -LL | existential type Item: Bug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type Item = impl Bug; + | ^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 3 previous errors diff --git a/src/test/ui/existential_types/issue-60407.rs b/src/test/ui/type-alias-impl-trait/issue-60407.rs index 52162c491b5..7d462f057cb 100644 --- a/src/test/ui/existential_types/issue-60407.rs +++ b/src/test/ui/type-alias-impl-trait/issue-60407.rs @@ -1,8 +1,8 @@ // check-pass -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] -existential type Debuggable: core::fmt::Debug; +type Debuggable = impl core::fmt::Debug; static mut TEST: Option<Debuggable> = None; diff --git a/src/test/ui/existential_types/issue-60564.rs b/src/test/ui/type-alias-impl-trait/issue-60564.rs index cb3914ddd1d..91c4576597e 100644 --- a/src/test/ui/existential_types/issue-60564.rs +++ b/src/test/ui/type-alias-impl-trait/issue-60564.rs @@ -1,11 +1,11 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] trait IterBits { type BitsIter: Iterator<Item = u8>; fn iter_bits(self, n: u8) -> Self::BitsIter; } -existential type IterBitsIter<T, E, I>: std::iter::Iterator<Item = I>; +type IterBitsIter<T, E, I> = impl std::iter::Iterator<Item = I>; //~^ ERROR could not find defining uses impl<T, E> IterBits for T diff --git a/src/test/ui/existential_types/issue-60564.stderr b/src/test/ui/type-alias-impl-trait/issue-60564.stderr index d8480b52157..ebb13fca1da 100644 --- a/src/test/ui/existential_types/issue-60564.stderr +++ b/src/test/ui/type-alias-impl-trait/issue-60564.stderr @@ -2,7 +2,7 @@ error[E0601]: `main` function not found in crate `issue_60564` | = note: consider adding a `main` function to `$DIR/issue-60564.rs` -error: type parameter `E` is part of concrete type but not used in parameter list for existential type +error: type parameter `E` is part of concrete type but not used in parameter list for the `impl Trait` type alias --> $DIR/issue-60564.rs:20:49 | LL | fn iter_bits(self, n: u8) -> Self::BitsIter { @@ -17,8 +17,8 @@ LL | | } error: could not find defining uses --> $DIR/issue-60564.rs:8:1 | -LL | existential type IterBitsIter<T, E, I>: std::iter::Iterator<Item = I>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type IterBitsIter<T, E, I> = impl std::iter::Iterator<Item = I>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 3 previous errors diff --git a/src/test/ui/existential_types/nested_existential_types.rs b/src/test/ui/type-alias-impl-trait/nested_type_alias_impl_trait.rs index de52e88bae2..82c9ecd2ac6 100644 --- a/src/test/ui/existential_types/nested_existential_types.rs +++ b/src/test/ui/type-alias-impl-trait/nested_type_alias_impl_trait.rs @@ -1,10 +1,10 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] // build-pass (FIXME(62277): could be check-pass?) mod my_mod { use std::fmt::Debug; - pub existential type Foo: Debug; - pub existential type Foot: Debug; + pub type Foo = impl Debug; + pub type Foot = impl Debug; pub fn get_foo() -> Foo { 5i32 diff --git a/src/test/ui/existential_types/never_reveal_concrete_type.rs b/src/test/ui/type-alias-impl-trait/never_reveal_concrete_type.rs index 04da394848e..8787c023eb0 100644 --- a/src/test/ui/existential_types/never_reveal_concrete_type.rs +++ b/src/test/ui/type-alias-impl-trait/never_reveal_concrete_type.rs @@ -1,9 +1,9 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} // don't reveal the concrete type -existential type NoReveal: std::fmt::Debug; +type NoReveal = impl std::fmt::Debug; fn define_no_reveal() -> NoReveal { "" diff --git a/src/test/ui/existential_types/never_reveal_concrete_type.stderr b/src/test/ui/type-alias-impl-trait/never_reveal_concrete_type.stderr index 7c195f1fad0..7c195f1fad0 100644 --- a/src/test/ui/existential_types/never_reveal_concrete_type.stderr +++ b/src/test/ui/type-alias-impl-trait/never_reveal_concrete_type.stderr diff --git a/src/test/ui/existential_types/no_inferrable_concrete_type.rs b/src/test/ui/type-alias-impl-trait/no_inferrable_concrete_type.rs index eec8a4be63d..c9ca504f780 100644 --- a/src/test/ui/existential_types/no_inferrable_concrete_type.rs +++ b/src/test/ui/type-alias-impl-trait/no_inferrable_concrete_type.rs @@ -1,9 +1,9 @@ -// Issue 52985: user code provides no use case that allows an existential type +// Issue 52985: user code provides no use case that allows a type alias `impl Trait` // We now emit a 'could not find defining uses' error -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] -existential type Foo: Copy; //~ could not find defining uses +type Foo = impl Copy; //~ could not find defining uses // make compiler happy about using 'Foo' fn bar(x: Foo) -> Foo { x } diff --git a/src/test/ui/existential_types/no_inferrable_concrete_type.stderr b/src/test/ui/type-alias-impl-trait/no_inferrable_concrete_type.stderr index bc9a883c836..444e6e8214f 100644 --- a/src/test/ui/existential_types/no_inferrable_concrete_type.stderr +++ b/src/test/ui/type-alias-impl-trait/no_inferrable_concrete_type.stderr @@ -1,8 +1,8 @@ error: could not find defining uses --> $DIR/no_inferrable_concrete_type.rs:6:1 | -LL | existential type Foo: Copy; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | type Foo = impl Copy; + | ^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/existential_types/no_revealing_outside_defining_module.rs b/src/test/ui/type-alias-impl-trait/no_revealing_outside_defining_module.rs index 04793c67b56..61153b1e171 100644 --- a/src/test/ui/existential_types/no_revealing_outside_defining_module.rs +++ b/src/test/ui/type-alias-impl-trait/no_revealing_outside_defining_module.rs @@ -1,9 +1,9 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() {} mod boo { - pub existential type Boo: ::std::fmt::Debug; + pub type Boo = impl ::std::fmt::Debug; fn bomp() -> Boo { "" } diff --git a/src/test/ui/existential_types/no_revealing_outside_defining_module.stderr b/src/test/ui/type-alias-impl-trait/no_revealing_outside_defining_module.stderr index 5e5826978fc..5e5826978fc 100644 --- a/src/test/ui/existential_types/no_revealing_outside_defining_module.stderr +++ b/src/test/ui/type-alias-impl-trait/no_revealing_outside_defining_module.stderr diff --git a/src/test/ui/existential_types/not_a_defining_use.rs b/src/test/ui/type-alias-impl-trait/not_a_defining_use.rs index 3f81f5177d0..ca00e582d34 100644 --- a/src/test/ui/existential_types/not_a_defining_use.rs +++ b/src/test/ui/type-alias-impl-trait/not_a_defining_use.rs @@ -1,13 +1,13 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] use std::fmt::Debug; fn main() {} -existential type Two<T, U>: Debug; +type Two<T, U> = impl Debug; fn two<T: Debug>(t: T) -> Two<T, u32> { - //~^ ERROR defining existential type use does not fully define existential type + //~^ ERROR defining opaque type use does not fully define opaque type (t, 4i8) } diff --git a/src/test/ui/existential_types/not_a_defining_use.stderr b/src/test/ui/type-alias-impl-trait/not_a_defining_use.stderr index f315811cdb4..7bb8939ccf5 100644 --- a/src/test/ui/existential_types/not_a_defining_use.stderr +++ b/src/test/ui/type-alias-impl-trait/not_a_defining_use.stderr @@ -1,4 +1,4 @@ -error: defining existential type use does not fully define existential type +error: defining opaque type use does not fully define opaque type --> $DIR/not_a_defining_use.rs:9:1 | LL | / fn two<T: Debug>(t: T) -> Two<T, u32> { @@ -7,7 +7,7 @@ LL | | (t, 4i8) LL | | } | |_^ -error: concrete type differs from previous defining existential type use +error: concrete type differs from previous defining opaque type use --> $DIR/not_a_defining_use.rs:30:1 | LL | / fn four<T: Debug, U: Bar>(t: T) -> Two<T, U> { diff --git a/src/test/ui/existential_types/not_well_formed.rs b/src/test/ui/type-alias-impl-trait/not_well_formed.rs index 073fa90cb35..36ec9b34ebd 100644 --- a/src/test/ui/existential_types/not_well_formed.rs +++ b/src/test/ui/type-alias-impl-trait/not_well_formed.rs @@ -1,4 +1,4 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() { } @@ -7,7 +7,7 @@ trait TraitWithAssoc { type Assoc; } -existential type Foo<V>: Trait<V::Assoc>; //~ associated type `Assoc` not found for `V` +type Foo<V> = impl Trait<V::Assoc>; //~ associated type `Assoc` not found for `V` trait Trait<U> {} diff --git a/src/test/ui/existential_types/not_well_formed.stderr b/src/test/ui/type-alias-impl-trait/not_well_formed.stderr index 05f84d57623..d374d6d33ee 100644 --- a/src/test/ui/existential_types/not_well_formed.stderr +++ b/src/test/ui/type-alias-impl-trait/not_well_formed.stderr @@ -1,8 +1,8 @@ error[E0220]: associated type `Assoc` not found for `V` - --> $DIR/not_well_formed.rs:10:32 + --> $DIR/not_well_formed.rs:10:26 | -LL | existential type Foo<V>: Trait<V::Assoc>; - | ^^^^^^^^ associated type `Assoc` not found +LL | type Foo<V> = impl Trait<V::Assoc>; + | ^^^^^^^^ associated type `Assoc` not found error: aborting due to previous error diff --git a/src/test/ui/existential_types/private_unused.rs b/src/test/ui/type-alias-impl-trait/private_unused.rs index 92268f1861d..92268f1861d 100644 --- a/src/test/ui/existential_types/private_unused.rs +++ b/src/test/ui/type-alias-impl-trait/private_unused.rs diff --git a/src/test/ui/existential_types/existential_type_const.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-const.rs index 646e9a73424..0fd4d26ef60 100644 --- a/src/test/ui/existential_types/existential_type_const.rs +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-const.rs @@ -1,18 +1,18 @@ // check-pass -#![feature(existential_type)] -// Currently, the `existential_type` feature implicitly +#![feature(type_alias_impl_trait)] +// Currently, the `type_alias_impl_trait` feature implicitly // depends on `impl_trait_in_bindings` in order to work properly. // Specifically, this line requires `impl_trait_in_bindings` to be enabled: // https://github.com/rust-lang/rust/blob/481068a707679257e2a738b40987246e0420e787/src/librustc_typeck/check/mod.rs#L856 #![feature(impl_trait_in_bindings)] //~^ WARN the feature `impl_trait_in_bindings` is incomplete and may cause the compiler to crash -// Ensures that `const` items can constrain an `existential type`. +// Ensures that `const` items can constrain an opaque `impl Trait`. use std::fmt::Debug; -pub existential type Foo: Debug; +pub type Foo = impl Debug; const _FOO: Foo = 5; diff --git a/src/test/ui/existential_types/existential_type_const.stderr b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-const.stderr index 81754c8f706..691de82c9d8 100644 --- a/src/test/ui/existential_types/existential_type_const.stderr +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-const.stderr @@ -1,5 +1,5 @@ warning: the feature `impl_trait_in_bindings` is incomplete and may cause the compiler to crash - --> $DIR/existential_type_const.rs:8:12 + --> $DIR/type-alias-impl-trait-const.rs:8:12 | LL | #![feature(impl_trait_in_bindings)] | ^^^^^^^^^^^^^^^^^^^^^^ diff --git a/src/test/ui/existential_types/existential_type_fns.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-fns.rs index 6f22eef2849..a22b12cae6b 100644 --- a/src/test/ui/existential_types/existential_type_fns.rs +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-fns.rs @@ -1,6 +1,6 @@ // check-pass -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] // Regression test for issue #61863 @@ -22,6 +22,6 @@ pub fn bla2() -> TE { } -existential type TE: MyTrait; +type TE = impl MyTrait; fn main() {} diff --git a/src/test/ui/existential_types/existential_type_tuple.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs index 0f134a52897..86c9d482143 100644 --- a/src/test/ui/existential_types/existential_type_tuple.rs +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs @@ -1,6 +1,6 @@ // check-pass -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] #![allow(dead_code)] pub trait MyTrait {} @@ -28,6 +28,6 @@ fn make_foo() -> Foo { true } -existential type Foo: MyTrait; +type Foo = impl MyTrait; fn main() {} diff --git a/src/test/ui/existential_types/existential-types-with-cycle-error.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.rs index 38fcabb5cc1..c009952eab7 100644 --- a/src/test/ui/existential_types/existential-types-with-cycle-error.rs +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.rs @@ -1,6 +1,6 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] -existential type Foo: Fn() -> Foo; +type Foo = impl Fn() -> Foo; //~^ ERROR: could not find defining uses fn crash(x: Foo) -> Foo { diff --git a/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr new file mode 100644 index 00000000000..02ab3399ea6 --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr @@ -0,0 +1,8 @@ +error: could not find defining uses + --> $DIR/type-alias-impl-trait-with-cycle-error.rs:3:1 + | +LL | type Foo = impl Fn() -> Foo; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/existential_types/existential-types-with-cycle-error2.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.rs index f9e6bdb67d4..32ecc366618 100644 --- a/src/test/ui/existential_types/existential-types-with-cycle-error2.rs +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.rs @@ -1,10 +1,10 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] pub trait Bar<T> { type Item; } -existential type Foo: Bar<Foo, Item = Foo>; +type Foo = impl Bar<Foo, Item = Foo>; //~^ ERROR: could not find defining uses fn crash(x: Foo) -> Foo { diff --git a/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr new file mode 100644 index 00000000000..e9abb795886 --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr @@ -0,0 +1,8 @@ +error: could not find defining uses + --> $DIR/type-alias-impl-trait-with-cycle-error2.rs:7:1 + | +LL | type Foo = impl Bar<Foo, Item = Foo>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/existential_types/existential-types-with-no-traits.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-no-traits.rs index 46339c73b1f..8ca279eec92 100644 --- a/src/test/ui/existential_types/existential-types-with-no-traits.rs +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-no-traits.rs @@ -1,6 +1,6 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] -existential type Foo: 'static; +type Foo = impl 'static; //~^ ERROR: at least one trait must be specified fn foo() -> Foo { diff --git a/src/test/ui/existential_types/existential-types-with-no-traits.stderr b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-no-traits.stderr index 4b2fbc79d3b..58028bd0861 100644 --- a/src/test/ui/existential_types/existential-types-with-no-traits.stderr +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-no-traits.stderr @@ -1,11 +1,11 @@ error: at least one trait must be specified - --> $DIR/existential-types-with-no-traits.rs:3:23 + --> $DIR/type-alias-impl-trait-with-no-traits.rs:3:17 | -LL | existential type Foo: 'static; - | ^^^^^^^ +LL | type Foo = impl 'static; + | ^^^^^^^ error: at least one trait must be specified - --> $DIR/existential-types-with-no-traits.rs:10:13 + --> $DIR/type-alias-impl-trait-with-no-traits.rs:10:13 | LL | fn bar() -> impl 'static { | ^^^^^^^^^^^^ diff --git a/src/test/ui/existential_types/existential_type-pass.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait.rs index c2cf0eeed3d..209134acf01 100644 --- a/src/test/ui/existential_types/existential_type-pass.rs +++ b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait.rs @@ -3,7 +3,7 @@ #![allow(dead_code)] #![allow(unused_assignments)] #![allow(unused_variables)] -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() { assert_eq!(foo().to_string(), "foo"); @@ -16,14 +16,14 @@ fn main() { } // single definition -existential type Foo: std::fmt::Display; +type Foo = impl std::fmt::Display; fn foo() -> Foo { "foo" } // two definitions -existential type Bar: std::fmt::Display; +type Bar = impl std::fmt::Display; fn bar1() -> Bar { "bar1" @@ -34,7 +34,7 @@ fn bar2() -> Bar { } // definition in submodule -existential type Boo: std::fmt::Display; +type Boo = impl std::fmt::Display; mod boo { pub fn boo() -> super::Boo { @@ -42,7 +42,7 @@ mod boo { } } -existential type MyIter<T>: Iterator<Item = T>; +type MyIter<T> = impl Iterator<Item = T>; fn my_iter<T>(t: T) -> MyIter<T> { std::iter::once(t) @@ -63,21 +63,21 @@ fn my_iter4<U, V>(_: U, v: V) -> MyIter<V> { } // param names should not have an effect! -existential type MyOtherIter<T>: Iterator<Item = T>; +type MyOtherIter<T> = impl Iterator<Item = T>; fn my_other_iter<U>(u: U) -> MyOtherIter<U> { std::iter::once(u) } trait Trait {} -existential type GenericBound<'a, T: Trait>: Sized + 'a; +type GenericBound<'a, T: Trait> = impl Sized + 'a; fn generic_bound<'a, T: Trait + 'a>(t: T) -> GenericBound<'a, T> { t } mod pass_through { - pub existential type Passthrough<T>: Sized + 'static; + pub type Passthrough<T> = impl Sized + 'static; fn define_passthrough<T: 'static>(t: T) -> Passthrough<T> { t diff --git a/src/test/ui/existential_types/unused_generic_param.rs b/src/test/ui/type-alias-impl-trait/unused_generic_param.rs index 5455b39f4cb..a9ab727b193 100644 --- a/src/test/ui/existential_types/unused_generic_param.rs +++ b/src/test/ui/type-alias-impl-trait/unused_generic_param.rs @@ -1,16 +1,16 @@ -#![feature(existential_type)] +#![feature(type_alias_impl_trait)] fn main() { } -existential type PartiallyDefined<T>: 'static; +type PartiallyDefined<T> = impl 'static; //~^ ERROR: at least one trait must be specified fn partially_defined<T: std::fmt::Debug>(_: T) -> PartiallyDefined<T> { 4u32 } -existential type PartiallyDefined2<T>: 'static; +type PartiallyDefined2<T> = impl 'static; //~^ ERROR: at least one trait must be specified fn partially_defined2<T: std::fmt::Debug>(_: T) -> PartiallyDefined2<T> { diff --git a/src/test/ui/type-alias-impl-trait/unused_generic_param.stderr b/src/test/ui/type-alias-impl-trait/unused_generic_param.stderr new file mode 100644 index 00000000000..23105026964 --- /dev/null +++ b/src/test/ui/type-alias-impl-trait/unused_generic_param.stderr @@ -0,0 +1,14 @@ +error: at least one trait must be specified + --> $DIR/unused_generic_param.rs:6:33 + | +LL | type PartiallyDefined<T> = impl 'static; + | ^^^^^^^ + +error: at least one trait must be specified + --> $DIR/unused_generic_param.rs:13:34 + | +LL | type PartiallyDefined2<T> = impl 'static; + | ^^^^^^^ + +error: aborting due to 2 previous errors + |