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

Rollup merge of #66197 - Centril:transparent-ast, r=varkor

Browse source 
Push `ast::{ItemKind, ImplItemKind}::OpaqueTy` hack down into lowering

We currently have a hack in the form of `ast::{ItemKind, ImplItemKind}::OpaqueTy` which is constructed literally when you write `type Alias = impl Trait;` but not e.g. `type Alias = Vec<impl Trait>;`. Per https://github.com/rust-lang/rfcs/pull/2515, this needs to change to allow `impl Trait` in nested positions.  This PR achieves this change for the syntactic aspect but not the semantic one, which will require changes in lowering and def collection. In the interim, `TyKind::opaque_top_hack` is introduced to avoid knock-on changes in lowering, collection, and resolve. These hacks can then be removed and fixed one by one until the desired semantics are supported.

r? @varkor
This commit is contained in:
Tyler Mandry 2019-11-15 14:44:47 +01:00 • committed by GitHub
commit c5bb2ec0dd
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
27 changed files with 314 additions and 263 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/librustc/hir/lowering.rs
View file

@ -454,7 +454,6 @@ impl<'a> LoweringContext<'a> {
| ItemKind::Union(_, ref generics)
| ItemKind::Enum(_, ref generics)
| ItemKind::TyAlias(_, 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

62
src/librustc/hir/lowering/item.rs
View file

@ -337,20 +337,22 @@ impl LoweringContext<'_> {
ItemKind::Mod(ref m) => hir::ItemKind::Mod(self.lower_mod(m)),
ItemKind::ForeignMod(ref nm) => hir::ItemKind::ForeignMod(self.lower_foreign_mod(nm)),
ItemKind::GlobalAsm(ref ga) => hir::ItemKind::GlobalAsm(self.lower_global_asm(ga)),
ItemKind::TyAlias(ref t, ref generics) => hir::ItemKind::TyAlias(
self.lower_ty(t, ImplTraitContext::disallowed()),
self.lower_generics(generics, ImplTraitContext::disallowed()),
),
ItemKind::OpaqueTy(ref b, ref generics) => hir::ItemKind::OpaqueTy(
hir::OpaqueTy {
generics: self.lower_generics(generics,
ImplTraitContext::OpaqueTy(None)),
bounds: self.lower_param_bounds(b,
ImplTraitContext::OpaqueTy(None)),
impl_trait_fn: None,
origin: hir::OpaqueTyOrigin::TypeAlias,
ItemKind::TyAlias(ref ty, ref generics) => match ty.kind.opaque_top_hack() {
None => {
let ty = self.lower_ty(ty, ImplTraitContext::disallowed());
let generics = self.lower_generics(generics, ImplTraitContext::disallowed());
hir::ItemKind::TyAlias(ty, generics)
},
),
Some(bounds) => {
let ty = hir::OpaqueTy {
generics: self.lower_generics(generics, ImplTraitContext::OpaqueTy(None)),
bounds: self.lower_param_bounds(bounds, ImplTraitContext::OpaqueTy(None)),
impl_trait_fn: None,
origin: hir::OpaqueTyOrigin::TypeAlias,
};
hir::ItemKind::OpaqueTy(ty)
}
}
ItemKind::Enum(ref enum_definition, ref generics) => {
hir::ItemKind::Enum(
hir::EnumDef {
@ -916,16 +918,20 @@ impl LoweringContext<'_> {
(generics, hir::ImplItemKind::Method(sig, body_id))
}
ImplItemKind::TyAlias(ref ty) => (
self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
hir::ImplItemKind::TyAlias(self.lower_ty(ty, ImplTraitContext::disallowed())),
),
ImplItemKind::OpaqueTy(ref bounds) => (
self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
hir::ImplItemKind::OpaqueTy(
self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
),
),
ImplItemKind::TyAlias(ref ty) => {
let generics = self.lower_generics(&i.generics, ImplTraitContext::disallowed());
let kind = match ty.kind.opaque_top_hack() {
None => {
let ty = self.lower_ty(ty, ImplTraitContext::disallowed());
hir::ImplItemKind::TyAlias(ty)
}
Some(bs) => {
let bounds = self.lower_param_bounds(bs, ImplTraitContext::disallowed());
hir::ImplItemKind::OpaqueTy(bounds)
}
};
(generics, kind)
},
ImplItemKind::Macro(..) => bug!("`TyMac` should have been expanded by now"),
};
@ -950,11 +956,13 @@ impl LoweringContext<'_> {
span: i.span,
vis: self.lower_visibility(&i.vis, Some(i.id)),
defaultness: self.lower_defaultness(i.defaultness, true /* [1] */),
kind: match i.kind {
kind: match &i.kind {
ImplItemKind::Const(..) => hir::AssocItemKind::Const,
ImplItemKind::TyAlias(..) => hir::AssocItemKind::Type,
ImplItemKind::OpaqueTy(..) => hir::AssocItemKind::OpaqueTy,
ImplItemKind::Method(ref sig, _) => hir::AssocItemKind::Method {
ImplItemKind::TyAlias(ty) => match ty.kind.opaque_top_hack() {
None => hir::AssocItemKind::Type,
Some(_) => hir::AssocItemKind::OpaqueTy,
},
ImplItemKind::Method(sig, _) => hir::AssocItemKind::Method {
has_self: sig.decl.has_self(),
},
ImplItemKind::Macro(..) => unimplemented!(),

5
src/librustc/hir/map/def_collector.rs
View file

@ -107,7 +107,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
}
ItemKind::Mod(..) | ItemKind::Trait(..) | ItemKind::TraitAlias(..) |
ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) |
ItemKind::OpaqueTy(..) | ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) |
ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) |
ItemKind::TyAlias(..) => DefPathData::TypeNs(i.ident.name),
ItemKind::Fn(sig, generics, body) if sig.header.asyncness.node.is_async() => {
return self.visit_async_fn(
@ -239,8 +239,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
}
ImplItemKind::Method(..) |
ImplItemKind::Const(..) => DefPathData::ValueNs(ii.ident.name),
ImplItemKind::TyAlias(..) |
ImplItemKind::OpaqueTy(..) => DefPathData::TypeNs(ii.ident.name),
ImplItemKind::TyAlias(..) => DefPathData::TypeNs(ii.ident.name),
ImplItemKind::Macro(..) => return self.visit_macro_invoc(ii.id),
};

61
src/librustc_parse/parser/item.rs
View file

@ -7,7 +7,7 @@ use syntax::ast::{self, Abi, DUMMY_NODE_ID, Ident, Attribute, AttrKind, AttrStyl
use syntax::ast::{ItemKind, ImplItem, ImplItemKind, TraitItem, TraitItemKind, UseTree, UseTreeKind};
use syntax::ast::{PathSegment, IsAuto, Constness, IsAsync, Unsafety, Defaultness};
use syntax::ast::{Visibility, VisibilityKind, Mutability, FnHeader, ForeignItem, ForeignItemKind};
use syntax::ast::{Ty, TyKind, Generics, GenericBounds, TraitRef, EnumDef, VariantData, StructField};
use syntax::ast::{Ty, TyKind, Generics, TraitRef, EnumDef, VariantData, StructField};
use syntax::ast::{Mac, MacDelimiter, Block, BindingMode, FnDecl, FnSig, SelfKind, Param};
use syntax::ptr::P;
use syntax::ThinVec;
@ -24,15 +24,6 @@ use log::debug;
use std::mem;
use errors::{PResult, Applicability, DiagnosticBuilder, StashKey};
/// Whether the type alias or associated type is a concrete type or an opaque type.
#[derive(Debug)]
pub(super) 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.
OpaqueTy(GenericBounds),
}
pub(super) type ItemInfo = (Ident, ItemKind, Option<Vec<Attribute>>);
impl<'a> Parser<'a> {
@ -269,15 +260,11 @@ impl<'a> Parser<'a> {
return self.mk_item_with_info(attrs, lo, vis, info);
}
if let Some(type_) = self.eat_type() {
let (ident, alias, generics) = type_?;
if self.eat_keyword(kw::Type) {
// TYPE ITEM
let item_ = match alias {
AliasKind::Weak(ty) => ItemKind::TyAlias(ty, generics),
AliasKind::OpaqueTy(bounds) => ItemKind::OpaqueTy(bounds, generics),
};
let span = lo.to(self.prev_span);
return Ok(Some(self.mk_item(span, ident, item_, vis, attrs)));
let (ident, ty, generics) = self.parse_type_alias()?;
let kind = ItemKind::TyAlias(ty, generics);
return self.mk_item_with_info(attrs, lo, vis, (ident, kind, None));
}
if self.eat_keyword(kw::Enum) {
@ -711,13 +698,9 @@ impl<'a> Parser<'a> {
let lo = self.token.span;
let vis = self.parse_visibility(false)?;
let defaultness = self.parse_defaultness();
let (name, kind, generics) = if let Some(type_) = self.eat_type() {
let (name, alias, generics) = type_?;
let kind = match alias {
AliasKind::Weak(typ) => ast::ImplItemKind::TyAlias(typ),
AliasKind::OpaqueTy(bounds) => ast::ImplItemKind::OpaqueTy(bounds),
};
(name, kind, generics)
let (name, kind, generics) = if self.eat_keyword(kw::Type) {
let (name, ty, generics) = self.parse_type_alias()?;
(name, ast::ImplItemKind::TyAlias(ty), generics)
} else if self.is_const_item() {
self.parse_impl_const()?
} else if let Some(mac) = self.parse_assoc_macro_invoc("impl", Some(&vis), at_end)? {
@ -1322,34 +1305,16 @@ impl<'a> Parser<'a> {
})
}
/// Parses `type Foo = Bar;` or returns `None`
/// without modifying the parser state.
fn eat_type(&mut self) -> Option<PResult<'a, (Ident, AliasKind, Generics)>> {
// This parses the grammar:
// Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";"
if self.eat_keyword(kw::Type) {
Some(self.parse_type_alias())
} else {
None
}
}
/// Parses a type alias or opaque type.
fn parse_type_alias(&mut self) -> PResult<'a, (Ident, AliasKind, Generics)> {
/// Parses the grammar:
/// Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";"
fn parse_type_alias(&mut self) -> PResult<'a, (Ident, P<Ty>, Generics)> {
let ident = self.parse_ident()?;
let mut tps = self.parse_generics()?;
tps.where_clause = self.parse_where_clause()?;
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::OpaqueTy(bounds)
} else {
let ty = self.parse_ty()?;
AliasKind::Weak(ty)
};
let ty = self.parse_ty()?;
self.expect_semi()?;
Ok((ident, alias, tps))
Ok((ident, ty, tps))
}
/// Parses an enum declaration.

10
src/librustc_passes/ast_validation.rs
View file

@ -20,7 +20,7 @@ use syntax::source_map::Spanned;
use syntax::symbol::{kw, sym};
use syntax::visit::{self, Visitor};
use syntax::{span_err, struct_span_err, walk_list};
use syntax_pos::{Span, MultiSpan};
use syntax_pos::Span;
use errors::{Applicability, FatalError};
use rustc_error_codes::*;
@ -586,14 +586,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
"unions cannot have zero fields");
}
}
ItemKind::OpaqueTy(ref bounds, _) => {
if !bounds.iter()
.any(|b| if let GenericBound::Trait(..) = *b { true } else { false }) {
let msp = MultiSpan::from_spans(bounds.iter()
.map(|bound| bound.span()).collect());
self.err_handler().span_err(msp, "at least one trait must be specified");
}
}
_ => {}
}

13
src/librustc_resolve/build_reduced_graph.rs
View file

@ -701,13 +701,12 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
}
// These items live in the type namespace.
ItemKind::TyAlias(..) => {
let res = Res::Def(DefKind::TyAlias, self.r.definitions.local_def_id(item.id));
self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
}
ItemKind::OpaqueTy(_, _) => {
let res = Res::Def(DefKind::OpaqueTy, self.r.definitions.local_def_id(item.id));
ItemKind::TyAlias(ref ty, _) => {
let def_kind = match ty.kind.opaque_top_hack() {
None => DefKind::TyAlias,
Some(_) => DefKind::OpaqueTy,
};
let res = Res::Def(def_kind, self.r.definitions.local_def_id(item.id));
self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
}

13
src/librustc_resolve/late.rs
View file

@ -732,7 +732,6 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
match item.kind {
ItemKind::TyAlias(_, ref generics) |
ItemKind::OpaqueTy(_, ref generics) |
ItemKind::Fn(_, ref generics, _) => {
self.with_generic_param_rib(generics, ItemRibKind(HasGenericParams::Yes),
|this| visit::walk_item(this, item));
@ -1087,18 +1086,6 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
this.visit_ty(ty);
}
ImplItemKind::OpaqueTy(ref bounds) => {
// If this is a trait impl, ensure the type
// exists in trait
this.check_trait_item(impl_item.ident,
TypeNS,
impl_item.span,
|n, s| TypeNotMemberOfTrait(n, s));
for bound in bounds {
this.visit_param_bound(bound);
}
}
ImplItemKind::Macro(_) =>
panic!("unexpanded macro in resolve!"),
}

38
src/librustc_save_analysis/dump_visitor.rs
View file

@ -1133,12 +1133,6 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
// trait.
self.visit_ty(ty)
}
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.
self.process_bounds(&bounds);
}
ast::ImplItemKind::Macro(_) => {}
}
}
@ -1384,38 +1378,6 @@ impl<'l, 'tcx> Visitor<'l> for DumpVisitor<'l, 'tcx> {
self.visit_ty(&ty);
self.process_generic_params(ty_params, &qualname, item.id);
}
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)));
let value = String::new();
if !self.span.filter_generated(item.ident.span) {
let span = self.span_from_span(item.ident.span);
let id = id_from_node_id(item.id, &self.save_ctxt);
let hir_id = self.tcx.hir().node_to_hir_id(item.id);
self.dumper.dump_def(
&access_from!(self.save_ctxt, item, hir_id),
Def {
kind: DefKind::Type,
id,
span,
name: item.ident.to_string(),
qualname: qualname.clone(),
value,
parent: None,
children: vec![],
decl_id: None,
docs: self.save_ctxt.docs_for_attrs(&item.attrs),
sig: sig::item_signature(item, &self.save_ctxt),
attributes: lower_attributes(item.attrs.clone(), &self.save_ctxt),
},
);
}
self.process_bounds(bounds);
self.process_generic_params(ty_params, &qualname, item.id);
}
Mac(_) => (),
_ => visit::walk_item(self, item),
}

10
src/librustc_save_analysis/sig.rs
View file

@ -447,16 +447,6 @@ 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)?;

15
src/libsyntax/ast.rs
View file

@ -1579,7 +1579,6 @@ pub enum ImplItemKind {
Const(P<Ty>, P<Expr>),
Method(FnSig, P<Block>),
TyAlias(P<Ty>),
OpaqueTy(GenericBounds),
Macro(Mac),
}
@ -1816,6 +1815,15 @@ impl TyKind {
false
}
}
/// HACK(type_alias_impl_trait, Centril): A temporary crutch used
/// in lowering to avoid making larger changes there and beyond.
pub fn opaque_top_hack(&self) -> Option<&GenericBounds> {
match self {
Self::ImplTrait(_, bounds) => Some(bounds),
_ => None,
}
}
}
/// Syntax used to declare a trait object.
@ -2483,10 +2491,6 @@ pub enum ItemKind {
///
/// E.g., `type Foo = Bar<u8>;`.
TyAlias(P<Ty>, Generics),
/// An opaque `impl Trait` type alias.
///
/// E.g., `type Foo = impl Bar + Boo;`.
OpaqueTy(GenericBounds, Generics),
/// An enum definition (`enum`).
///
/// E.g., `enum Foo<A, B> { C<A>, D<B> }`.
@ -2540,7 +2544,6 @@ impl ItemKind {
ItemKind::ForeignMod(..) => "foreign module",
ItemKind::GlobalAsm(..) => "global asm",
ItemKind::TyAlias(..) => "type alias",
ItemKind::OpaqueTy(..) => "opaque type",
ItemKind::Enum(..) => "enum",
ItemKind::Struct(..) => "struct",
ItemKind::Union(..) => "union",

46
src/libsyntax/feature_gate/check.rs
View file

@ -321,6 +321,27 @@ impl<'a> PostExpansionVisitor<'a> {
);
}
}
/// Feature gate `impl Trait` inside `type Alias = $type_expr;`.
fn check_impl_trait(&self, ty: &ast::Ty) {
struct ImplTraitVisitor<'a> {
vis: &'a PostExpansionVisitor<'a>,
}
impl Visitor<'_> for ImplTraitVisitor<'_> {
fn visit_ty(&mut self, ty: &ast::Ty) {
if let ast::TyKind::ImplTrait(..) = ty.kind {
gate_feature_post!(
&self.vis,
type_alias_impl_trait,
ty.span,
"`impl Trait` in type aliases is unstable"
);
}
visit::walk_ty(self, ty);
}
}
ImplTraitVisitor { vis: self }.visit_ty(ty);
}
}
impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
@ -455,14 +476,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
gate_feature_post!(&self, decl_macro, i.span, msg);
}
ast::ItemKind::OpaqueTy(..) => {
gate_feature_post!(
&self,
type_alias_impl_trait,
i.span,
"`impl Trait` in type aliases is unstable"
);
}
ast::ItemKind::TyAlias(ref ty, ..) => self.check_impl_trait(&ty),
_ => {}
}
@ -636,9 +650,8 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
}
}
ast::TraitItemKind::Type(_, ref default) => {
// We use three if statements instead of something like match guards so that all
// of these errors can be emitted if all cases apply.
if default.is_some() {
if let Some(ty) = default {
self.check_impl_trait(ty);
gate_feature_post!(&self, associated_type_defaults, ti.span,
"associated type defaults are unstable");
}
@ -663,15 +676,8 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
"C-variadic functions are unstable");
}
}
ast::ImplItemKind::OpaqueTy(..) => {
gate_feature_post!(
&self,
type_alias_impl_trait,
ii.span,
"`impl Trait` in type aliases is unstable"
);
}
ast::ImplItemKind::TyAlias(_) => {
ast::ImplItemKind::TyAlias(ref ty) => {
self.check_impl_trait(ty);
self.check_gat(&ii.generics, ii.span);
}
_ => {}

5
src/libsyntax/mut_visit.rs
View file

@ -887,10 +887,6 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) {
vis.visit_ty(ty);
vis.visit_generics(generics);
}
ItemKind::OpaqueTy(bounds, generics) => {
visit_bounds(bounds, vis);
vis.visit_generics(generics);
}
ItemKind::Enum(EnumDef { variants }, generics) => {
variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
vis.visit_generics(generics);
@ -970,7 +966,6 @@ pub fn noop_flat_map_impl_item<T: MutVisitor>(mut item: ImplItem, visitor: &mut
visitor.visit_block(body);
}
ImplItemKind::TyAlias(ty) => visitor.visit_ty(ty),
ImplItemKind::OpaqueTy(bounds) => visit_bounds(bounds, visitor),
ImplItemKind::Macro(mac) => visitor.visit_mac(mac),
}
visitor.visit_span(span);

20
src/libsyntax/print/pprust.rs
View file

@ -1255,19 +1255,6 @@ impl<'a> State<'a> {
self.s.word(";");
self.end(); // end the outer ibox
}
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
self.print_where_clause(&generics.where_clause);
self.s.space();
self.print_type_bounds(":", bounds);
self.s.word(";");
self.end(); // end the outer ibox
}
ast::ItemKind::Enum(ref enum_definition, ref params) => {
self.print_enum_def(
enum_definition,
@ -1620,13 +1607,6 @@ impl<'a> State<'a> {
ast::ImplItemKind::TyAlias(ref ty) => {
self.print_associated_type(ii.ident, None, Some(ty));
}
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);
match mac.delim {

7
src/libsyntax/visit.rs
View file

@ -263,10 +263,6 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) {
visitor.visit_ty(typ);
visitor.visit_generics(generics)
}
ItemKind::OpaqueTy(ref bounds, ref generics) => {
walk_list!(visitor, visit_param_bound, bounds);
visitor.visit_generics(generics)
}
ItemKind::Enum(ref enum_definition, ref generics) => {
visitor.visit_generics(generics);
visitor.visit_enum_def(enum_definition, generics, item.id, item.span)
@ -628,9 +624,6 @@ pub fn walk_impl_item<'a, V: Visitor<'a>>(visitor: &mut V, impl_item: &'a ImplIt
ImplItemKind::TyAlias(ref ty) => {
visitor.visit_ty(ty);
}
ImplItemKind::OpaqueTy(ref bounds) => {
walk_list!(visitor, visit_param_bound, bounds);
}
ImplItemKind::Macro(ref mac) => {
visitor.visit_mac(mac);
}

36
src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.rs
View file

@ -1,15 +1,45 @@
type Foo = impl std::fmt::Debug; //~ ERROR `impl Trait` in type aliases is unstable
use std::fmt::Debug;
type Foo = impl Debug; //~ ERROR `impl Trait` in type aliases is unstable
trait Bar {
type Baa: std::fmt::Debug;
type Baa: Debug;
fn define() -> Self::Baa;
}
impl Bar for () {
type Baa = impl std::fmt::Debug; //~ ERROR `impl Trait` in type aliases is unstable
type Baa = impl Debug; //~ ERROR `impl Trait` in type aliases is unstable
fn define() -> Self::Baa { 0 }
}
fn define() -> Foo { 0 }
trait TraitWithDefault {
type Assoc = impl Debug;
//~^ ERROR associated type defaults are unstable
//~| ERROR `impl Trait` not allowed outside of function
//~| ERROR `impl Trait` in type aliases is unstable
}
type NestedFree = (Vec<impl Debug>, impl Debug, impl Iterator<Item = impl Debug>);
//~^ ERROR `impl Trait` in type aliases is unstable
//~| ERROR `impl Trait` in type aliases is unstable
//~| ERROR `impl Trait` in type aliases is unstable
//~| ERROR `impl Trait` in type aliases is unstable
//~| ERROR `impl Trait` not allowed outside of function
//~| ERROR `impl Trait` not allowed outside of function
//~| ERROR `impl Trait` not allowed outside of function
impl Bar for u8 {
type Baa = (Vec<impl Debug>, impl Debug, impl Iterator<Item = impl Debug>);
//~^ ERROR `impl Trait` in type aliases is unstable
//~| ERROR `impl Trait` in type aliases is unstable
//~| ERROR `impl Trait` in type aliases is unstable
//~| ERROR `impl Trait` in type aliases is unstable
//~| ERROR `impl Trait` not allowed outside of function
//~| ERROR `impl Trait` not allowed outside of function
//~| ERROR `impl Trait` not allowed outside of function
fn define() -> Self::Baa { (vec![true], 0u8, 0i32..1) }
}
fn main() {}

149
src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.stderr
View file

@ -1,21 +1,154 @@
error[E0658]: `impl Trait` in type aliases is unstable
--> $DIR/feature-gate-type_alias_impl_trait.rs:1:1
--> $DIR/feature-gate-type_alias_impl_trait.rs:3:12
|
LL | type Foo = impl std::fmt::Debug;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | type Foo = 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/feature-gate-type_alias_impl_trait.rs:9:5
--> $DIR/feature-gate-type_alias_impl_trait.rs:11:16
|
LL | type Baa = impl std::fmt::Debug;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | type Baa = 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: aborting due to 2 previous errors
error[E0658]: `impl Trait` in type aliases is unstable
--> $DIR/feature-gate-type_alias_impl_trait.rs:18:18
|
LL | type Assoc = 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
For more information about this error, try `rustc --explain E0658`.
error[E0658]: associated type defaults are unstable
--> $DIR/feature-gate-type_alias_impl_trait.rs:18:5
|
LL | type Assoc = impl Debug;
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: for more information, see https://github.com/rust-lang/rust/issues/29661
= help: add `#![feature(associated_type_defaults)]` to the crate attributes to enable
error[E0658]: `impl Trait` in type aliases is unstable
--> $DIR/feature-gate-type_alias_impl_trait.rs:24:24
|
LL | type NestedFree = (Vec<impl Debug>, impl Debug, impl Iterator<Item = 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/feature-gate-type_alias_impl_trait.rs:24:37
|
LL | type NestedFree = (Vec<impl Debug>, impl Debug, impl Iterator<Item = 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/feature-gate-type_alias_impl_trait.rs:24:49
|
LL | type NestedFree = (Vec<impl Debug>, impl Debug, impl Iterator<Item = 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/feature-gate-type_alias_impl_trait.rs:24:70
|
LL | type NestedFree = (Vec<impl Debug>, impl Debug, impl Iterator<Item = 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/feature-gate-type_alias_impl_trait.rs:34:21
|
LL | type Baa = (Vec<impl Debug>, impl Debug, impl Iterator<Item = 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/feature-gate-type_alias_impl_trait.rs:34:34
|
LL | type Baa = (Vec<impl Debug>, impl Debug, impl Iterator<Item = 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/feature-gate-type_alias_impl_trait.rs:34:46
|
LL | type Baa = (Vec<impl Debug>, impl Debug, impl Iterator<Item = 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/feature-gate-type_alias_impl_trait.rs:34:67
|
LL | type Baa = (Vec<impl Debug>, impl Debug, impl Iterator<Item = 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/feature-gate-type_alias_impl_trait.rs:18:18
|
LL | type Assoc = impl Debug;
| ^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/feature-gate-type_alias_impl_trait.rs:24:24
|
LL | type NestedFree = (Vec<impl Debug>, impl Debug, impl Iterator<Item = impl Debug>);
| ^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/feature-gate-type_alias_impl_trait.rs:24:37
|
LL | type NestedFree = (Vec<impl Debug>, impl Debug, impl Iterator<Item = impl Debug>);
| ^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/feature-gate-type_alias_impl_trait.rs:24:49
|
LL | type NestedFree = (Vec<impl Debug>, impl Debug, impl Iterator<Item = impl Debug>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/feature-gate-type_alias_impl_trait.rs:34:21
|
LL | type Baa = (Vec<impl Debug>, impl Debug, impl Iterator<Item = impl Debug>);
| ^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/feature-gate-type_alias_impl_trait.rs:34:34
|
LL | type Baa = (Vec<impl Debug>, impl Debug, impl Iterator<Item = impl Debug>);
| ^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/feature-gate-type_alias_impl_trait.rs:34:46
|
LL | type Baa = (Vec<impl Debug>, impl Debug, impl Iterator<Item = impl Debug>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 19 previous errors
Some errors have detailed explanations: E0562, E0658.
For more information about an error, try `rustc --explain E0562`.

1
src/test/ui/impl-trait/where-allowed.rs
View file

@ -163,6 +163,7 @@ type InTypeAlias<R> = impl Debug;
type InReturnInTypeAlias<R> = fn() -> impl Debug;
//~^ ERROR `impl Trait` not allowed outside of function and inherent method return types
//~| ERROR `impl Trait` in type aliases is unstable
// Disallowed in impl headers
impl PartialEq<impl Debug> for () {

41
src/test/ui/impl-trait/where-allowed.stderr
View file

@ -17,19 +17,28 @@ LL | fn in_impl_Fn_parameter_in_return() -> &'static impl Fn(impl Debug) { panic
| outer `impl Trait`
error[E0658]: `impl Trait` in type aliases is unstable
--> $DIR/where-allowed.rs:124:5
--> $DIR/where-allowed.rs:124:16
|
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:160:1
--> $DIR/where-allowed.rs:160:23
|
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[E0658]: `impl Trait` in type aliases is unstable
--> $DIR/where-allowed.rs:164:39
|
LL | type InReturnInTypeAlias<R> = fn() -> 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
@ -179,61 +188,61 @@ 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:168:16
--> $DIR/where-allowed.rs:169: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:173:24
--> $DIR/where-allowed.rs:174: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:178:6
--> $DIR/where-allowed.rs:179:6
|
LL | impl impl Debug {
| ^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/where-allowed.rs:184:24
--> $DIR/where-allowed.rs:185:24
|
LL | impl InInherentImplAdt<impl Debug> {
| ^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/where-allowed.rs:190:11
--> $DIR/where-allowed.rs:191:11
|
LL | where impl Debug: Debug
| ^^^^^^^^^^
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
--> $DIR/where-allowed.rs:197:15
--> $DIR/where-allowed.rs:198: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:204:24
--> $DIR/where-allowed.rs:205: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:211:17
--> $DIR/where-allowed.rs:212: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:218:22
--> $DIR/where-allowed.rs:219: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:224:29
--> $DIR/where-allowed.rs:225:29
|
LL | let _in_local_variable: impl Fn() = || {};
| ^^^^^^^^^
@ -241,7 +250,7 @@ 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:226:46
--> $DIR/where-allowed.rs:227:46
|
LL | let _in_return_in_local_variable = || -> impl Fn() { || {} };
| ^^^^^^^^^
@ -270,7 +279,7 @@ error: could not find defining uses
LL | type Out = impl Debug;
| ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 43 previous errors
error: aborting due to 44 previous errors
Some errors have detailed explanations: E0282, E0562, E0658, E0666.
For more information about an error, try `rustc --explain E0282`.

4
src/test/ui/type-alias-impl-trait/generic_nondefining_use.stderr
View file

@ -1,8 +1,8 @@
error: at least one trait must be specified
--> $DIR/generic_nondefining_use.rs:5:20
--> $DIR/generic_nondefining_use.rs:5:15
|
LL | type Cmp<T> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error: defining opaque type use does not fully define opaque type
--> $DIR/generic_nondefining_use.rs:11:1

4
src/test/ui/type-alias-impl-trait/generic_not_used.stderr
View file

@ -1,8 +1,8 @@
error: at least one trait must be specified
--> $DIR/generic_not_used.rs:5:38
--> $DIR/generic_not_used.rs:5:33
|
LL | type WrongGeneric<T: 'static> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
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

4
src/test/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.nll.stderr
View file

@ -1,8 +1,8 @@
error: at least one trait must be specified
--> $DIR/generic_type_does_not_live_long_enough.rs:9:29
--> $DIR/generic_type_does_not_live_long_enough.rs:9:24
|
LL | type WrongGeneric<T> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/generic_type_does_not_live_long_enough.rs:6:18

4
src/test/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.stderr
View file

@ -1,8 +1,8 @@
error: at least one trait must be specified
--> $DIR/generic_type_does_not_live_long_enough.rs:9:29
--> $DIR/generic_type_does_not_live_long_enough.rs:9:24
|
LL | type WrongGeneric<T> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/generic_type_does_not_live_long_enough.rs:6:18

4
src/test/ui/type-alias-impl-trait/generic_underconstrained.stderr
View file

@ -1,8 +1,8 @@
error: at least one trait must be specified
--> $DIR/generic_underconstrained.rs:6:40
--> $DIR/generic_underconstrained.rs:6:35
|
LL | type Underconstrained<T: Trait> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error[E0277]: the trait bound `T: Trait` is not satisfied
--> $DIR/generic_underconstrained.rs:6:1

8
src/test/ui/type-alias-impl-trait/generic_underconstrained2.stderr
View file

@ -1,14 +1,14 @@
error: at least one trait must be specified
--> $DIR/generic_underconstrained2.rs:5:50
--> $DIR/generic_underconstrained2.rs:5:45
|
LL | type Underconstrained<T: std::fmt::Debug> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error: at least one trait must be specified
--> $DIR/generic_underconstrained2.rs:14:51
--> $DIR/generic_underconstrained2.rs:14:46
|
LL | type Underconstrained2<T: std::fmt::Debug> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error[E0277]: `U` doesn't implement `std::fmt::Debug`
--> $DIR/generic_underconstrained2.rs:5:1

4
src/test/ui/type-alias-impl-trait/issue-60371.stderr
View file

@ -1,8 +1,8 @@
error[E0658]: `impl Trait` in type aliases is unstable
--> $DIR/issue-60371.rs:8:5
--> $DIR/issue-60371.rs:8:17
|
LL | type Item = impl Bug;
| ^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^
|
= 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

4
src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-no-traits.stderr
View file

@ -1,8 +1,8 @@
error: at least one trait must be specified
--> $DIR/type-alias-impl-trait-with-no-traits.rs:3:17
--> $DIR/type-alias-impl-trait-with-no-traits.rs:3:12
|
LL | type Foo = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error: at least one trait must be specified
--> $DIR/type-alias-impl-trait-with-no-traits.rs:10:13

8
src/test/ui/type-alias-impl-trait/unused_generic_param.stderr
View file

@ -1,14 +1,14 @@
error: at least one trait must be specified
--> $DIR/unused_generic_param.rs:6:33
--> $DIR/unused_generic_param.rs:6:28
|
LL | type PartiallyDefined<T> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error: at least one trait must be specified
--> $DIR/unused_generic_param.rs:13:34
--> $DIR/unused_generic_param.rs:13:29
|
LL | type PartiallyDefined2<T> = impl 'static;
| ^^^^^^^
| ^^^^^^^^^^^^
error: aborting due to 2 previous errors