diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 0a59e3c2e3f82..6c634fc84268d 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -142,13 +142,9 @@ struct LoweringContext<'a, 'hir: 'a> { /// indicate whether or not we're in a place where new lifetimes will result /// in in-band lifetime definitions, such a function or an impl header, /// including implicit lifetimes from `impl_header_lifetime_elision`. - is_collecting_in_band_lifetimes: bool, + is_collecting_anonymous_lifetimes: bool, /// Currently in-scope lifetimes defined in impl headers, fn headers, or HRTB. - /// When `is_collecting_in_band_lifetimes` is true, each lifetime is checked - /// against this list to see if it is already in-scope, or if a definition - /// needs to be created for it. - /// /// We always store a `normalize_to_macros_2_0()` version of the param-name in this /// vector. in_scope_lifetimes: Vec, @@ -377,7 +373,7 @@ pub fn lower_crate<'a, 'hir>( task_context: None, current_item: None, lifetimes_to_define: Vec::new(), - is_collecting_in_band_lifetimes: false, + is_collecting_anonymous_lifetimes: false, in_scope_lifetimes: Vec::new(), allow_try_trait: Some([sym::try_trait_v2][..].into()), allow_gen_future: Some([sym::gen_future][..].into()), @@ -724,13 +720,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { &mut self, f: impl FnOnce(&mut Self) -> T, ) -> (Vec<(Span, ParamName)>, T) { - let was_collecting = std::mem::replace(&mut self.is_collecting_in_band_lifetimes, true); + let was_collecting = std::mem::replace(&mut self.is_collecting_anonymous_lifetimes, true); let len = self.lifetimes_to_define.len(); let res = f(self); let lifetimes_to_define = self.lifetimes_to_define.split_off(len); - self.is_collecting_in_band_lifetimes = was_collecting; + self.is_collecting_anonymous_lifetimes = was_collecting; (lifetimes_to_define, res) } @@ -747,7 +743,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { // that collisions are ok here and this shouldn't // really show up for end-user. let (str_name, kind) = match hir_name { - ParamName::Plain(ident) => (ident.name, hir::LifetimeParamKind::InBand), + ParamName::Plain(ident) => (ident.name, hir::LifetimeParamKind::Explicit), ParamName::Fresh(_) => (kw::UnderscoreLifetime, hir::LifetimeParamKind::Elided), ParamName::Error => (kw::UnderscoreLifetime, hir::LifetimeParamKind::Error), }; @@ -771,38 +767,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } } - /// When there is a reference to some lifetime `'a`, and in-band - /// lifetimes are enabled, then we want to push that lifetime into - /// the vector of names to define later. In that case, it will get - /// added to the appropriate generics. - fn maybe_collect_in_band_lifetime(&mut self, ident: Ident) { - if !self.is_collecting_in_band_lifetimes { - return; - } - - if !self.sess.features_untracked().in_band_lifetimes { - return; - } - - if self.in_scope_lifetimes.contains(&ParamName::Plain(ident.normalize_to_macros_2_0())) { - return; - } - - let hir_name = ParamName::Plain(ident); - - if self.lifetimes_to_define.iter().any(|(_, lt_name)| { - lt_name.normalize_to_macros_2_0() == hir_name.normalize_to_macros_2_0() - }) { - return; - } - - self.lifetimes_to_define.push((ident.span, hir_name)); - } - /// When we have either an elided or `'_` lifetime in an impl /// header, we convert it to an in-band lifetime. - fn collect_fresh_in_band_lifetime(&mut self, span: Span) -> ParamName { - assert!(self.is_collecting_in_band_lifetimes); + fn collect_fresh_anonymous_lifetime(&mut self, span: Span) -> ParamName { + assert!(self.is_collecting_anonymous_lifetimes); let index = self.lifetimes_to_define.len() + self.in_scope_lifetimes.len(); let hir_name = ParamName::Fresh(index); self.lifetimes_to_define.push((span, hir_name)); @@ -1944,7 +1912,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } ident if ident.name == kw::UnderscoreLifetime => match self.anonymous_lifetime_mode { AnonymousLifetimeMode::CreateParameter => { - let fresh_name = self.collect_fresh_in_band_lifetime(span); + let fresh_name = self.collect_fresh_anonymous_lifetime(span); self.new_named_lifetime(l.id, span, hir::LifetimeName::Param(fresh_name)) } @@ -1955,7 +1923,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { AnonymousLifetimeMode::ReportError => self.new_error_lifetime(Some(l.id), span), }, ident => { - self.maybe_collect_in_band_lifetime(ident); let param_name = ParamName::Plain(self.lower_ident(ident)); self.new_named_lifetime(l.id, span, hir::LifetimeName::Param(param_name)) } @@ -1999,8 +1966,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let (name, kind) = match param.kind { GenericParamKind::Lifetime => { - let was_collecting_in_band = self.is_collecting_in_band_lifetimes; - self.is_collecting_in_band_lifetimes = false; + let was_collecting_in_band = self.is_collecting_anonymous_lifetimes; + self.is_collecting_anonymous_lifetimes = false; let lt = self .with_anonymous_lifetime_mode(AnonymousLifetimeMode::ReportError, |this| { @@ -2023,7 +1990,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let kind = hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit }; - self.is_collecting_in_band_lifetimes = was_collecting_in_band; + self.is_collecting_anonymous_lifetimes = was_collecting_in_band; (param_name, kind) } @@ -2382,7 +2349,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { // Hence `impl Foo for &u32` becomes `impl<'f> Foo for &'f u32` for some fresh // `'f`. AnonymousLifetimeMode::CreateParameter => { - let fresh_name = self.collect_fresh_in_band_lifetime(span); + let fresh_name = self.collect_fresh_anonymous_lifetime(span); hir::Lifetime { hir_id: self.next_id(), span: self.lower_span(span), diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs index 8d6c8c247851e..68b536da9f70f 100644 --- a/compiler/rustc_attr/src/builtin.rs +++ b/compiler/rustc_attr/src/builtin.rs @@ -8,6 +8,7 @@ use rustc_errors::{struct_span_err, Applicability}; use rustc_feature::{find_gated_cfg, is_builtin_attr_name, Features, GatedCfg}; use rustc_macros::HashStable_Generic; use rustc_session::lint::builtin::UNEXPECTED_CFGS; +use rustc_session::lint::BuiltinLintDiagnostics; use rustc_session::parse::{feature_err, ParseSess}; use rustc_session::Session; use rustc_span::hygiene::Transparency; @@ -461,29 +462,37 @@ pub fn cfg_matches(cfg: &ast::MetaItem, sess: &ParseSess, features: Option<&Feat true } MetaItemKind::NameValue(..) | MetaItemKind::Word => { - let name = cfg.ident().expect("multi-segment cfg predicate").name; + let ident = cfg.ident().expect("multi-segment cfg predicate"); + let name = ident.name; let value = cfg.value_str(); - if sess.check_config.names_checked && !sess.check_config.names_valid.contains(&name) - { - sess.buffer_lint( - UNEXPECTED_CFGS, - cfg.span, - CRATE_NODE_ID, - "unexpected `cfg` condition name", - ); - } - if let Some(val) = value { - if sess.check_config.values_checked.contains(&name) - && !sess.check_config.values_valid.contains(&(name, val)) - { - sess.buffer_lint( + if let Some(names_valid) = &sess.check_config.names_valid { + if !names_valid.contains(&name) { + sess.buffer_lint_with_diagnostic( UNEXPECTED_CFGS, cfg.span, CRATE_NODE_ID, - "unexpected `cfg` condition value", + "unexpected `cfg` condition name", + BuiltinLintDiagnostics::UnexpectedCfg(ident.span, name, None), ); } } + if let Some(value) = value { + if let Some(values) = &sess.check_config.values_valid.get(&name) { + if !values.contains(&value) { + sess.buffer_lint_with_diagnostic( + UNEXPECTED_CFGS, + cfg.span, + CRATE_NODE_ID, + "unexpected `cfg` condition value", + BuiltinLintDiagnostics::UnexpectedCfg( + cfg.name_value_literal_span().unwrap(), + name, + Some(value), + ), + ); + } + } + } sess.config.contains(&(name, value)) } } diff --git a/compiler/rustc_codegen_cranelift/src/main_shim.rs b/compiler/rustc_codegen_cranelift/src/main_shim.rs index 9ce727279c27c..2f71a70a44946 100644 --- a/compiler/rustc_codegen_cranelift/src/main_shim.rs +++ b/compiler/rustc_codegen_cranelift/src/main_shim.rs @@ -51,7 +51,10 @@ pub(crate) fn maybe_create_entry_wrapper( // late-bound regions, since late-bound // regions must appear in the argument // listing. - let main_ret_ty = tcx.erase_regions(main_ret_ty.no_bound_vars().unwrap()); + let main_ret_ty = tcx.normalize_erasing_regions( + ty::ParamEnv::reveal_all(), + main_ret_ty.no_bound_vars().unwrap(), + ); let cmain_sig = Signature { params: vec![ diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs index 4ca92b3efe098..d515502d445a9 100644 --- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs +++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs @@ -449,7 +449,10 @@ fn pointer_or_reference_metadata<'ll, 'tcx>( // This is a thin pointer. Create a regular pointer type and give it the correct name. debug_assert_eq!( (thin_pointer_size, thin_pointer_align), - cx.size_and_align_of(ptr_type) + cx.size_and_align_of(ptr_type), + "ptr_type={}, pointee_type={}", + ptr_type, + pointee_type, ); unsafe { diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs b/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs index acd032a7dc6d0..fa75463067f47 100644 --- a/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs +++ b/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs @@ -4,9 +4,9 @@ use super::namespace::item_namespace; use super::CrateDebugContext; use rustc_hir::def_id::DefId; -use rustc_middle::ty::layout::LayoutOf; +use rustc_middle::ty::layout::{HasParamEnv, LayoutOf}; use rustc_middle::ty::{self, DefIdTree, Ty}; -use rustc_target::abi::Variants; +use tracing::trace; use crate::common::CodegenCx; use crate::llvm; @@ -63,30 +63,26 @@ pub(crate) fn fat_pointer_kind<'ll, 'tcx>( cx: &CodegenCx<'ll, 'tcx>, pointee_ty: Ty<'tcx>, ) -> Option { - let layout = cx.layout_of(pointee_ty); + let pointee_tail_ty = cx.tcx.struct_tail_erasing_lifetimes(pointee_ty, cx.param_env()); + let layout = cx.layout_of(pointee_tail_ty); + trace!( + "fat_pointer_kind: {:?} has layout {:?} (is_unsized? {})", + pointee_tail_ty, + layout, + layout.is_unsized() + ); if !layout.is_unsized() { return None; } - match *pointee_ty.kind() { + match *pointee_tail_ty.kind() { ty::Str | ty::Slice(_) => Some(FatPtrKind::Slice), ty::Dynamic(..) => Some(FatPtrKind::Dyn), - ty::Adt(..) | ty::Tuple(..) if matches!(layout.variants, Variants::Single { .. }) => { - let last_field_index = layout.fields.count() - 1; - debug_assert!( - (0..last_field_index) - .all(|field_index| { !layout.field(cx, field_index).is_unsized() }) - ); - - let unsized_field = layout.field(cx, last_field_index); - debug_assert!(unsized_field.is_unsized()); - fat_pointer_kind(cx, unsized_field.ty) - } ty::Foreign(_) => { // Assert that pointers to foreign types really are thin: debug_assert_eq!( - cx.size_of(cx.tcx.mk_imm_ptr(pointee_ty)), + cx.size_of(cx.tcx.mk_imm_ptr(pointee_tail_ty)), cx.size_of(cx.tcx.mk_imm_ptr(cx.tcx.types.u8)) ); None @@ -94,7 +90,10 @@ pub(crate) fn fat_pointer_kind<'ll, 'tcx>( _ => { // For all other pointee types we should already have returned None // at the beginning of the function. - panic!("fat_pointer_kind() - Encountered unexpected `pointee_ty`: {:?}", pointee_ty) + panic!( + "fat_pointer_kind() - Encountered unexpected `pointee_tail_ty`: {:?}", + pointee_tail_ty + ) } } } diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs index ed6c156547e29..11f32d92e44cd 100644 --- a/compiler/rustc_codegen_ssa/src/base.rs +++ b/compiler/rustc_codegen_ssa/src/base.rs @@ -407,7 +407,10 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( // late-bound regions, since late-bound // regions must appear in the argument // listing. - let main_ret_ty = cx.tcx().erase_regions(main_ret_ty.no_bound_vars().unwrap()); + let main_ret_ty = cx.tcx().normalize_erasing_regions( + ty::ParamEnv::reveal_all(), + main_ret_ty.no_bound_vars().unwrap(), + ); let Some(llfn) = cx.declare_c_main(llfty) else { // FIXME: We should be smart and show a better diagnostic here. diff --git a/compiler/rustc_error_codes/src/error_codes/E0687.md b/compiler/rustc_error_codes/src/error_codes/E0687.md index 67b7db2d31fde..05c4915535de8 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0687.md +++ b/compiler/rustc_error_codes/src/error_codes/E0687.md @@ -1,8 +1,10 @@ +#### Note: this error code is no longer emitted by the compiler. + In-band lifetimes cannot be used in `fn`/`Fn` syntax. Erroneous code examples: -```compile_fail,E0687 +```ignore (feature got removed) #![feature(in_band_lifetimes)] fn foo(x: fn(&'a u32)) {} // error! diff --git a/compiler/rustc_error_codes/src/error_codes/E0688.md b/compiler/rustc_error_codes/src/error_codes/E0688.md index db50f490208f4..44e641a2a0b5a 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0688.md +++ b/compiler/rustc_error_codes/src/error_codes/E0688.md @@ -1,8 +1,10 @@ +#### Note: this error code is no longer emitted by the compiler. + In-band lifetimes were mixed with explicit lifetime binders. Erroneous code example: -```compile_fail,E0688 +```ignore (feature got removed) #![feature(in_band_lifetimes)] fn foo<'a>(x: &'a u32, y: &'b u32) {} // error! diff --git a/compiler/rustc_feature/src/active.rs b/compiler/rustc_feature/src/active.rs index 5545abc6024af..1d9d16e85cb21 100644 --- a/compiler/rustc_feature/src/active.rs +++ b/compiler/rustc_feature/src/active.rs @@ -400,8 +400,6 @@ declare_features! ( (active, if_let_guard, "1.47.0", Some(51114), None), /// Allows using imported `main` function (active, imported_main, "1.53.0", Some(28937), None), - /// Allows in-band quantification of lifetime bindings (e.g., `fn foo(x: &'a u8) -> &'a u8`). - (active, in_band_lifetimes, "1.23.0", Some(44524), None), /// Allows inferring `'static` outlives requirements (RFC 2093). (active, infer_static_outlives_requirements, "1.26.0", Some(54185), None), /// Allows associated types in inherent impls. diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs index f5f944db5e90b..fae9bd633afff 100644 --- a/compiler/rustc_feature/src/removed.rs +++ b/compiler/rustc_feature/src/removed.rs @@ -104,6 +104,9 @@ declare_features! ( (removed, impl_trait_in_bindings, "1.55.0", Some(63065), None, Some("the implementation was not maintainable, the feature may get reintroduced once the current refactorings are done")), (removed, import_shadowing, "1.0.0", None, None, None), + /// Allows in-band quantification of lifetime bindings (e.g., `fn foo(x: &'a u8) -> &'a u8`). + (removed, in_band_lifetimes, "1.23.0", Some(44524), None, + Some("removed due to unsolved ergonomic questions and added lifetime resolution complexity")), /// Lazily evaluate constants. This allows constants to depend on type parameters. (removed, lazy_normalization_consts, "1.46.0", Some(72219), None, Some("superseded by `generic_const_exprs`")), /// Allows using the `#[link_args]` attribute. diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index d48c8e81f540f..ccc2a2038af38 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -470,11 +470,6 @@ pub enum LifetimeParamKind { // `fn foo<'a>(x: &'a u8) -> &'a u8 { x }`). Explicit, - // Indicates that the lifetime definition was synthetically added - // as a result of an in-band lifetime usage (e.g., in - // `fn foo(x: &'a u8) -> &'a u8 { x }`). - InBand, - // Indication that the lifetime was elided (e.g., in both cases in // `fn foo(x: &u8) -> &'_ u8 { x }`). Elided, diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/find_anon_type.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/find_anon_type.rs index b1535701bb399..135714af2a6c1 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/find_anon_type.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/find_anon_type.rs @@ -125,7 +125,7 @@ impl<'tcx> Visitor<'tcx> for FindNestedTypeVisitor<'tcx> { // Find the index of the named region that was part of the // error. We will then search the function parameters for a bound // region at the right depth with the same index - (Some(rl::Region::EarlyBound(_, id, _)), ty::BrNamed(def_id, _)) => { + (Some(rl::Region::EarlyBound(_, id)), ty::BrNamed(def_id, _)) => { debug!("EarlyBound id={:?} def_id={:?}", id, def_id); if id == def_id { self.found_type = Some(arg); @@ -137,7 +137,7 @@ impl<'tcx> Visitor<'tcx> for FindNestedTypeVisitor<'tcx> { // error. We will then search the function parameters for a bound // region at the right depth with the same index ( - Some(rl::Region::LateBound(debruijn_index, _, id, _)), + Some(rl::Region::LateBound(debruijn_index, _, id)), ty::BrNamed(def_id, _), ) => { debug!( @@ -155,8 +155,8 @@ impl<'tcx> Visitor<'tcx> for FindNestedTypeVisitor<'tcx> { Some( rl::Region::Static | rl::Region::Free(_, _) - | rl::Region::EarlyBound(_, _, _) - | rl::Region::LateBound(_, _, _, _) + | rl::Region::EarlyBound(_, _) + | rl::Region::LateBound(_, _, _) | rl::Region::LateBoundAnon(_, _, _), ) | None, @@ -221,7 +221,7 @@ impl<'tcx> Visitor<'tcx> for TyPathVisitor<'tcx> { } } - (Some(rl::Region::EarlyBound(_, id, _)), ty::BrNamed(def_id, _)) => { + (Some(rl::Region::EarlyBound(_, id)), ty::BrNamed(def_id, _)) => { debug!("EarlyBound id={:?} def_id={:?}", id, def_id); if id == def_id { self.found_it = true; @@ -229,7 +229,7 @@ impl<'tcx> Visitor<'tcx> for TyPathVisitor<'tcx> { } } - (Some(rl::Region::LateBound(debruijn_index, _, id, _)), ty::BrNamed(def_id, _)) => { + (Some(rl::Region::LateBound(debruijn_index, _, id)), ty::BrNamed(def_id, _)) => { debug!("FindNestedTypeVisitor::visit_ty: LateBound depth = {:?}", debruijn_index,); debug!("id={:?}", id); debug!("def_id={:?}", def_id); @@ -242,8 +242,8 @@ impl<'tcx> Visitor<'tcx> for TyPathVisitor<'tcx> { ( Some( rl::Region::Static - | rl::Region::EarlyBound(_, _, _) - | rl::Region::LateBound(_, _, _, _) + | rl::Region::EarlyBound(_, _) + | rl::Region::LateBound(_, _, _) | rl::Region::LateBoundAnon(_, _, _) | rl::Region::Free(_, _), ) diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs index 609fc4b78c0de..91ced2a2d90e2 100644 --- a/compiler/rustc_interface/src/interface.rs +++ b/compiler/rustc_interface/src/interface.rs @@ -169,11 +169,12 @@ pub fn parse_check_cfg(specs: Vec) -> CheckCfg { Ok(meta_item) if parser.token == token::Eof => { if let Some(args) = meta_item.meta_item_list() { if meta_item.has_name(sym::names) { - cfg.names_checked = true; + let names_valid = + cfg.names_valid.get_or_insert_with(|| FxHashSet::default()); for arg in args { if arg.is_word() && arg.ident().is_some() { let ident = arg.ident().expect("multi-segment cfg key"); - cfg.names_valid.insert(ident.name.to_string()); + names_valid.insert(ident.name.to_string()); } else { error!("`names()` arguments must be simple identifers"); } @@ -183,13 +184,16 @@ pub fn parse_check_cfg(specs: Vec) -> CheckCfg { if let Some((name, values)) = args.split_first() { if name.is_word() && name.ident().is_some() { let ident = name.ident().expect("multi-segment cfg key"); - cfg.values_checked.insert(ident.to_string()); + let ident_values = cfg + .values_valid + .entry(ident.name.to_string()) + .or_insert_with(|| FxHashSet::default()); + for val in values { if let Some(LitKind::Str(s, _)) = val.literal().map(|lit| &lit.kind) { - cfg.values_valid - .insert((ident.to_string(), s.to_string())); + ident_values.insert(s.to_string()); } else { error!( "`values()` arguments must be string literals" @@ -219,7 +223,9 @@ pub fn parse_check_cfg(specs: Vec) -> CheckCfg { ); } - cfg.names_valid.extend(cfg.values_checked.iter().cloned()); + if let Some(names_valid) = &mut cfg.names_valid { + names_valid.extend(cfg.values_valid.keys().cloned()); + } cfg }) } diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index d8f55292ccd8d..0c9defc4ceac4 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -765,7 +765,40 @@ pub trait LintContext: Sized { BuiltinLintDiagnostics::NamedAsmLabel(help) => { db.help(&help); db.note("see the asm section of Rust By Example for more information"); - } + }, + BuiltinLintDiagnostics::UnexpectedCfg(span, name, value) => { + let possibilities: Vec = if value.is_some() { + let Some(values) = &sess.parse_sess.check_config.values_valid.get(&name) else { + bug!("it shouldn't be possible to have a diagnostic on a value whose name is not in values"); + }; + values.iter().map(|&s| s).collect() + } else { + let Some(names_valid) = &sess.parse_sess.check_config.names_valid else { + bug!("it shouldn't be possible to have a diagnostic on a name if name checking is not enabled"); + }; + names_valid.iter().map(|s| *s).collect() + }; + + // Show the full list if all possible values for a given name, but don't do it + // for names as the possibilities could be very long + if value.is_some() { + if !possibilities.is_empty() { + let mut possibilities = possibilities.iter().map(Symbol::as_str).collect::>(); + possibilities.sort(); + + let possibilities = possibilities.join(", "); + db.note(&format!("expected values for `{name}` are: {possibilities}")); + } else { + db.note(&format!("no expected value for `{name}`")); + } + } + + // Suggest the most probable if we found one + if let Some(best_match) = find_best_match_for_name(&possibilities, value.unwrap_or(name), None) { + let punctuation = if value.is_some() { "\"" } else { "" }; + db.span_suggestion(span, "did you mean", format!("{punctuation}{best_match}{punctuation}"), Applicability::MaybeIncorrect); + } + }, } // Rewrap `db`, and pass control to the user. decorate(LintDiagnosticBuilder::new(db)); diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs index 69863b5ff827f..7182022d25298 100644 --- a/compiler/rustc_lint/src/lib.rs +++ b/compiler/rustc_lint/src/lib.rs @@ -31,6 +31,7 @@ #![feature(box_patterns)] #![feature(crate_visibility_modifier)] #![feature(if_let_guard)] +#![feature(iter_intersperse)] #![feature(iter_order_by)] #![feature(let_else)] #![feature(never_type)] diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs index 1f834b7212fe5..e9c62fc400651 100644 --- a/compiler/rustc_lint_defs/src/lib.rs +++ b/compiler/rustc_lint_defs/src/lib.rs @@ -310,6 +310,7 @@ pub enum BuiltinLintDiagnostics { BreakWithLabelAndLoop(Span), NamedAsmLabel(String), UnicodeTextFlow(Span, String), + UnexpectedCfg(Span, Symbol, Option), } /// Lints that are buffered up early on in the `Session` before the diff --git a/compiler/rustc_middle/src/middle/resolve_lifetime.rs b/compiler/rustc_middle/src/middle/resolve_lifetime.rs index 2665ea8d7fd73..98375cbad9f9b 100644 --- a/compiler/rustc_middle/src/middle/resolve_lifetime.rs +++ b/compiler/rustc_middle/src/middle/resolve_lifetime.rs @@ -4,47 +4,14 @@ use crate::ty; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir::def_id::{DefId, LocalDefId}; -use rustc_hir::{GenericParam, ItemLocalId}; -use rustc_hir::{GenericParamKind, LifetimeParamKind}; +use rustc_hir::ItemLocalId; use rustc_macros::HashStable; -/// The origin of a named lifetime definition. -/// -/// This is used to prevent the usage of in-band lifetimes in `Fn`/`fn` syntax. -#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable, Debug, HashStable)] -pub enum LifetimeDefOrigin { - // Explicit binders like `fn foo<'a>(x: &'a u8)` or elided like `impl Foo<&u32>` - ExplicitOrElided, - // In-band declarations like `fn foo(x: &'a u8)` - InBand, - // Some kind of erroneous origin - Error, -} - -impl LifetimeDefOrigin { - pub fn from_param(param: &GenericParam<'_>) -> Self { - match param.kind { - GenericParamKind::Lifetime { kind } => match kind { - LifetimeParamKind::InBand => LifetimeDefOrigin::InBand, - LifetimeParamKind::Explicit => LifetimeDefOrigin::ExplicitOrElided, - LifetimeParamKind::Elided => LifetimeDefOrigin::ExplicitOrElided, - LifetimeParamKind::Error => LifetimeDefOrigin::Error, - }, - _ => bug!("expected a lifetime param"), - } - } -} - #[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable, Debug, HashStable)] pub enum Region { Static, - EarlyBound(/* index */ u32, /* lifetime decl */ DefId, LifetimeDefOrigin), - LateBound( - ty::DebruijnIndex, - /* late-bound index */ u32, - /* lifetime decl */ DefId, - LifetimeDefOrigin, - ), + EarlyBound(/* index */ u32, /* lifetime decl */ DefId), + LateBound(ty::DebruijnIndex, /* late-bound index */ u32, /* lifetime decl */ DefId), LateBoundAnon(ty::DebruijnIndex, /* late-bound index */ u32, /* anon index */ u32), Free(DefId, /* lifetime decl */ DefId), } diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs index a517e4879aafa..2f88c45a2a389 100644 --- a/compiler/rustc_monomorphize/src/collector.rs +++ b/compiler/rustc_monomorphize/src/collector.rs @@ -1270,7 +1270,10 @@ impl<'v> RootCollector<'_, 'v> { // late-bound regions, since late-bound // regions must appear in the argument // listing. - let main_ret_ty = self.tcx.erase_regions(main_ret_ty.no_bound_vars().unwrap()); + let main_ret_ty = self.tcx.normalize_erasing_regions( + ty::ParamEnv::reveal_all(), + main_ret_ty.no_bound_vars().unwrap(), + ); let start_instance = Instance::resolve( self.tcx, diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs index f20cf29cc89d1..260fc81500a86 100644 --- a/compiler/rustc_resolve/src/late/diagnostics.rs +++ b/compiler/rustc_resolve/src/late/diagnostics.rs @@ -1844,7 +1844,6 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { lifetime_ref ); err.span_label(lifetime_ref.span, "undeclared lifetime"); - let mut suggests_in_band = false; let mut suggested_spans = vec![]; for missing in &self.missing_named_lifetime_spots { match missing { @@ -1860,7 +1859,6 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { }) { (param.span.shrink_to_lo(), format!("{}, ", lifetime_ref)) } else { - suggests_in_band = true; (generics.span, format!("<{}>", lifetime_ref)) }; if suggested_spans.contains(&span) { @@ -1895,15 +1893,6 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { _ => {} } } - if self.tcx.sess.is_nightly_build() - && !self.tcx.features().in_band_lifetimes - && suggests_in_band - { - err.help( - "if you want to experiment with in-band lifetime bindings, \ - add `#![feature(in_band_lifetimes)]` to the crate attributes", - ); - } err.emit(); } diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs index 2f0ad60709dac..7a7b466d82743 100644 --- a/compiler/rustc_resolve/src/late/lifetimes.rs +++ b/compiler/rustc_resolve/src/late/lifetimes.rs @@ -1,4 +1,3 @@ -// ignore-tidy-filelength //! Name resolution for lifetimes. //! //! Name resolution for lifetimes follows *much* simpler rules than the @@ -16,7 +15,7 @@ use rustc_hir::def_id::{DefIdMap, LocalDefId}; use rustc_hir::hir_id::ItemLocalId; use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::{GenericArg, GenericParam, LifetimeName, Node, ParamName, QPath}; -use rustc_hir::{GenericParamKind, HirIdMap, HirIdSet, LifetimeParamKind}; +use rustc_hir::{GenericParamKind, HirIdMap, HirIdSet}; use rustc_middle::hir::map::Map; use rustc_middle::hir::nested_filter; use rustc_middle::middle::resolve_lifetime::*; @@ -63,23 +62,18 @@ impl RegionExt for Region { let i = *index; *index += 1; let def_id = hir_map.local_def_id(param.hir_id); - let origin = LifetimeDefOrigin::from_param(param); debug!("Region::early: index={} def_id={:?}", i, def_id); - (param.name.normalize_to_macros_2_0(), Region::EarlyBound(i, def_id.to_def_id(), origin)) + (param.name.normalize_to_macros_2_0(), Region::EarlyBound(i, def_id.to_def_id())) } fn late(idx: u32, hir_map: Map<'_>, param: &GenericParam<'_>) -> (ParamName, Region) { let depth = ty::INNERMOST; let def_id = hir_map.local_def_id(param.hir_id); - let origin = LifetimeDefOrigin::from_param(param); debug!( - "Region::late: idx={:?}, param={:?} depth={:?} def_id={:?} origin={:?}", - idx, param, depth, def_id, origin, + "Region::late: idx={:?}, param={:?} depth={:?} def_id={:?}", + idx, param, depth, def_id, ); - ( - param.name.normalize_to_macros_2_0(), - Region::LateBound(depth, idx, def_id.to_def_id(), origin), - ) + (param.name.normalize_to_macros_2_0(), Region::LateBound(depth, idx, def_id.to_def_id())) } fn late_anon(named_late_bound_vars: u32, index: &Cell) -> Region { @@ -93,7 +87,7 @@ impl RegionExt for Region { match *self { Region::Static | Region::LateBoundAnon(..) => None, - Region::EarlyBound(_, id, _) | Region::LateBound(_, _, id, _) | Region::Free(_, id) => { + Region::EarlyBound(_, id) | Region::LateBound(_, _, id) | Region::Free(_, id) => { Some(id) } } @@ -101,8 +95,8 @@ impl RegionExt for Region { fn shifted(self, amount: u32) -> Region { match self { - Region::LateBound(debruijn, idx, id, origin) => { - Region::LateBound(debruijn.shifted_in(amount), idx, id, origin) + Region::LateBound(debruijn, idx, id) => { + Region::LateBound(debruijn.shifted_in(amount), idx, id) } Region::LateBoundAnon(debruijn, index, anon_index) => { Region::LateBoundAnon(debruijn.shifted_in(amount), index, anon_index) @@ -113,8 +107,8 @@ impl RegionExt for Region { fn shifted_out_to_binder(self, binder: ty::DebruijnIndex) -> Region { match self { - Region::LateBound(debruijn, index, id, origin) => { - Region::LateBound(debruijn.shifted_out_to_binder(binder), index, id, origin) + Region::LateBound(debruijn, index, id) => { + Region::LateBound(debruijn.shifted_out_to_binder(binder), index, id) } Region::LateBoundAnon(debruijn, index, anon_index) => { Region::LateBoundAnon(debruijn.shifted_out_to_binder(binder), index, anon_index) @@ -127,7 +121,7 @@ impl RegionExt for Region { where L: Iterator, { - if let Region::EarlyBound(index, _, _) = self { + if let Region::EarlyBound(index, _) = self { params.nth(index as usize).and_then(|lifetime| map.defs.get(&lifetime.hir_id).cloned()) } else { Some(self) @@ -568,7 +562,7 @@ fn sub_items_have_self_param(node: &hir::ItemKind<'_>) -> bool { fn late_region_as_bound_region<'tcx>(tcx: TyCtxt<'tcx>, region: &Region) -> ty::BoundVariableKind { match region { - Region::LateBound(_, _, def_id, _) => { + Region::LateBound(_, _, def_id) => { let name = tcx.hir().name(tcx.hir().local_def_id_to_hir_id(def_id.expect_local())); ty::BoundVariableKind::Region(ty::BrNamed(*def_id, name)) } @@ -1010,7 +1004,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { // well-supported at the moment, so this doesn't work. // In the future, this should be fixed and this error should be removed. let def = self.map.defs.get(&lifetime.hir_id).cloned(); - let Some(Region::LateBound(_, _, def_id, _)) = def else { + let Some(Region::LateBound(_, _, def_id)) = def else { continue }; let Some(def_id) = def_id.as_local() else { @@ -1046,7 +1040,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { match param.kind { GenericParamKind::Lifetime { .. } => { let (name, reg) = Region::early(self.tcx.hir(), &mut index, ¶m); - let Region::EarlyBound(_, def_id, _) = reg else { + let Region::EarlyBound(_, def_id) = reg else { bug!(); }; // We cannot predict what lifetimes are unused in opaque type. @@ -1325,9 +1319,6 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { } fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) { - if !self.trait_definition_only { - check_mixed_explicit_and_in_band_defs(self.tcx, &generics.params); - } let scope = Scope::TraitRefBoundary { s: self.scope }; self.with(scope, |_, this| { for param in generics.params { @@ -1535,30 +1526,6 @@ impl ShadowKind { } } -fn check_mixed_explicit_and_in_band_defs(tcx: TyCtxt<'_>, params: &[hir::GenericParam<'_>]) { - let lifetime_params: Vec<_> = params - .iter() - .filter_map(|param| match param.kind { - GenericParamKind::Lifetime { kind, .. } => Some((kind, param.span)), - _ => None, - }) - .collect(); - let explicit = lifetime_params.iter().find(|(kind, _)| *kind == LifetimeParamKind::Explicit); - let in_band = lifetime_params.iter().find(|(kind, _)| *kind == LifetimeParamKind::InBand); - - if let (Some((_, explicit_span)), Some((_, in_band_span))) = (explicit, in_band) { - struct_span_err!( - tcx.sess, - *in_band_span, - E0688, - "cannot mix in-band and explicit lifetime definitions" - ) - .span_label(*in_band_span, "in-band lifetime definition here") - .span_label(*explicit_span, "explicit lifetime definition here") - .emit(); - } -} - fn signal_shadowing_problem(tcx: TyCtxt<'_>, name: Symbol, orig: Original, shadower: Shadower) { let mut err = if let (ShadowKind::Lifetime, ShadowKind::Lifetime) = (orig.kind, shadower.kind) { // lifetime/lifetime shadowing is an error @@ -1695,7 +1662,7 @@ fn compute_object_lifetime_defaults<'tcx>( .map(|set| match *set { Set1::Empty => "BaseDefault".into(), Set1::One(Region::Static) => "'static".into(), - Set1::One(Region::EarlyBound(mut i, _, _)) => generics + Set1::One(Region::EarlyBound(mut i, _)) => generics .params .iter() .find_map(|param| match param.kind { @@ -1776,18 +1743,16 @@ fn object_lifetime_defaults_for_item<'tcx>( .params .iter() .filter_map(|param| match param.kind { - GenericParamKind::Lifetime { .. } => Some(( - param.hir_id, - hir::LifetimeName::Param(param.name), - LifetimeDefOrigin::from_param(param), - )), + GenericParamKind::Lifetime { .. } => { + Some((param.hir_id, hir::LifetimeName::Param(param.name))) + } _ => None, }) .enumerate() - .find(|&(_, (_, lt_name, _))| lt_name == name) - .map_or(Set1::Many, |(i, (id, _, origin))| { + .find(|&(_, (_, lt_name))| lt_name == name) + .map_or(Set1::Many, |(i, (id, _))| { let def_id = tcx.hir().local_def_id(id); - Set1::One(Region::EarlyBound(i as u32, def_id.to_def_id(), origin)) + Set1::One(Region::EarlyBound(i as u32, def_id.to_def_id())) }) } } @@ -1845,13 +1810,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { fn lifetime_deletion_span(&self, name: Ident, generics: &hir::Generics<'_>) -> Option { generics.params.iter().enumerate().find_map(|(i, param)| { if param.name.ident() == name { - let in_band = matches!( - param.kind, - hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::InBand } - ); - if in_band { - Some(param.span) - } else if generics.params.len() == 1 { + if generics.params.len() == 1 { // if sole lifetime, remove the entire `<>` brackets Some(generics.span) } else { @@ -1981,8 +1940,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { let def_ids: Vec<_> = defined_by .values() .flat_map(|region| match region { - Region::EarlyBound(_, def_id, _) - | Region::LateBound(_, _, def_id, _) + Region::EarlyBound(_, def_id) + | Region::LateBound(_, _, def_id) | Region::Free(_, def_id) => Some(*def_id), Region::LateBoundAnon(..) | Region::Static => None, @@ -2337,39 +2296,6 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { } } - // Check for fn-syntax conflicts with in-band lifetime definitions - if !self.trait_definition_only && self.is_in_fn_syntax { - match def { - Region::EarlyBound(_, _, LifetimeDefOrigin::InBand) - | Region::LateBound(_, _, _, LifetimeDefOrigin::InBand) => { - struct_span_err!( - self.tcx.sess, - lifetime_ref.span, - E0687, - "lifetimes used in `fn` or `Fn` syntax must be \ - explicitly declared using `<...>` binders" - ) - .span_label(lifetime_ref.span, "in-band lifetime definition") - .emit(); - } - - Region::Static - | Region::EarlyBound( - _, - _, - LifetimeDefOrigin::ExplicitOrElided | LifetimeDefOrigin::Error, - ) - | Region::LateBound( - _, - _, - _, - LifetimeDefOrigin::ExplicitOrElided | LifetimeDefOrigin::Error, - ) - | Region::LateBoundAnon(..) - | Region::Free(..) => {} - } - } - self.insert_lifetime(lifetime_ref, def); } else { self.emit_undeclared_lifetime_error(lifetime_ref); @@ -2949,7 +2875,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { fn visit_lifetime(&mut self, lifetime_ref: &hir::Lifetime) { if let Some(&lifetime) = self.map.defs.get(&lifetime_ref.hir_id) { match lifetime { - Region::LateBound(debruijn, _, _, _) + Region::LateBound(debruijn, _, _) | Region::LateBoundAnon(debruijn, _, _) if debruijn < self.outer_index => { @@ -3355,8 +3281,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { } Region::Free(_, def_id) - | Region::LateBound(_, _, def_id, _) - | Region::EarlyBound(_, def_id, _) => { + | Region::LateBound(_, _, def_id) + | Region::EarlyBound(_, def_id) => { // A lifetime declared by the user. let track_lifetime_uses = self.track_lifetime_uses(); debug!(?track_lifetime_uses); diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index 7a0d9a212c9d9..f9b75690e375f 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -8,7 +8,7 @@ use crate::search_paths::SearchPath; use crate::utils::{CanonicalizedPath, NativeLib, NativeLibKind}; use crate::{early_error, early_warn, Session}; -use rustc_data_structures::fx::FxHashSet; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::impl_stable_hash_via_hash; use rustc_target::abi::{Align, TargetDataLayout}; @@ -1023,34 +1023,30 @@ pub fn to_crate_config(cfg: FxHashSet<(String, Option)>) -> CrateConfig /// The parsed `--check-cfg` options pub struct CheckCfg { - /// Set if `names()` checking is enabled - pub names_checked: bool, - /// The union of all `names()` - pub names_valid: FxHashSet, - /// The set of names for which `values()` was used - pub values_checked: FxHashSet, - /// The set of all (name, value) pairs passed in `values()` - pub values_valid: FxHashSet<(T, T)>, + /// The set of all `names()`, if None no name checking is performed + pub names_valid: Option>, + /// The set of all `values()` + pub values_valid: FxHashMap>, } impl Default for CheckCfg { fn default() -> Self { - CheckCfg { - names_checked: false, - names_valid: FxHashSet::default(), - values_checked: FxHashSet::default(), - values_valid: FxHashSet::default(), - } + CheckCfg { names_valid: Default::default(), values_valid: Default::default() } } } impl CheckCfg { fn map_data(&self, f: impl Fn(&T) -> O) -> CheckCfg { CheckCfg { - names_checked: self.names_checked, - names_valid: self.names_valid.iter().map(|a| f(a)).collect(), - values_checked: self.values_checked.iter().map(|a| f(a)).collect(), - values_valid: self.values_valid.iter().map(|(a, b)| (f(a), f(b))).collect(), + names_valid: self + .names_valid + .as_ref() + .map(|names_valid| names_valid.iter().map(|a| f(a)).collect()), + values_valid: self + .values_valid + .iter() + .map(|(a, b)| (f(a), b.iter().map(|b| f(b)).collect())) + .collect(), } } } @@ -1090,17 +1086,23 @@ impl CrateCheckConfig { sym::doctest, sym::feature, ]; - for &name in WELL_KNOWN_NAMES { - self.names_valid.insert(name); + if let Some(names_valid) = &mut self.names_valid { + for &name in WELL_KNOWN_NAMES { + names_valid.insert(name); + } } } /// Fills a `CrateCheckConfig` with configuration names and values that are actually active. pub fn fill_actual(&mut self, cfg: &CrateConfig) { for &(k, v) in cfg { - self.names_valid.insert(k); + if let Some(names_valid) = &mut self.names_valid { + names_valid.insert(k); + } if let Some(v) = v { - self.values_valid.insert((k, v)); + self.values_valid.entry(k).and_modify(|values| { + values.insert(v); + }); } } } diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs index dbe7ddeb6a824..1ba7534d8699b 100644 --- a/compiler/rustc_typeck/src/astconv/mod.rs +++ b/compiler/rustc_typeck/src/astconv/mod.rs @@ -205,7 +205,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { let r = match tcx.named_region(lifetime.hir_id) { Some(rl::Region::Static) => tcx.lifetimes.re_static, - Some(rl::Region::LateBound(debruijn, index, def_id, _)) => { + Some(rl::Region::LateBound(debruijn, index, def_id)) => { let name = lifetime_name(def_id.expect_local()); let br = ty::BoundRegion { var: ty::BoundVar::from_u32(index), @@ -222,7 +222,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { tcx.mk_region(ty::ReLateBound(debruijn, br)) } - Some(rl::Region::EarlyBound(index, id, _)) => { + Some(rl::Region::EarlyBound(index, id)) => { let name = lifetime_name(id.expect_local()); tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion { def_id: id, index, name })) } diff --git a/compiler/rustc_typeck/src/coherence/orphan.rs b/compiler/rustc_typeck/src/coherence/orphan.rs index 54fffeb3cdaa6..811136a7eb4ee 100644 --- a/compiler/rustc_typeck/src/coherence/orphan.rs +++ b/compiler/rustc_typeck/src/coherence/orphan.rs @@ -439,6 +439,7 @@ fn fast_reject_auto_impl<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId, self_ty: } match t.kind() { + ty::Adt(def, substs) if def.is_phantom_data() => substs.super_visit_with(self), ty::Adt(def, substs) => { // @lcnr: This is the only place where cycles can happen. We avoid this // by only visiting each `DefId` once. diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs index 392144ca7639c..ae82aa5b94f47 100644 --- a/compiler/rustc_typeck/src/collect.rs +++ b/compiler/rustc_typeck/src/collect.rs @@ -1375,7 +1375,7 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option {} Some( - rl::Region::LateBound(debruijn, _, _, _) + rl::Region::LateBound(debruijn, _, _) | rl::Region::LateBoundAnon(debruijn, _, _), ) if debruijn < self.outer_index => {} Some( diff --git a/src/doc/unstable-book/src/compiler-flags/check-cfg.md b/src/doc/unstable-book/src/compiler-flags/check-cfg.md new file mode 100644 index 0000000000000..d7345ad0c33f2 --- /dev/null +++ b/src/doc/unstable-book/src/compiler-flags/check-cfg.md @@ -0,0 +1,221 @@ +# `check-cfg` + +The tracking issue for this feature is: [#82450](https://github.com/rust-lang/rust/issues/82450). + +------------------------ + +This feature allows you to enable complete or partial checking of configuration. + +`rustc` accepts the `--check-cfg` option, which specifies whether to check conditions and how to +check them. The `--check-cfg` option takes a value, called the _check cfg specification_. The +check cfg specification is parsed using the Rust metadata syntax, just as the `--cfg` option is. + +`--check-cfg` option can take one of two forms: + +1. `--check-cfg names(...)` enables checking condition names. +2. `--check-cfg values(...)` enables checking the values within list-valued conditions. + +These two options are independent. `names` checks only the namespace of condition names +while `values` checks only the namespace of the values of list-valued conditions. + +## The `names(...)` form + +The `names(...)` form enables checking the names. This form uses a named list: + +```bash +rustc --check-cfg 'names(name1, name2, ... nameN)' +``` + +where each `name` is a bare identifier (has no quotes). The order of the names is not significant. + +If `--check-cfg names(...)` is specified at least once, then `rustc` will check all references to +condition names. `rustc` will check every `#[cfg]` attribute, `#[cfg_attr]` attribute, `cfg` clause +inside `#[link]` attribute and `cfg!(...)` call against the provided list of expected condition +names. If a name is not present in this list, then `rustc` will report an `unexpected_cfgs` lint +diagnostic. The default diagnostic level for this lint is `Warn`. + +If `--check-cfg names(...)` is not specified, then `rustc` will not check references to condition +names. + +`--check-cfg names(...)` may be specified more than once. The result is that the list of valid +condition names is merged across all options. It is legal for a condition name to be specified +more than once; redundantly specifying a condition name has no effect. + +To enable checking condition names with an empty set of valid condition names, use the following +form. The parentheses are required. + +```bash +rustc --check-cfg 'names()' +``` + +Note that `--check-cfg 'names()'` is _not_ equivalent to omitting the option entirely. +The first form enables checking condition names, while specifying that there are no valid +condition names (outside of the set of well-known names defined by `rustc`). Omitting the +`--check-cfg 'names(...)'` option does not enable checking condition names. + +Conditions that are enabled are implicitly valid; it is unnecessary (but legal) to specify a +condition name as both enabled and valid. For example, the following invocations are equivalent: + +```bash +# condition names will be checked, and 'has_time_travel' is valid +rustc --cfg 'has_time_travel' --check-cfg 'names()' + +# condition names will be checked, and 'has_time_travel' is valid +rustc --cfg 'has_time_travel' --check-cfg 'names(has_time_travel)' +``` + +In contrast, the following two invocations are _not_ equivalent: + +```bash +# condition names will not be checked (because there is no --check-cfg names(...)) +rustc --cfg 'has_time_travel' + +# condition names will be checked, and 'has_time_travel' is both valid and enabled. +rustc --cfg 'has_time_travel' --check-cfg 'names(has_time_travel)' +``` + +## The `values(...)` form + +The `values(...)` form enables checking the values within list-valued conditions. It has this +form: + +```bash +rustc --check-cfg `values(name, "value1", "value2", ... "valueN")' +``` + +where `name` is a bare identifier (has no quotes) and each `"value"` term is a quoted literal +string. `name` specifies the name of the condition, such as `feature` or `target_os`. + +When the `values(...)` option is specified, `rustc` will check every `#[cfg(name = "value")]` +attribute, `#[cfg_attr(name = "value")]` attribute, `#[link(name = "a", cfg(name = "value"))]` +and `cfg!(name = "value")` call. It will check that the `"value"` specified is present in the +list of expected values. If `"value"` is not in it, then `rustc` will report an `unexpected_cfgs` +lint diagnostic. The default diagnostic level for this lint is `Warn`. + +The form `values()` is an error, because it does not specify a condition name. + +To enable checking of values, but to provide an empty set of valid values, use this form: + +```bash +rustc --check-cfg `values(name)` +``` + +The `--check-cfg values(...)` option can be repeated, both for the same condition name and for +different names. If it is repeated for the same condition name, then the sets of values for that +condition are merged together. + +## Examples + +Consider this command line: + +```bash +rustc --check-cfg 'names(feature)' \ + --check-cfg 'values(feature,"lion","zebra")' \ + --cfg 'feature="lion"' -Z unstable-options \ + example.rs +``` + +This command line indicates that this crate has two features: `lion` and `zebra`. The `lion` +feature is enabled, while the `zebra` feature is disabled. Consider compiling this code: + +```rust +// This is expected, and tame_lion() will be compiled +#[cfg(feature = "lion")] +fn tame_lion(lion: Lion) {} + +// This is expected, and ride_zebra() will NOT be compiled. +#[cfg(feature = "zebra")] +fn ride_zebra(zebra: Zebra) {} + +// This is UNEXPECTED, and will cause a compiler warning (by default). +#[cfg(feature = "platypus")] +fn poke_platypus() {} + +// This is UNEXPECTED, because 'feechure' is not a known condition name, +// and will cause a compiler warning (by default). +#[cfg(feechure = "lion")] +fn tame_lion() {} +``` + +> Note: The `--check-cfg names(feature)` option is necessary only to enable checking the condition +> name, as in the last example. `feature` is a well-known (always-expected) condition name, and so +> it is not necessary to specify it in a `--check-cfg 'names(...)'` option. That option can be +> shortened to > `--check-cfg names()` in order to enable checking well-known condition names. + +### Example: Checking condition names, but not values + +```bash +# This turns on checking for condition names, but not values, such as 'feature' values. +rustc --check-cfg 'names(is_embedded, has_feathers)' \ + --cfg has_feathers --cfg 'feature = "zapping"' -Z unstable-options +``` + +```rust +#[cfg(is_embedded)] // This is expected as "is_embedded" was provided in names() +fn do_embedded() {} + +#[cfg(has_feathers)] // This is expected as "has_feathers" was provided in names() +fn do_features() {} + +#[cfg(has_mumble_frotz)] // This is UNEXPECTED because names checking is enable and + // "has_mumble_frotz" was not provided in names() +fn do_mumble_frotz() {} + +#[cfg(feature = "lasers")] // This doesn't raise a warning, because values checking for "feature" + // was never used +fn shoot_lasers() {} +``` + +### Example: Checking feature values, but not condition names + +```bash +# This turns on checking for feature values, but not for condition names. +rustc --check-cfg 'values(feature, "zapping", "lasers")' \ + --cfg 'feature="zapping"' -Z unstable-options +``` + +```rust +#[cfg(is_embedded)] // This is doesn't raise a warning, because names checking was not + // enable (ie not names()) +fn do_embedded() {} + +#[cfg(has_feathers)] // Same as above, --check-cfg names(...) was never used so no name + // checking is performed +fn do_features() {} + + +#[cfg(feature = "lasers")] // This is expected, "lasers" is in the values(feature) list +fn shoot_lasers() {} + +#[cfg(feature = "monkeys")] // This is UNEXPECTED, because "monkeys" is not in the + // --check-cfg values(feature) list +fn write_shakespeare() {} +``` + +### Example: Checking both condition names and feature values + +```bash +# This turns on checking for feature values and for condition names. +rustc --check-cfg 'names(is_embedded, has_feathers)' \ + --check-cfg 'values(feature, "zapping", "lasers")' \ + --cfg has_feathers --cfg 'feature="zapping"' -Z unstable-options +``` + +```rust +#[cfg(is_embedded)] // This is expected because "is_embedded" was provided in names() +fn do_embedded() {} + +#[cfg(has_feathers)] // This is expected because "has_feathers" was provided in names() +fn do_features() {} + +#[cfg(has_mumble_frotz)] // This is UNEXPECTED, because has_mumble_frotz is not in the + // --check-cfg names(...) list +fn do_mumble_frotz() {} + +#[cfg(feature = "lasers")] // This is expected, "lasers" is in the values(feature) list +fn shoot_lasers() {} + +#[cfg(feature = "monkeys")] // This is UNEXPECTED, because "monkeys" is not in + // the values(feature) list +fn write_shakespear() {} +``` diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 76994f2ee1712..0484066cb8d59 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -193,8 +193,8 @@ impl Clean for hir::Lifetime { fn clean(&self, cx: &mut DocContext<'_>) -> Lifetime { let def = cx.tcx.named_region(self.hir_id); if let Some( - rl::Region::EarlyBound(_, node_id, _) - | rl::Region::LateBound(_, _, node_id, _) + rl::Region::EarlyBound(_, node_id) + | rl::Region::LateBound(_, _, node_id) | rl::Region::Free(_, node_id), ) = def { diff --git a/src/test/ui/async-await/generics-and-bounds.rs b/src/test/ui/async-await/generics-and-bounds.rs index 90ab0c01f5450..963b19b34a620 100644 --- a/src/test/ui/async-await/generics-and-bounds.rs +++ b/src/test/ui/async-await/generics-and-bounds.rs @@ -2,8 +2,6 @@ // edition:2018 // compile-flags: --crate-type lib -#![feature(in_band_lifetimes)] - use std::future::Future; pub async fn simple_generic() {} @@ -73,10 +71,6 @@ pub fn call_with_ref_block<'a>(f: &'a (impl Foo + 'a)) -> impl Future impl Future + 'a { - async move { f.foo() } -} - pub fn async_block_with_same_generic_params_unifies() { let mut a = call_generic_bound_block(FooType); a = call_generic_bound_block(FooType); @@ -91,9 +85,4 @@ pub fn async_block_with_same_generic_params_unifies() { let f_two = FooType; let mut d = call_with_ref_block(&f_one); d = call_with_ref_block(&f_two); - - let f_one = FooType; - let f_two = FooType; - let mut d = call_with_ref_block_in_band(&f_one); - d = call_with_ref_block_in_band(&f_two); } diff --git a/src/test/ui/auto-traits/suspicious-impls-lint.rs b/src/test/ui/auto-traits/suspicious-impls-lint.rs index 1026a35a455ac..1574a7e02e97f 100644 --- a/src/test/ui/auto-traits/suspicious-impls-lint.rs +++ b/src/test/ui/auto-traits/suspicious-impls-lint.rs @@ -1,5 +1,7 @@ #![deny(suspicious_auto_trait_impls)] +use std::marker::PhantomData; + struct MayImplementSendOk(T); unsafe impl Send for MayImplementSendOk {} // ok @@ -31,4 +33,12 @@ unsafe impl Send for TwoParamsSame {} //~^ ERROR //~| WARNING this will change its meaning +pub struct WithPhantomDataNonSend(PhantomData<*const T>, U); +unsafe impl Send for WithPhantomDataNonSend {} // ok + +pub struct WithPhantomDataSend(PhantomData, U); +unsafe impl Send for WithPhantomDataSend<*const T, i8> {} +//~^ ERROR +//~| WARNING this will change its meaning + fn main() {} diff --git a/src/test/ui/auto-traits/suspicious-impls-lint.stderr b/src/test/ui/auto-traits/suspicious-impls-lint.stderr index f91aa862271d3..084bfef49c029 100644 --- a/src/test/ui/auto-traits/suspicious-impls-lint.stderr +++ b/src/test/ui/auto-traits/suspicious-impls-lint.stderr @@ -1,5 +1,5 @@ error: cross-crate traits with a default impl, like `Send`, should not be specialized - --> $DIR/suspicious-impls-lint.rs:7:1 + --> $DIR/suspicious-impls-lint.rs:9:1 | LL | unsafe impl Send for MayImplementSendErr<&T> {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -12,14 +12,14 @@ LL | #![deny(suspicious_auto_trait_impls)] = warning: this will change its meaning in a future release! = note: for more information, see issue #93367 note: try using the same sequence of generic parameters as the struct definition - --> $DIR/suspicious-impls-lint.rs:6:1 + --> $DIR/suspicious-impls-lint.rs:8:1 | LL | struct MayImplementSendErr(T); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: `&T` is not a generic parameter error: cross-crate traits with a default impl, like `Send`, should not be specialized - --> $DIR/suspicious-impls-lint.rs:19:1 + --> $DIR/suspicious-impls-lint.rs:21:1 | LL | unsafe impl Send for ContainsVec {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -27,14 +27,14 @@ LL | unsafe impl Send for ContainsVec {} = warning: this will change its meaning in a future release! = note: for more information, see issue #93367 note: try using the same sequence of generic parameters as the struct definition - --> $DIR/suspicious-impls-lint.rs:18:1 + --> $DIR/suspicious-impls-lint.rs:20:1 | LL | struct ContainsVec(Vec); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: `i32` is not a generic parameter error: cross-crate traits with a default impl, like `Send`, should not be specialized - --> $DIR/suspicious-impls-lint.rs:30:1 + --> $DIR/suspicious-impls-lint.rs:32:1 | LL | unsafe impl Send for TwoParamsSame {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -42,11 +42,26 @@ LL | unsafe impl Send for TwoParamsSame {} = warning: this will change its meaning in a future release! = note: for more information, see issue #93367 note: try using the same sequence of generic parameters as the struct definition - --> $DIR/suspicious-impls-lint.rs:29:1 + --> $DIR/suspicious-impls-lint.rs:31:1 | LL | struct TwoParamsSame(T, U); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: `T` is mentioned multiple times -error: aborting due to 3 previous errors +error: cross-crate traits with a default impl, like `Send`, should not be specialized + --> $DIR/suspicious-impls-lint.rs:40:1 + | +LL | unsafe impl Send for WithPhantomDataSend<*const T, i8> {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = warning: this will change its meaning in a future release! + = note: for more information, see issue #93367 +note: try using the same sequence of generic parameters as the struct definition + --> $DIR/suspicious-impls-lint.rs:39:1 + | +LL | pub struct WithPhantomDataSend(PhantomData, U); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = note: `*const T` is not a generic parameter + +error: aborting due to 4 previous errors diff --git a/src/test/ui/check-cfg/invalid-cfg-name.stderr b/src/test/ui/check-cfg/invalid-cfg-name.stderr index 2587685afa048..2bd1821c9422b 100644 --- a/src/test/ui/check-cfg/invalid-cfg-name.stderr +++ b/src/test/ui/check-cfg/invalid-cfg-name.stderr @@ -2,7 +2,7 @@ warning: unexpected `cfg` condition name --> $DIR/invalid-cfg-name.rs:7:7 | LL | #[cfg(widnows)] - | ^^^^^^^ + | ^^^^^^^ help: did you mean: `windows` | = note: `#[warn(unexpected_cfgs)]` on by default diff --git a/src/test/ui/check-cfg/invalid-cfg-value.stderr b/src/test/ui/check-cfg/invalid-cfg-value.stderr index c591d8474a261..bc2c053fed65a 100644 --- a/src/test/ui/check-cfg/invalid-cfg-value.stderr +++ b/src/test/ui/check-cfg/invalid-cfg-value.stderr @@ -5,6 +5,7 @@ LL | #[cfg(feature = "sedre")] | ^^^^^^^^^^^^^^^^^ | = note: `#[warn(unexpected_cfgs)]` on by default + = note: expected values for `feature` are: full, rand, serde warning: 1 warning emitted diff --git a/src/test/ui/check-cfg/mix.rs b/src/test/ui/check-cfg/mix.rs new file mode 100644 index 0000000000000..26c735c4a10bd --- /dev/null +++ b/src/test/ui/check-cfg/mix.rs @@ -0,0 +1,50 @@ +// This test checks the combination of well known names, their activation via names(), the usage of +// partial values() with a --cfg and test that we also correctly lint on the `cfg!` macro and +// `cfg_attr` attribute. +// +// check-pass +// compile-flags: --check-cfg=names() --check-cfg=values(feature,"foo") --cfg feature="bar" -Z unstable-options + +#[cfg(windows)] +fn do_windows_stuff() {} + +#[cfg(widnows)] +//~^ WARNING unexpected `cfg` condition name +fn do_windows_stuff() {} + +#[cfg(feature = "foo")] +fn use_foo() {} + +#[cfg(feature = "bar")] +fn use_bar() {} + +#[cfg(feature = "zebra")] +//~^ WARNING unexpected `cfg` condition value +fn use_zebra() {} + +#[cfg_attr(uu, test)] +//~^ WARNING unexpected `cfg` condition name +fn do_test() {} + +#[cfg_attr(feature = "foo", no_mangle)] +fn do_test_foo() {} + +fn test_cfg_macro() { + cfg!(windows); + cfg!(widnows); + //~^ WARNING unexpected `cfg` condition name + cfg!(feature = "foo"); + cfg!(feature = "bar"); + cfg!(feature = "zebra"); + //~^ WARNING unexpected `cfg` condition value + cfg!(xxx = "foo"); + //~^ WARNING unexpected `cfg` condition name + cfg!(xxx); + //~^ WARNING unexpected `cfg` condition name + cfg!(any(xxx, windows)); + //~^ WARNING unexpected `cfg` condition name + cfg!(any(feature = "bad", windows)); + //~^ WARNING unexpected `cfg` condition value +} + +fn main() {} diff --git a/src/test/ui/check-cfg/mix.stderr b/src/test/ui/check-cfg/mix.stderr new file mode 100644 index 0000000000000..b273be774224d --- /dev/null +++ b/src/test/ui/check-cfg/mix.stderr @@ -0,0 +1,66 @@ +warning: unexpected `cfg` condition name + --> $DIR/mix.rs:11:7 + | +LL | #[cfg(widnows)] + | ^^^^^^^ help: did you mean: `windows` + | + = note: `#[warn(unexpected_cfgs)]` on by default + +warning: unexpected `cfg` condition value + --> $DIR/mix.rs:21:7 + | +LL | #[cfg(feature = "zebra")] + | ^^^^^^^^^^^^^^^^^ + | + = note: expected values for `feature` are: bar, foo + +warning: unexpected `cfg` condition name + --> $DIR/mix.rs:25:12 + | +LL | #[cfg_attr(uu, test)] + | ^^ + +warning: unexpected `cfg` condition name + --> $DIR/mix.rs:34:10 + | +LL | cfg!(widnows); + | ^^^^^^^ help: did you mean: `windows` + +warning: unexpected `cfg` condition value + --> $DIR/mix.rs:38:10 + | +LL | cfg!(feature = "zebra"); + | ^^^^^^^^^^^^^^^^^ + | + = note: expected values for `feature` are: bar, foo + +warning: unexpected `cfg` condition name + --> $DIR/mix.rs:40:10 + | +LL | cfg!(xxx = "foo"); + | ^^^^^^^^^^^ + +warning: unexpected `cfg` condition name + --> $DIR/mix.rs:42:10 + | +LL | cfg!(xxx); + | ^^^ + +warning: unexpected `cfg` condition name + --> $DIR/mix.rs:44:14 + | +LL | cfg!(any(xxx, windows)); + | ^^^ + +warning: unexpected `cfg` condition value + --> $DIR/mix.rs:46:14 + | +LL | cfg!(any(feature = "bad", windows)); + | ^^^^^^^^^^----- + | | + | help: did you mean: `"bar"` + | + = note: expected values for `feature` are: bar, foo + +warning: 9 warnings emitted + diff --git a/src/test/ui/check-cfg/no-values.rs b/src/test/ui/check-cfg/no-values.rs new file mode 100644 index 0000000000000..2440757e52da9 --- /dev/null +++ b/src/test/ui/check-cfg/no-values.rs @@ -0,0 +1,10 @@ +// Check that we detect unexpected value when none are allowed +// +// check-pass +// compile-flags: --check-cfg=values(feature) -Z unstable-options + +#[cfg(feature = "foo")] +//~^ WARNING unexpected `cfg` condition value +fn do_foo() {} + +fn main() {} diff --git a/src/test/ui/check-cfg/no-values.stderr b/src/test/ui/check-cfg/no-values.stderr new file mode 100644 index 0000000000000..ea1c9107d4c2f --- /dev/null +++ b/src/test/ui/check-cfg/no-values.stderr @@ -0,0 +1,11 @@ +warning: unexpected `cfg` condition value + --> $DIR/no-values.rs:6:7 + | +LL | #[cfg(feature = "foo")] + | ^^^^^^^^^^^^^^^ + | + = note: `#[warn(unexpected_cfgs)]` on by default + = note: no expected value for `feature` + +warning: 1 warning emitted + diff --git a/src/test/ui/check-cfg/well-known-names.rs b/src/test/ui/check-cfg/well-known-names.rs new file mode 100644 index 0000000000000..a66568a2ffdc9 --- /dev/null +++ b/src/test/ui/check-cfg/well-known-names.rs @@ -0,0 +1,27 @@ +// This test checks that we lint on non well known names and that we don't lint on well known names +// +// check-pass +// compile-flags: --check-cfg=names() -Z unstable-options + +#[cfg(target_oz = "linux")] +//~^ WARNING unexpected `cfg` condition name +fn target_os_misspell() {} + +#[cfg(target_os = "linux")] +fn target_os() {} + +#[cfg(features = "foo")] +//~^ WARNING unexpected `cfg` condition name +fn feature_misspell() {} + +#[cfg(feature = "foo")] +fn feature() {} + +#[cfg(uniw)] +//~^ WARNING unexpected `cfg` condition name +fn unix_misspell() {} + +#[cfg(unix)] +fn unix() {} + +fn main() {} diff --git a/src/test/ui/check-cfg/well-known-names.stderr b/src/test/ui/check-cfg/well-known-names.stderr new file mode 100644 index 0000000000000..bdbe4d29d30fe --- /dev/null +++ b/src/test/ui/check-cfg/well-known-names.stderr @@ -0,0 +1,26 @@ +warning: unexpected `cfg` condition name + --> $DIR/well-known-names.rs:6:7 + | +LL | #[cfg(target_oz = "linux")] + | ---------^^^^^^^^^^ + | | + | help: did you mean: `target_os` + | + = note: `#[warn(unexpected_cfgs)]` on by default + +warning: unexpected `cfg` condition name + --> $DIR/well-known-names.rs:13:7 + | +LL | #[cfg(features = "foo")] + | --------^^^^^^^^ + | | + | help: did you mean: `feature` + +warning: unexpected `cfg` condition name + --> $DIR/well-known-names.rs:20:7 + | +LL | #[cfg(uniw)] + | ^^^^ help: did you mean: `unix` + +warning: 3 warnings emitted + diff --git a/src/test/ui/debuginfo-emit-llvm-ir-and-split-debuginfo.rs b/src/test/ui/debuginfo/debuginfo-emit-llvm-ir-and-split-debuginfo.rs similarity index 100% rename from src/test/ui/debuginfo-emit-llvm-ir-and-split-debuginfo.rs rename to src/test/ui/debuginfo/debuginfo-emit-llvm-ir-and-split-debuginfo.rs diff --git a/src/test/ui/debuginfo/debuginfo_with_uninhabitable_field_and_unsized.rs b/src/test/ui/debuginfo/debuginfo_with_uninhabitable_field_and_unsized.rs new file mode 100644 index 0000000000000..833a4726acb0f --- /dev/null +++ b/src/test/ui/debuginfo/debuginfo_with_uninhabitable_field_and_unsized.rs @@ -0,0 +1,29 @@ +// check-pass +// compile-flags: -Cdebuginfo=2 +// fixes issue #94149 + +#![allow(dead_code)] + +pub fn main() { + let _ = Foo::::new(); +} + +pub struct Foo { + base: FooBase, + value: T, +} + +impl Foo { + pub fn new() -> Box> { + todo!() + } +} + +pub trait FooTrait {} + +pub struct FooBase { + cls: Bar, +} + +// Bar *must* be a fieldless enum +pub enum Bar {} diff --git a/src/test/ui/error-codes/E0261.stderr b/src/test/ui/error-codes/E0261.stderr index 33d74feead513..0eab2dc0ee05f 100644 --- a/src/test/ui/error-codes/E0261.stderr +++ b/src/test/ui/error-codes/E0261.stderr @@ -5,8 +5,6 @@ LL | fn foo(x: &'a str) { } | - ^^ undeclared lifetime | | | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/E0261.rs:5:9 @@ -15,8 +13,6 @@ LL | struct Foo { | - help: consider introducing lifetime `'a` here: `<'a>` LL | x: &'a str, | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error: aborting due to 2 previous errors diff --git a/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.rs b/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.rs deleted file mode 100644 index 0e5f968892f33..0000000000000 --- a/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.rs +++ /dev/null @@ -1,62 +0,0 @@ -#![allow(warnings)] - -fn foo(x: &'x u8) -> &'x u8 { x } -//~^ ERROR use of undeclared lifetime name -//~^^ ERROR use of undeclared lifetime name - -struct X<'a>(&'a u8); - -impl<'a> X<'a> { - fn inner(&self) -> &'a u8 { - self.0 - } -} - -impl<'a> X<'b> { -//~^ ERROR use of undeclared lifetime name - fn inner_2(&self) -> &'b u8 { - //~^ ERROR use of undeclared lifetime name - self.0 - } -} - -impl X<'b> { -//~^ ERROR use of undeclared lifetime name - fn inner_3(&self) -> &'b u8 { - //~^ ERROR use of undeclared lifetime name - self.0 - } -} - -struct Y(T); - -impl Y<&'a u8> { - //~^ ERROR use of undeclared lifetime name - fn inner(&self) -> &'a u8 { - //~^ ERROR use of undeclared lifetime name - self.0 - } -} - -trait MyTrait<'a> { - fn my_lifetime(&self) -> &'a u8; - fn any_lifetime() -> &'b u8; - //~^ ERROR use of undeclared lifetime name - fn borrowed_lifetime(&'b self) -> &'b u8; - //~^ ERROR use of undeclared lifetime name - //~^^ ERROR use of undeclared lifetime name -} - -impl MyTrait<'a> for Y<&'a u8> { -//~^ ERROR use of undeclared lifetime name -//~^^ ERROR use of undeclared lifetime name - fn my_lifetime(&self) -> &'a u8 { self.0 } - //~^ ERROR use of undeclared lifetime name - fn any_lifetime() -> &'b u8 { &0 } - //~^ ERROR use of undeclared lifetime name - fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 } - //~^ ERROR use of undeclared lifetime name - //~^^ ERROR use of undeclared lifetime name -} - -fn main() {} diff --git a/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.stderr b/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.stderr deleted file mode 100644 index 41fb1456f869e..0000000000000 --- a/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.stderr +++ /dev/null @@ -1,231 +0,0 @@ -error[E0261]: use of undeclared lifetime name `'x` - --> $DIR/feature-gate-in_band_lifetimes.rs:3:12 - | -LL | fn foo(x: &'x u8) -> &'x u8 { x } - | - ^^ undeclared lifetime - | | - | help: consider introducing lifetime `'x` here: `<'x>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes - -error[E0261]: use of undeclared lifetime name `'x` - --> $DIR/feature-gate-in_band_lifetimes.rs:3:23 - | -LL | fn foo(x: &'x u8) -> &'x u8 { x } - | - ^^ undeclared lifetime - | | - | help: consider introducing lifetime `'x` here: `<'x>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:15:12 - | -LL | impl<'a> X<'b> { - | - ^^ undeclared lifetime - | | - | help: consider introducing lifetime `'b` here: `'b,` - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:17:27 - | -LL | fn inner_2(&self) -> &'b u8 { - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'b` here - | -LL | impl<'b, 'a> X<'b> { - | +++ -help: consider introducing lifetime `'b` here - | -LL | fn inner_2<'b>(&self) -> &'b u8 { - | ++++ - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:23:8 - | -LL | impl X<'b> { - | - ^^ undeclared lifetime - | | - | help: consider introducing lifetime `'b` here: `<'b>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:25:27 - | -LL | fn inner_3(&self) -> &'b u8 { - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'b` here - | -LL | impl<'b> X<'b> { - | ++++ -help: consider introducing lifetime `'b` here - | -LL | fn inner_3<'b>(&self) -> &'b u8 { - | ++++ - -error[E0261]: use of undeclared lifetime name `'a` - --> $DIR/feature-gate-in_band_lifetimes.rs:33:9 - | -LL | impl Y<&'a u8> { - | - ^^ undeclared lifetime - | | - | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes - -error[E0261]: use of undeclared lifetime name `'a` - --> $DIR/feature-gate-in_band_lifetimes.rs:35:25 - | -LL | fn inner(&self) -> &'a u8 { - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'a` here - | -LL | impl<'a> Y<&'a u8> { - | ++++ -help: consider introducing lifetime `'a` here - | -LL | fn inner<'a>(&self) -> &'a u8 { - | ++++ - -error[E0261]: use of undeclared lifetime name `'a` - --> $DIR/feature-gate-in_band_lifetimes.rs:50:14 - | -LL | impl MyTrait<'a> for Y<&'a u8> { - | - ^^ undeclared lifetime - | | - | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes - -error[E0261]: use of undeclared lifetime name `'a` - --> $DIR/feature-gate-in_band_lifetimes.rs:50:25 - | -LL | impl MyTrait<'a> for Y<&'a u8> { - | - ^^ undeclared lifetime - | | - | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes - -error[E0261]: use of undeclared lifetime name `'a` - --> $DIR/feature-gate-in_band_lifetimes.rs:53:31 - | -LL | fn my_lifetime(&self) -> &'a u8 { self.0 } - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'a` here - | -LL | impl<'a> MyTrait<'a> for Y<&'a u8> { - | ++++ -help: consider introducing lifetime `'a` here - | -LL | fn my_lifetime<'a>(&self) -> &'a u8 { self.0 } - | ++++ - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:55:27 - | -LL | fn any_lifetime() -> &'b u8 { &0 } - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'b` here - | -LL | impl<'b> MyTrait<'a> for Y<&'a u8> { - | ++++ -help: consider introducing lifetime `'b` here - | -LL | fn any_lifetime<'b>() -> &'b u8 { &0 } - | ++++ - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:57:27 - | -LL | fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 } - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'b` here - | -LL | impl<'b> MyTrait<'a> for Y<&'a u8> { - | ++++ -help: consider introducing lifetime `'b` here - | -LL | fn borrowed_lifetime<'b>(&'b self) -> &'b u8 { &*self.0 } - | ++++ - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:57:40 - | -LL | fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 } - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'b` here - | -LL | impl<'b> MyTrait<'a> for Y<&'a u8> { - | ++++ -help: consider introducing lifetime `'b` here - | -LL | fn borrowed_lifetime<'b>(&'b self) -> &'b u8 { &*self.0 } - | ++++ - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:43:27 - | -LL | fn any_lifetime() -> &'b u8; - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'b` here - | -LL | trait MyTrait<'b, 'a> { - | +++ -help: consider introducing lifetime `'b` here - | -LL | fn any_lifetime<'b>() -> &'b u8; - | ++++ - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:45:27 - | -LL | fn borrowed_lifetime(&'b self) -> &'b u8; - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'b` here - | -LL | trait MyTrait<'b, 'a> { - | +++ -help: consider introducing lifetime `'b` here - | -LL | fn borrowed_lifetime<'b>(&'b self) -> &'b u8; - | ++++ - -error[E0261]: use of undeclared lifetime name `'b` - --> $DIR/feature-gate-in_band_lifetimes.rs:45:40 - | -LL | fn borrowed_lifetime(&'b self) -> &'b u8; - | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes -help: consider introducing lifetime `'b` here - | -LL | trait MyTrait<'b, 'a> { - | +++ -help: consider introducing lifetime `'b` here - | -LL | fn borrowed_lifetime<'b>(&'b self) -> &'b u8; - | ++++ - -error: aborting due to 17 previous errors - -For more information about this error, try `rustc --explain E0261`. diff --git a/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.stderr b/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.stderr index ce9df46483d13..317897ae70f72 100644 --- a/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.stderr +++ b/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.stderr @@ -5,8 +5,6 @@ LL | fn _f(arg : Box X = &'a [u32]>>) {} | - ^^ undeclared lifetime | | | help: consider introducing lifetime `'x` here: `<'x>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0582]: binding for associated type `Y` references lifetime `'a`, which does not appear in the trait input types --> $DIR/gat-in-trait-path-undeclared-lifetime.rs:8:33 diff --git a/src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr b/src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr index adbd47ac16f45..bf0ca8715036b 100644 --- a/src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr +++ b/src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr @@ -4,7 +4,6 @@ error[E0261]: use of undeclared lifetime name `'b` LL | + Deref>; | ^^ undeclared lifetime | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'b` here | LL | trait Iterable<'b> { @@ -20,7 +19,6 @@ error[E0261]: use of undeclared lifetime name `'undeclared` LL | fn iter<'a>(&'a self) -> Self::Iter<'undeclared>; | ^^^^^^^^^^^ undeclared lifetime | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'undeclared` here | LL | trait Iterable<'undeclared> { diff --git a/src/test/ui/generic-associated-types/issue-67510.stderr b/src/test/ui/generic-associated-types/issue-67510.stderr index 8ed2854ed3057..abc02b33e0e6a 100644 --- a/src/test/ui/generic-associated-types/issue-67510.stderr +++ b/src/test/ui/generic-associated-types/issue-67510.stderr @@ -5,8 +5,6 @@ LL | fn f(x: Box=&'a ()>>) {} | - ^^ undeclared lifetime | | | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/issue-67510.rs:7:26 @@ -15,8 +13,6 @@ LL | fn f(x: Box=&'a ()>>) {} | - ^^ undeclared lifetime | | | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error: aborting due to 2 previous errors diff --git a/src/test/ui/impl-trait/region-escape-via-bound-contravariant-closure.rs b/src/test/ui/impl-trait/region-escape-via-bound-contravariant-closure.rs index adaa474474f67..9f63a8617babd 100644 --- a/src/test/ui/impl-trait/region-escape-via-bound-contravariant-closure.rs +++ b/src/test/ui/impl-trait/region-escape-via-bound-contravariant-closure.rs @@ -8,9 +8,8 @@ // run-pass #![allow(dead_code)] -#![feature(in_band_lifetimes)] -fn foo(x: &'x u32) -> impl Fn() -> &'y u32 +fn foo<'x, 'y>(x: &'x u32) -> impl Fn() -> &'y u32 where 'x: 'y { move || x diff --git a/src/test/ui/impl-trait/region-escape-via-bound-contravariant.rs b/src/test/ui/impl-trait/region-escape-via-bound-contravariant.rs index 204c2ff304114..79319dfe796a2 100644 --- a/src/test/ui/impl-trait/region-escape-via-bound-contravariant.rs +++ b/src/test/ui/impl-trait/region-escape-via-bound-contravariant.rs @@ -8,13 +8,12 @@ // run-pass #![allow(dead_code)] -#![feature(in_band_lifetimes)] trait Trait<'a> { } -impl Trait<'b> for &'a u32 { } +impl<'a, 'b> Trait<'b> for &'a u32 { } -fn foo(x: &'x u32) -> impl Trait<'y> +fn foo<'x, 'y>(x: &'x u32) -> impl Trait<'y> where 'x: 'y { x diff --git a/src/test/ui/impl-trait/region-escape-via-bound.rs b/src/test/ui/impl-trait/region-escape-via-bound.rs index 29243699e44fd..e834f96dbbeeb 100644 --- a/src/test/ui/impl-trait/region-escape-via-bound.rs +++ b/src/test/ui/impl-trait/region-escape-via-bound.rs @@ -4,15 +4,14 @@ // See https://github.com/rust-lang/rust/issues/46541 for more details. #![allow(dead_code)] -#![feature(in_band_lifetimes)] use std::cell::Cell; trait Trait<'a> { } -impl Trait<'b> for Cell<&'a u32> { } +impl<'a, 'b> Trait<'b> for Cell<&'a u32> { } -fn foo(x: Cell<&'x u32>) -> impl Trait<'y> +fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> //~^ ERROR hidden type for `impl Trait` captures lifetime that does not appear in bounds [E0700] where 'x: 'y { diff --git a/src/test/ui/impl-trait/region-escape-via-bound.stderr b/src/test/ui/impl-trait/region-escape-via-bound.stderr index cf854f67d0456..ecec34e0115c6 100644 --- a/src/test/ui/impl-trait/region-escape-via-bound.stderr +++ b/src/test/ui/impl-trait/region-escape-via-bound.stderr @@ -1,16 +1,15 @@ error[E0700]: hidden type for `impl Trait` captures lifetime that does not appear in bounds - --> $DIR/region-escape-via-bound.rs:15:29 + --> $DIR/region-escape-via-bound.rs:14:37 | -LL | fn foo(x: Cell<&'x u32>) -> impl Trait<'y> - | ^^^^^^^^^^^^^^ -LL | -LL | where 'x: 'y - | -- hidden type `Cell<&'x u32>` captures the lifetime `'x` as defined here +LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + | -- ^^^^^^^^^^^^^^ + | | + | hidden type `Cell<&'x u32>` captures the lifetime `'x` as defined here | help: to declare that the `impl Trait` captures `'x`, you can add an explicit `'x` lifetime bound | -LL | fn foo(x: Cell<&'x u32>) -> impl Trait<'y> + 'x - | ++++ +LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + 'x + | ++++ error: aborting due to previous error diff --git a/src/test/ui/in-band-lifetimes/E0687.rs b/src/test/ui/in-band-lifetimes/E0687.rs deleted file mode 100644 index 2e262ddaea3f4..0000000000000 --- a/src/test/ui/in-band-lifetimes/E0687.rs +++ /dev/null @@ -1,16 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -fn foo(x: fn(&'a u32)) {} //~ ERROR must be explicitly - -fn bar(x: &Fn(&'a u32)) {} //~ ERROR must be explicitly - -fn baz(x: fn(&'a u32), y: &'a u32) {} //~ ERROR must be explicitly - -struct Foo<'a> { x: &'a u32 } - -impl Foo<'a> { - fn bar(&self, x: fn(&'a u32)) {} //~ ERROR must be explicitly -} - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/E0687.stderr b/src/test/ui/in-band-lifetimes/E0687.stderr deleted file mode 100644 index 7aea2f220466c..0000000000000 --- a/src/test/ui/in-band-lifetimes/E0687.stderr +++ /dev/null @@ -1,27 +0,0 @@ -error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders - --> $DIR/E0687.rs:4:15 - | -LL | fn foo(x: fn(&'a u32)) {} - | ^^ in-band lifetime definition - -error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders - --> $DIR/E0687.rs:6:16 - | -LL | fn bar(x: &Fn(&'a u32)) {} - | ^^ in-band lifetime definition - -error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders - --> $DIR/E0687.rs:8:15 - | -LL | fn baz(x: fn(&'a u32), y: &'a u32) {} - | ^^ in-band lifetime definition - -error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders - --> $DIR/E0687.rs:13:26 - | -LL | fn bar(&self, x: fn(&'a u32)) {} - | ^^ in-band lifetime definition - -error: aborting due to 4 previous errors - -For more information about this error, try `rustc --explain E0687`. diff --git a/src/test/ui/in-band-lifetimes/E0687_where.rs b/src/test/ui/in-band-lifetimes/E0687_where.rs deleted file mode 100644 index 6cf8053287d8f..0000000000000 --- a/src/test/ui/in-band-lifetimes/E0687_where.rs +++ /dev/null @@ -1,8 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -fn bar(x: &F) where F: Fn(&'a u32) {} //~ ERROR must be explicitly - -fn baz(x: &impl Fn(&'a u32)) {} //~ ERROR must be explicitly - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/E0687_where.stderr b/src/test/ui/in-band-lifetimes/E0687_where.stderr deleted file mode 100644 index af0f9665f5d06..0000000000000 --- a/src/test/ui/in-band-lifetimes/E0687_where.stderr +++ /dev/null @@ -1,15 +0,0 @@ -error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders - --> $DIR/E0687_where.rs:4:31 - | -LL | fn bar(x: &F) where F: Fn(&'a u32) {} - | ^^ in-band lifetime definition - -error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders - --> $DIR/E0687_where.rs:6:21 - | -LL | fn baz(x: &impl Fn(&'a u32)) {} - | ^^ in-band lifetime definition - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0687`. diff --git a/src/test/ui/in-band-lifetimes/E0688.rs b/src/test/ui/in-band-lifetimes/E0688.rs deleted file mode 100644 index a4e1f01c1781a..0000000000000 --- a/src/test/ui/in-band-lifetimes/E0688.rs +++ /dev/null @@ -1,16 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -fn foo<'a>(x: &'a u32, y: &'b u32) {} //~ ERROR cannot mix - -struct Foo<'a> { x: &'a u32 } - -impl Foo<'a> { - fn bar<'b>(x: &'a u32, y: &'b u32, z: &'c u32) {} //~ ERROR cannot mix -} - -impl<'b> Foo<'a> { //~ ERROR cannot mix - fn baz() {} -} - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/E0688.stderr b/src/test/ui/in-band-lifetimes/E0688.stderr deleted file mode 100644 index afefcd9fc2c66..0000000000000 --- a/src/test/ui/in-band-lifetimes/E0688.stderr +++ /dev/null @@ -1,27 +0,0 @@ -error[E0688]: cannot mix in-band and explicit lifetime definitions - --> $DIR/E0688.rs:4:28 - | -LL | fn foo<'a>(x: &'a u32, y: &'b u32) {} - | -- ^^ in-band lifetime definition here - | | - | explicit lifetime definition here - -error[E0688]: cannot mix in-band and explicit lifetime definitions - --> $DIR/E0688.rs:9:44 - | -LL | fn bar<'b>(x: &'a u32, y: &'b u32, z: &'c u32) {} - | -- ^^ in-band lifetime definition here - | | - | explicit lifetime definition here - -error[E0688]: cannot mix in-band and explicit lifetime definitions - --> $DIR/E0688.rs:12:14 - | -LL | impl<'b> Foo<'a> { - | -- ^^ in-band lifetime definition here - | | - | explicit lifetime definition here - -error: aborting due to 3 previous errors - -For more information about this error, try `rustc --explain E0688`. diff --git a/src/test/ui/in-band-lifetimes/elided-lifetimes.fixed b/src/test/ui/in-band-lifetimes/elided-lifetimes.fixed deleted file mode 100644 index 87a79b8813777..0000000000000 --- a/src/test/ui/in-band-lifetimes/elided-lifetimes.fixed +++ /dev/null @@ -1,119 +0,0 @@ -// run-rustfix -// edition:2018 - -#![allow(unused)] -#![deny(elided_lifetimes_in_paths)] -//~^ NOTE the lint level is defined here - -use std::cell::{Ref, RefCell}; - -struct Foo<'a> { - x: &'a u32, -} - -fn foo(x: &Foo<'_>) { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime -} - -fn bar(x: &Foo<'_>) {} - -struct Wrapped<'a>(&'a str); - -struct WrappedWithBow<'a> { - gift: &'a str, -} - -struct MatchedSet<'a, 'b> { - one: &'a str, - another: &'b str, -} - -fn wrap_gift(gift: &str) -> Wrapped<'_> { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - Wrapped(gift) -} - -fn wrap_gift_with_bow(gift: &str) -> WrappedWithBow<'_> { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - WrappedWithBow { gift } -} - -fn inspect_matched_set(set: MatchedSet<'_, '_>) { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected 2 lifetime parameters - //~| HELP consider using the `'_` lifetime - println!("{} {}", set.one, set.another); -} - -// Verify that the lint does not fire, because the added `'_` wouldn't be resolved correctly. -fn match_sets() -> MatchedSet<'static, 'static> { - //~^ ERROR missing lifetime specifiers - //~| NOTE expected 2 lifetime parameters - //~| HELP this function's return type contains a borrowed value - //~| HELP consider using the `'static` lifetime - MatchedSet { one: "one", another: "another" } -} - -macro_rules! autowrapper { - ($type_name:ident, $fn_name:ident, $lt:lifetime) => { - struct $type_name<$lt> { - gift: &$lt str - } - - fn $fn_name(gift: &str) -> $type_name<'_> { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - //~| ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - $type_name { gift } - } - } -} - -autowrapper!(Autowrapped, autowrap_gift, 'a); -//~^ NOTE in this expansion of autowrapper! -//~| NOTE in this expansion of autowrapper! - -// Verify that rustfix does not try to apply the fix twice. -autowrapper!(AutowrappedAgain, autowrap_gift_again, 'a); -//~^ NOTE in this expansion of autowrapper! -//~| NOTE in this expansion of autowrapper! - -macro_rules! anytuple_ref_ty { - ($($types:ty),*) => { - Ref<'_, ($($types),*)> - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - } -} - -#[allow(elided_lifetimes_in_paths)] -mod blah { - struct Thing<'a>(&'a i32); - struct Bar(T); - - fn foo(b: Bar) {} -} - -fn main() { - let honesty = RefCell::new((4, 'e')); - let loyalty: Ref<'_, (u32, char)> = honesty.borrow(); - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - let generosity = Ref::map(loyalty, |t| &t.0); - - let laughter = RefCell::new((true, "magic")); - let yellow: anytuple_ref_ty!(bool, &str) = laughter.borrow(); - //~^ NOTE in this expansion of anytuple_ref_ty! - //~| NOTE in this expansion of anytuple_ref_ty! -} diff --git a/src/test/ui/in-band-lifetimes/elided-lifetimes.rs b/src/test/ui/in-band-lifetimes/elided-lifetimes.rs deleted file mode 100644 index 28323a22427b6..0000000000000 --- a/src/test/ui/in-band-lifetimes/elided-lifetimes.rs +++ /dev/null @@ -1,119 +0,0 @@ -// run-rustfix -// edition:2018 - -#![allow(unused)] -#![deny(elided_lifetimes_in_paths)] -//~^ NOTE the lint level is defined here - -use std::cell::{Ref, RefCell}; - -struct Foo<'a> { - x: &'a u32, -} - -fn foo(x: &Foo) { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime -} - -fn bar(x: &Foo<'_>) {} - -struct Wrapped<'a>(&'a str); - -struct WrappedWithBow<'a> { - gift: &'a str, -} - -struct MatchedSet<'a, 'b> { - one: &'a str, - another: &'b str, -} - -fn wrap_gift(gift: &str) -> Wrapped { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - Wrapped(gift) -} - -fn wrap_gift_with_bow(gift: &str) -> WrappedWithBow { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - WrappedWithBow { gift } -} - -fn inspect_matched_set(set: MatchedSet) { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected 2 lifetime parameters - //~| HELP consider using the `'_` lifetime - println!("{} {}", set.one, set.another); -} - -// Verify that the lint does not fire, because the added `'_` wouldn't be resolved correctly. -fn match_sets() -> MatchedSet { - //~^ ERROR missing lifetime specifiers - //~| NOTE expected 2 lifetime parameters - //~| HELP this function's return type contains a borrowed value - //~| HELP consider using the `'static` lifetime - MatchedSet { one: "one", another: "another" } -} - -macro_rules! autowrapper { - ($type_name:ident, $fn_name:ident, $lt:lifetime) => { - struct $type_name<$lt> { - gift: &$lt str - } - - fn $fn_name(gift: &str) -> $type_name { - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - //~| ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - $type_name { gift } - } - } -} - -autowrapper!(Autowrapped, autowrap_gift, 'a); -//~^ NOTE in this expansion of autowrapper! -//~| NOTE in this expansion of autowrapper! - -// Verify that rustfix does not try to apply the fix twice. -autowrapper!(AutowrappedAgain, autowrap_gift_again, 'a); -//~^ NOTE in this expansion of autowrapper! -//~| NOTE in this expansion of autowrapper! - -macro_rules! anytuple_ref_ty { - ($($types:ty),*) => { - Ref<($($types),*)> - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - } -} - -#[allow(elided_lifetimes_in_paths)] -mod blah { - struct Thing<'a>(&'a i32); - struct Bar(T); - - fn foo(b: Bar) {} -} - -fn main() { - let honesty = RefCell::new((4, 'e')); - let loyalty: Ref<(u32, char)> = honesty.borrow(); - //~^ ERROR hidden lifetime parameters in types are deprecated - //~| NOTE expected named lifetime parameter - //~| HELP consider using the `'_` lifetime - let generosity = Ref::map(loyalty, |t| &t.0); - - let laughter = RefCell::new((true, "magic")); - let yellow: anytuple_ref_ty!(bool, &str) = laughter.borrow(); - //~^ NOTE in this expansion of anytuple_ref_ty! - //~| NOTE in this expansion of anytuple_ref_ty! -} diff --git a/src/test/ui/in-band-lifetimes/elided-lifetimes.stderr b/src/test/ui/in-band-lifetimes/elided-lifetimes.stderr deleted file mode 100644 index 2e65461b321e9..0000000000000 --- a/src/test/ui/in-band-lifetimes/elided-lifetimes.stderr +++ /dev/null @@ -1,120 +0,0 @@ -error: hidden lifetime parameters in types are deprecated - --> $DIR/elided-lifetimes.rs:14:12 - | -LL | fn foo(x: &Foo) { - | ^^^ expected named lifetime parameter - | -note: the lint level is defined here - --> $DIR/elided-lifetimes.rs:5:9 - | -LL | #![deny(elided_lifetimes_in_paths)] - | ^^^^^^^^^^^^^^^^^^^^^^^^^ -help: consider using the `'_` lifetime - | -LL | fn foo(x: &Foo<'_>) { - | ~~~~~~~ - -error: hidden lifetime parameters in types are deprecated - --> $DIR/elided-lifetimes.rs:33:29 - | -LL | fn wrap_gift(gift: &str) -> Wrapped { - | ^^^^^^^ expected named lifetime parameter - | -help: consider using the `'_` lifetime - | -LL | fn wrap_gift(gift: &str) -> Wrapped<'_> { - | ~~~~~~~~~~~ - -error: hidden lifetime parameters in types are deprecated - --> $DIR/elided-lifetimes.rs:40:38 - | -LL | fn wrap_gift_with_bow(gift: &str) -> WrappedWithBow { - | ^^^^^^^^^^^^^^ expected named lifetime parameter - | -help: consider using the `'_` lifetime - | -LL | fn wrap_gift_with_bow(gift: &str) -> WrappedWithBow<'_> { - | ~~~~~~~~~~~~~~~~~~ - -error: hidden lifetime parameters in types are deprecated - --> $DIR/elided-lifetimes.rs:47:29 - | -LL | fn inspect_matched_set(set: MatchedSet) { - | ^^^^^^^^^^ expected 2 lifetime parameters - | -help: consider using the `'_` lifetime - | -LL | fn inspect_matched_set(set: MatchedSet<'_, '_>) { - | ~~~~~~~~~~~~~~~~~~ - -error[E0106]: missing lifetime specifiers - --> $DIR/elided-lifetimes.rs:55:20 - | -LL | fn match_sets() -> MatchedSet { - | ^^^^^^^^^^ expected 2 lifetime parameters - | - = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from -help: consider using the `'static` lifetime - | -LL | fn match_sets() -> MatchedSet<'static, 'static> { - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -error: hidden lifetime parameters in types are deprecated - --> $DIR/elided-lifetimes.rs:69:36 - | -LL | fn $fn_name(gift: &str) -> $type_name { - | ^^^^^^^^^^ expected named lifetime parameter -... -LL | autowrapper!(Autowrapped, autowrap_gift, 'a); - | -------------------------------------------- in this macro invocation - | - = note: this error originates in the macro `autowrapper` (in Nightly builds, run with -Z macro-backtrace for more info) -help: consider using the `'_` lifetime - | -LL | fn $fn_name(gift: &str) -> $type_name<'_> { - | ~~~~~~~~~~~~~~ - -error: hidden lifetime parameters in types are deprecated - --> $DIR/elided-lifetimes.rs:69:36 - | -LL | fn $fn_name(gift: &str) -> $type_name { - | ^^^^^^^^^^ expected named lifetime parameter -... -LL | autowrapper!(AutowrappedAgain, autowrap_gift_again, 'a); - | ------------------------------------------------------- in this macro invocation - | - = note: this error originates in the macro `autowrapper` (in Nightly builds, run with -Z macro-backtrace for more info) -help: consider using the `'_` lifetime - | -LL | fn $fn_name(gift: &str) -> $type_name<'_> { - | ~~~~~~~~~~~~~~ - -error: hidden lifetime parameters in types are deprecated - --> $DIR/elided-lifetimes.rs:109:22 - | -LL | let loyalty: Ref<(u32, char)> = honesty.borrow(); - | ^ expected named lifetime parameter - | -help: consider using the `'_` lifetime - | -LL | let loyalty: Ref<'_, (u32, char)> = honesty.borrow(); - | +++ - -error: hidden lifetime parameters in types are deprecated - --> $DIR/elided-lifetimes.rs:92:13 - | -LL | Ref<($($types),*)> - | ^ expected named lifetime parameter -... -LL | let yellow: anytuple_ref_ty!(bool, &str) = laughter.borrow(); - | ---------------------------- in this macro invocation - | - = note: this error originates in the macro `anytuple_ref_ty` (in Nightly builds, run with -Z macro-backtrace for more info) -help: consider using the `'_` lifetime - | -LL | Ref<'_, ($($types),*)> - | +++ - -error: aborting due to 9 previous errors - -For more information about this error, try `rustc --explain E0106`. diff --git a/src/test/ui/in-band-lifetimes/in-band-lifetimes.rs b/src/test/ui/in-band-lifetimes/in-band-lifetimes.rs deleted file mode 100644 index 9b2e1fe83c1cc..0000000000000 --- a/src/test/ui/in-band-lifetimes/in-band-lifetimes.rs +++ /dev/null @@ -1,96 +0,0 @@ -// run-pass - -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -fn foo(x: &'x u8) -> &'x u8 { x } -fn foo2(x: &'a u8, y: &u8) -> &'a u8 { x } - -fn check_in_band_can_be_late_bound() { - let _: for<'x> fn(&'x u8, &u8) -> &'x u8 = foo2; -} - -struct ForInherentNoParams; - -impl ForInherentNoParams { - fn foo(x: &'a u32, y: &u32) -> &'a u32 { x } -} - -struct X<'a>(&'a u8); - -impl<'a> X<'a> { - fn inner(&self) -> &'a u8 { - self.0 - } - - fn same_lifetime_as_parameter(&mut self, x: &'a u8) { - self.0 = x; - } -} - -impl X<'b> { - fn inner_2(&self) -> &'b u8 { - self.0 - } - - fn reference_already_introduced_in_band_from_method_with_explicit_binders<'a>( - &'b self, x: &'a u32 - ) {} -} - -struct Y(T); - -impl Y<&'a u8> { - fn inner(&self) -> &'a u8 { - self.0 - } -} - -trait MyTrait<'a> { - fn my_lifetime(&self) -> &'a u8; - fn any_lifetime() -> &'b u8; - fn borrowed_lifetime(&'b self) -> &'b u8; - fn default_impl(&self, x: &'b u32, y: &u32) -> &'b u32 { x } - fn in_band_def_explicit_impl(&self, x: &'b u8); -} - -impl MyTrait<'a> for Y<&'a u8> { - fn my_lifetime(&self) -> &'a u8 { self.0 } - fn any_lifetime() -> &'b u8 { &0 } - fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 } - fn in_band_def_explicit_impl<'b>(&self, x: &'b u8) {} -} - -fn test_hrtb_defined_lifetime_where(_: F) where for<'a> F: Fn(&'a u8) {} -fn test_hrtb_defined_lifetime_polytraitref(_: F) where F: for<'a> Fn(&'a u8) {} - -fn reference_in_band_from_locals(x: &'test u32) -> &'test u32 { - let y: &'test u32 = x; - y -} - -fn in_generics_in_band>(x: &T) {} -fn where_clause_in_band(x: &T) where T: MyTrait<'a> {} -fn impl_trait_in_band(x: &impl MyTrait<'a>) {} - -// Tests around using in-band lifetimes within existential traits. - -trait FunkyTrait<'a> { } -impl<'a, T> FunkyTrait<'a> for T { } -fn ret_pos_impl_trait_in_band_outlives(x: &'a u32) -> impl ::std::fmt::Debug + 'a { - x -} -fn ret_pos_impl_trait_in_band_param(x: &'a u32) -> impl FunkyTrait<'a> { - x -} -fn ret_pos_impl_trait_in_band_param_static(x: &'a u32) -> impl FunkyTrait<'static> + 'a { - x -} -fn ret_pos_impl_trait_in_band_param_outlives(x: &'a u32) -> impl FunkyTrait<'a> + 'a { - x -} -fn ret_pos_impl_trait_in_band_higher_ranked(x: &'a u32) -> impl for<'b> FunkyTrait<'b> + 'a { - x -} - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/issue-61124-anon-lifetime-in-struct-declaration.rs b/src/test/ui/in-band-lifetimes/issue-61124-anon-lifetime-in-struct-declaration.rs deleted file mode 100644 index cf08cb7eeacd8..0000000000000 --- a/src/test/ui/in-band-lifetimes/issue-61124-anon-lifetime-in-struct-declaration.rs +++ /dev/null @@ -1,10 +0,0 @@ -#![deny(elided_lifetimes_in_paths)] - -// Previously, the elided-lifetimes-in-path lint would fire, but we don't want -// that, because `'_` isn't legal in struct declarations. - -struct Betrayal<'a> { x: &'a u8 } - -struct Heartbreak(Betrayal); //~ ERROR missing lifetime specifier - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/issue-61124-anon-lifetime-in-struct-declaration.stderr b/src/test/ui/in-band-lifetimes/issue-61124-anon-lifetime-in-struct-declaration.stderr deleted file mode 100644 index 20369a543b3ae..0000000000000 --- a/src/test/ui/in-band-lifetimes/issue-61124-anon-lifetime-in-struct-declaration.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error[E0106]: missing lifetime specifier - --> $DIR/issue-61124-anon-lifetime-in-struct-declaration.rs:8:19 - | -LL | struct Heartbreak(Betrayal); - | ^^^^^^^^ expected named lifetime parameter - | -help: consider introducing a named lifetime parameter - | -LL | struct Heartbreak<'a>(Betrayal<'a>); - | ++++ ~~~~~~~~~~~~ - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0106`. diff --git a/src/test/ui/in-band-lifetimes/mismatched.nll.stderr b/src/test/ui/in-band-lifetimes/mismatched.nll.stderr deleted file mode 100644 index db028e63a8244..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched.nll.stderr +++ /dev/null @@ -1,22 +0,0 @@ -error[E0621]: explicit lifetime required in the type of `y` - --> $DIR/mismatched.rs:4:42 - | -LL | fn foo(x: &'a u32, y: &u32) -> &'a u32 { y } - | ---- ^ lifetime `'a` required - | | - | help: add explicit lifetime `'a` to the type of `y`: `&'a u32` - -error: lifetime may not live long enough - --> $DIR/mismatched.rs:6:46 - | -LL | fn foo2(x: &'a u32, y: &'b u32) -> &'a u32 { y } - | -- -- ^ function was supposed to return data with lifetime `'a` but it is returning data with lifetime `'b` - | | | - | | lifetime `'b` defined here - | lifetime `'a` defined here - | - = help: consider adding the following bound: `'b: 'a` - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0621`. diff --git a/src/test/ui/in-band-lifetimes/mismatched.rs b/src/test/ui/in-band-lifetimes/mismatched.rs deleted file mode 100644 index 11c41eae954d4..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched.rs +++ /dev/null @@ -1,8 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -fn foo(x: &'a u32, y: &u32) -> &'a u32 { y } //~ ERROR explicit lifetime required - -fn foo2(x: &'a u32, y: &'b u32) -> &'a u32 { y } //~ ERROR lifetime mismatch - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/mismatched.stderr b/src/test/ui/in-band-lifetimes/mismatched.stderr deleted file mode 100644 index db72c20697108..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched.stderr +++ /dev/null @@ -1,20 +0,0 @@ -error[E0621]: explicit lifetime required in the type of `y` - --> $DIR/mismatched.rs:4:42 - | -LL | fn foo(x: &'a u32, y: &u32) -> &'a u32 { y } - | ---- ^ lifetime `'a` required - | | - | help: add explicit lifetime `'a` to the type of `y`: `&'a u32` - -error[E0623]: lifetime mismatch - --> $DIR/mismatched.rs:6:46 - | -LL | fn foo2(x: &'a u32, y: &'b u32) -> &'a u32 { y } - | ------- ------- ^ ...but data from `y` is returned here - | | - | this parameter and the return type are declared with different lifetimes... - -error: aborting due to 2 previous errors - -Some errors have detailed explanations: E0621, E0623. -For more information about an error, try `rustc --explain E0621`. diff --git a/src/test/ui/in-band-lifetimes/mismatched_trait.rs b/src/test/ui/in-band-lifetimes/mismatched_trait.rs deleted file mode 100644 index 221f4fc271bbf..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched_trait.rs +++ /dev/null @@ -1,10 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -trait Get { - fn baz(&self, x: &'a u32, y: &u32) -> &'a u32 { - y //~ ERROR explicit lifetime required - } -} - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/mismatched_trait.stderr b/src/test/ui/in-band-lifetimes/mismatched_trait.stderr deleted file mode 100644 index ac66daa21c7a9..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched_trait.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error[E0621]: explicit lifetime required in the type of `y` - --> $DIR/mismatched_trait.rs:6:9 - | -LL | fn baz(&self, x: &'a u32, y: &u32) -> &'a u32 { - | ---- help: add explicit lifetime `'a` to the type of `y`: `&'a u32` -LL | y - | ^ lifetime `'a` required - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0621`. diff --git a/src/test/ui/in-band-lifetimes/mismatched_trait_impl-2.rs b/src/test/ui/in-band-lifetimes/mismatched_trait_impl-2.rs deleted file mode 100644 index 1b524ec3833e8..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched_trait_impl-2.rs +++ /dev/null @@ -1,14 +0,0 @@ -use std::ops::Deref; -trait Trait {} - -struct Struct; - -impl Deref for Struct { - type Target = dyn Trait; - fn deref(&self) -> &dyn Trait { - //~^ ERROR `impl` item signature doesn't match `trait` item signature - unimplemented!(); - } -} - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/mismatched_trait_impl-2.stderr b/src/test/ui/in-band-lifetimes/mismatched_trait_impl-2.stderr deleted file mode 100644 index 0546b6b51b273..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched_trait_impl-2.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error: `impl` item signature doesn't match `trait` item signature - --> $DIR/mismatched_trait_impl-2.rs:8:5 - | -LL | fn deref(&self) -> &dyn Trait { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(&'1 Struct) -> &'1 (dyn Trait + '1)` - | - ::: $SRC_DIR/core/src/ops/deref.rs:LL:COL - | -LL | fn deref(&self) -> &Self::Target; - | --------------------------------- expected `fn(&'1 Struct) -> &'1 (dyn Trait + 'static)` - | - = note: expected `fn(&'1 Struct) -> &'1 (dyn Trait + 'static)` - found `fn(&'1 Struct) -> &'1 (dyn Trait + '1)` - = help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait` - = help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output - -error: aborting due to previous error - diff --git a/src/test/ui/in-band-lifetimes/mismatched_trait_impl.nll.stderr b/src/test/ui/in-band-lifetimes/mismatched_trait_impl.nll.stderr deleted file mode 100644 index c7a90c57add83..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched_trait_impl.nll.stderr +++ /dev/null @@ -1,16 +0,0 @@ -error: `impl` item signature doesn't match `trait` item signature - --> $DIR/mismatched_trait_impl.rs:9:5 - | -LL | fn foo(&self, x: &'a u32, y: &u32) -> &'a u32; - | ---------------------------------------------- expected `fn(&'1 i32, &'a u32, &'2 u32) -> &'a u32` -... -LL | fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(&'1 i32, &'2 u32, &'3 u32) -> &'3 u32` - | - = note: expected `fn(&'1 i32, &'a u32, &'2 u32) -> &'a u32` - found `fn(&'1 i32, &'2 u32, &'3 u32) -> &'3 u32` - = help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait` - = help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output - -error: aborting due to previous error - diff --git a/src/test/ui/in-band-lifetimes/mismatched_trait_impl.rs b/src/test/ui/in-band-lifetimes/mismatched_trait_impl.rs deleted file mode 100644 index b9e02e967c126..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched_trait_impl.rs +++ /dev/null @@ -1,14 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -trait Get { - fn foo(&self, x: &'a u32, y: &u32) -> &'a u32; -} - -impl Get for i32 { - fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 { //~ ERROR `impl` item signature doesn't match - x //~ ERROR lifetime mismatch - } -} - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/mismatched_trait_impl.stderr b/src/test/ui/in-band-lifetimes/mismatched_trait_impl.stderr deleted file mode 100644 index 84e5339122ead..0000000000000 --- a/src/test/ui/in-band-lifetimes/mismatched_trait_impl.stderr +++ /dev/null @@ -1,27 +0,0 @@ -error: `impl` item signature doesn't match `trait` item signature - --> $DIR/mismatched_trait_impl.rs:9:5 - | -LL | fn foo(&self, x: &'a u32, y: &u32) -> &'a u32; - | ---------------------------------------------- expected `fn(&'1 i32, &'a u32, &'2 u32) -> &'a u32` -... -LL | fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(&'1 i32, &'2 u32, &'3 u32) -> &'3 u32` - | - = note: expected `fn(&'1 i32, &'a u32, &'2 u32) -> &'a u32` - found `fn(&'1 i32, &'2 u32, &'3 u32) -> &'3 u32` - = help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait` - = help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output - -error[E0623]: lifetime mismatch - --> $DIR/mismatched_trait_impl.rs:10:9 - | -LL | fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 { - | ---- ------- - | | - | this parameter and the return type are declared with different lifetimes... -LL | x - | ^ ...but data from `x` is returned here - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0623`. diff --git a/src/test/ui/in-band-lifetimes/mut_while_borrow.rs b/src/test/ui/in-band-lifetimes/mut_while_borrow.rs deleted file mode 100644 index 97e8ed0d2813e..0000000000000 --- a/src/test/ui/in-band-lifetimes/mut_while_borrow.rs +++ /dev/null @@ -1,11 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -fn foo(x: &'a u32) -> &'a u32 { x } - -fn main() { - let mut p = 3; - let r = foo(&p); - p += 1; //~ ERROR cannot assign to `p` because it is borrowed - println!("{}", r); -} diff --git a/src/test/ui/in-band-lifetimes/mut_while_borrow.stderr b/src/test/ui/in-band-lifetimes/mut_while_borrow.stderr deleted file mode 100644 index f96ff9dd4e674..0000000000000 --- a/src/test/ui/in-band-lifetimes/mut_while_borrow.stderr +++ /dev/null @@ -1,13 +0,0 @@ -error[E0506]: cannot assign to `p` because it is borrowed - --> $DIR/mut_while_borrow.rs:9:5 - | -LL | let r = foo(&p); - | -- borrow of `p` occurs here -LL | p += 1; - | ^^^^^^ assignment to borrowed `p` occurs here -LL | println!("{}", r); - | - borrow later used here - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0506`. diff --git a/src/test/ui/in-band-lifetimes/nested-items.rs b/src/test/ui/in-band-lifetimes/nested-items.rs deleted file mode 100644 index 7de20712fba94..0000000000000 --- a/src/test/ui/in-band-lifetimes/nested-items.rs +++ /dev/null @@ -1,20 +0,0 @@ -// Test that the `'a` from the impl doesn't -// prevent us from creating a `'a` parameter -// on the `blah` function. -// -// check-pass - -#![feature(in_band_lifetimes)] - -struct Foo<'a> { - x: &'a u32 - -} - -impl Foo<'a> { - fn method(&self) { - fn blah(f: Foo<'a>) { } - } -} - -fn main() { } diff --git a/src/test/ui/in-band-lifetimes/no_in_band_in_struct.rs b/src/test/ui/in-band-lifetimes/no_in_band_in_struct.rs deleted file mode 100644 index 9b0c0cda77220..0000000000000 --- a/src/test/ui/in-band-lifetimes/no_in_band_in_struct.rs +++ /dev/null @@ -1,12 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -struct Foo { - x: &'test u32, //~ ERROR undeclared lifetime -} - -enum Bar { - Baz(&'test u32), //~ ERROR undeclared lifetime -} - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/no_in_band_in_struct.stderr b/src/test/ui/in-band-lifetimes/no_in_band_in_struct.stderr deleted file mode 100644 index fe656f7af7e01..0000000000000 --- a/src/test/ui/in-band-lifetimes/no_in_band_in_struct.stderr +++ /dev/null @@ -1,19 +0,0 @@ -error[E0261]: use of undeclared lifetime name `'test` - --> $DIR/no_in_band_in_struct.rs:5:9 - | -LL | struct Foo { - | - help: consider introducing lifetime `'test` here: `<'test>` -LL | x: &'test u32, - | ^^^^^ undeclared lifetime - -error[E0261]: use of undeclared lifetime name `'test` - --> $DIR/no_in_band_in_struct.rs:9:10 - | -LL | enum Bar { - | - help: consider introducing lifetime `'test` here: `<'test>` -LL | Baz(&'test u32), - | ^^^^^ undeclared lifetime - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0261`. diff --git a/src/test/ui/in-band-lifetimes/no_introducing_in_band_in_locals.rs b/src/test/ui/in-band-lifetimes/no_introducing_in_band_in_locals.rs deleted file mode 100644 index c1c40afdbab55..0000000000000 --- a/src/test/ui/in-band-lifetimes/no_introducing_in_band_in_locals.rs +++ /dev/null @@ -1,13 +0,0 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - -fn foo(x: &u32) { - let y: &'test u32 = x; //~ ERROR use of undeclared lifetime -} - -fn foo2(x: &u32) {} -fn bar() { - let y: fn(&'test u32) = foo2; //~ ERROR use of undeclared lifetime -} - -fn main() {} diff --git a/src/test/ui/in-band-lifetimes/no_introducing_in_band_in_locals.stderr b/src/test/ui/in-band-lifetimes/no_introducing_in_band_in_locals.stderr deleted file mode 100644 index 5f0de61e69d29..0000000000000 --- a/src/test/ui/in-band-lifetimes/no_introducing_in_band_in_locals.stderr +++ /dev/null @@ -1,27 +0,0 @@ -error[E0261]: use of undeclared lifetime name `'test` - --> $DIR/no_introducing_in_band_in_locals.rs:5:13 - | -LL | fn foo(x: &u32) { - | - help: consider introducing lifetime `'test` here: `<'test>` -LL | let y: &'test u32 = x; - | ^^^^^ undeclared lifetime - -error[E0261]: use of undeclared lifetime name `'test` - --> $DIR/no_introducing_in_band_in_locals.rs:10:16 - | -LL | let y: fn(&'test u32) = foo2; - | ^^^^^ undeclared lifetime - | - = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html -help: consider introducing lifetime `'test` here - | -LL | fn bar<'test>() { - | +++++++ -help: consider making the type lifetime-generic with a new `'test` lifetime - | -LL | let y: for<'test> fn(&'test u32) = foo2; - | ++++++++++ - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0261`. diff --git a/src/test/ui/in-band-lifetimes/missing-lifetime-in-alias.rs b/src/test/ui/lifetimes/missing-lifetime-in-alias.rs similarity index 97% rename from src/test/ui/in-band-lifetimes/missing-lifetime-in-alias.rs rename to src/test/ui/lifetimes/missing-lifetime-in-alias.rs index 800f03302ed38..af7b6412780d8 100644 --- a/src/test/ui/in-band-lifetimes/missing-lifetime-in-alias.rs +++ b/src/test/ui/lifetimes/missing-lifetime-in-alias.rs @@ -1,5 +1,4 @@ #![feature(generic_associated_types)] -#![allow(unused)] trait Trait<'a> { type Foo; diff --git a/src/test/ui/in-band-lifetimes/missing-lifetime-in-alias.stderr b/src/test/ui/lifetimes/missing-lifetime-in-alias.stderr similarity index 83% rename from src/test/ui/in-band-lifetimes/missing-lifetime-in-alias.stderr rename to src/test/ui/lifetimes/missing-lifetime-in-alias.stderr index f1b951fc82632..b16b792aefee9 100644 --- a/src/test/ui/in-band-lifetimes/missing-lifetime-in-alias.stderr +++ b/src/test/ui/lifetimes/missing-lifetime-in-alias.stderr @@ -1,5 +1,5 @@ error[E0106]: missing lifetime specifier - --> $DIR/missing-lifetime-in-alias.rs:23:24 + --> $DIR/missing-lifetime-in-alias.rs:22:24 | LL | type B<'a> = as Trait>::Foo; | ^^^^^ expected named lifetime parameter @@ -10,25 +10,25 @@ LL | type B<'a> = as Trait<'a>>::Foo; | ~~~~~~~~~ error[E0106]: missing lifetime specifier - --> $DIR/missing-lifetime-in-alias.rs:27:28 + --> $DIR/missing-lifetime-in-alias.rs:26:28 | LL | type C<'a, 'b> = as Trait>::Bar; | ^^^^^ expected named lifetime parameter | note: these named lifetimes are available to use - --> $DIR/missing-lifetime-in-alias.rs:27:8 + --> $DIR/missing-lifetime-in-alias.rs:26:8 | LL | type C<'a, 'b> = as Trait>::Bar; | ^^ ^^ error[E0107]: missing generics for associated type `Trait::Bar` - --> $DIR/missing-lifetime-in-alias.rs:27:36 + --> $DIR/missing-lifetime-in-alias.rs:26:36 | LL | type C<'a, 'b> = as Trait>::Bar; | ^^^ expected 1 lifetime argument | note: associated type defined here, with 1 lifetime parameter: `'b` - --> $DIR/missing-lifetime-in-alias.rs:7:10 + --> $DIR/missing-lifetime-in-alias.rs:6:10 | LL | type Bar<'b> | ^^^ -- diff --git a/src/test/ui/lifetimes/nested.rs b/src/test/ui/lifetimes/nested.rs new file mode 100644 index 0000000000000..f3f1f2016f237 --- /dev/null +++ b/src/test/ui/lifetimes/nested.rs @@ -0,0 +1,7 @@ +// check-pass + +fn method<'a>(_i: &'a i32) { + fn inner<'a>(_j: &'a f32) {} +} + +fn main() {} diff --git a/src/test/ui/in-band-lifetimes/shadow.rs b/src/test/ui/lifetimes/shadow.rs similarity index 71% rename from src/test/ui/in-band-lifetimes/shadow.rs rename to src/test/ui/lifetimes/shadow.rs index 27b5d57488c91..e2124887e0f09 100644 --- a/src/test/ui/in-band-lifetimes/shadow.rs +++ b/src/test/ui/lifetimes/shadow.rs @@ -1,9 +1,6 @@ -#![allow(warnings)] -#![feature(in_band_lifetimes)] - struct Foo(T); -impl Foo<&'s u8> { +impl<'s> Foo<&'s u8> { fn bar<'s>(&self, x: &'s u8) {} //~ ERROR shadows a lifetime name fn baz(x: for<'s> fn(&'s u32)) {} //~ ERROR shadows a lifetime name } diff --git a/src/test/ui/in-band-lifetimes/shadow.stderr b/src/test/ui/lifetimes/shadow.stderr similarity index 74% rename from src/test/ui/in-band-lifetimes/shadow.stderr rename to src/test/ui/lifetimes/shadow.stderr index c7a6f3ac3ad14..b834e90d8d079 100644 --- a/src/test/ui/in-band-lifetimes/shadow.stderr +++ b/src/test/ui/lifetimes/shadow.stderr @@ -1,16 +1,16 @@ error[E0496]: lifetime name `'s` shadows a lifetime name that is already in scope - --> $DIR/shadow.rs:7:12 + --> $DIR/shadow.rs:4:12 | -LL | impl Foo<&'s u8> { - | -- first declared here +LL | impl<'s> Foo<&'s u8> { + | -- first declared here LL | fn bar<'s>(&self, x: &'s u8) {} | ^^ lifetime `'s` already in scope error[E0496]: lifetime name `'s` shadows a lifetime name that is already in scope - --> $DIR/shadow.rs:8:19 + --> $DIR/shadow.rs:5:19 | -LL | impl Foo<&'s u8> { - | -- first declared here +LL | impl<'s> Foo<&'s u8> { + | -- first declared here LL | fn bar<'s>(&self, x: &'s u8) {} LL | fn baz(x: for<'s> fn(&'s u32)) {} | ^^ lifetime `'s` already in scope diff --git a/src/test/ui/lifetimes/undeclared-lifetime-used-in-debug-macro-issue-70152.stderr b/src/test/ui/lifetimes/undeclared-lifetime-used-in-debug-macro-issue-70152.stderr index a208689523401..cb459f31cd243 100644 --- a/src/test/ui/lifetimes/undeclared-lifetime-used-in-debug-macro-issue-70152.stderr +++ b/src/test/ui/lifetimes/undeclared-lifetime-used-in-debug-macro-issue-70152.stderr @@ -5,8 +5,6 @@ LL | struct Test { | - help: consider introducing lifetime `'b` here: `<'b>` LL | a: &'b str, | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'b` --> $DIR/undeclared-lifetime-used-in-debug-macro-issue-70152.rs:3:9 @@ -15,8 +13,6 @@ LL | struct Test { | - help: consider introducing lifetime `'b` here: `<'b>` LL | a: &'b str, | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'b` --> $DIR/undeclared-lifetime-used-in-debug-macro-issue-70152.rs:13:13 @@ -24,7 +20,6 @@ error[E0261]: use of undeclared lifetime name `'b` LL | fn foo(&'b self) {} | ^^ undeclared lifetime | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'b` here | LL | impl<'b> T for Test { diff --git a/src/test/ui/methods/method-call-lifetime-args-unresolved.stderr b/src/test/ui/methods/method-call-lifetime-args-unresolved.stderr index 93c0384fcc266..c9f235c4f7df7 100644 --- a/src/test/ui/methods/method-call-lifetime-args-unresolved.stderr +++ b/src/test/ui/methods/method-call-lifetime-args-unresolved.stderr @@ -5,8 +5,6 @@ LL | fn main() { | - help: consider introducing lifetime `'a` here: `<'a>` LL | 0.clone::<'a>(); | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error: aborting due to previous error diff --git a/src/test/ui/nll/issue-52742.rs b/src/test/ui/nll/issue-52742.rs index db9ddfff285b3..d3e201b8ae8e7 100644 --- a/src/test/ui/nll/issue-52742.rs +++ b/src/test/ui/nll/issue-52742.rs @@ -1,5 +1,3 @@ -#![feature(in_band_lifetimes)] - struct Foo<'a, 'b> { x: &'a u32, y: &'b u32, diff --git a/src/test/ui/nll/issue-52742.stderr b/src/test/ui/nll/issue-52742.stderr index 3f8481219a9ad..67bac14b6e4e1 100644 --- a/src/test/ui/nll/issue-52742.stderr +++ b/src/test/ui/nll/issue-52742.stderr @@ -1,16 +1,16 @@ error[E0312]: lifetime of reference outlives lifetime of borrowed content... - --> $DIR/issue-52742.rs:14:18 + --> $DIR/issue-52742.rs:12:18 | LL | self.y = b.z | ^^^ | note: ...the reference is valid for the lifetime `'_` as defined here... - --> $DIR/issue-52742.rs:12:10 + --> $DIR/issue-52742.rs:10:10 | LL | impl Foo<'_, '_> { | ^^ note: ...but the borrowed content is only valid for the anonymous lifetime defined here - --> $DIR/issue-52742.rs:13:31 + --> $DIR/issue-52742.rs:11:31 | LL | fn take_bar(&mut self, b: Bar<'_>) { | ^^^^^^^ diff --git a/src/test/ui/regions/regions-in-enums.stderr b/src/test/ui/regions/regions-in-enums.stderr index d56c1fbd119c8..66537653291c7 100644 --- a/src/test/ui/regions/regions-in-enums.stderr +++ b/src/test/ui/regions/regions-in-enums.stderr @@ -5,8 +5,6 @@ LL | enum No0 { | - help: consider introducing lifetime `'foo` here: `<'foo>` LL | X5(&'foo usize) | ^^^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-in-enums.rs:17:9 @@ -15,8 +13,6 @@ LL | enum No1 { | - help: consider introducing lifetime `'a` here: `<'a>` LL | X6(&'a usize) | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error: aborting due to 2 previous errors diff --git a/src/test/ui/regions/regions-in-structs.stderr b/src/test/ui/regions/regions-in-structs.stderr index 2750149d09735..5dfdc2ee93b43 100644 --- a/src/test/ui/regions/regions-in-structs.stderr +++ b/src/test/ui/regions/regions-in-structs.stderr @@ -5,8 +5,6 @@ LL | struct StructDecl { | - help: consider introducing lifetime `'a` here: `<'a>` LL | a: &'a isize, | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-in-structs.rs:11:9 @@ -16,8 +14,6 @@ LL | struct StructDecl { LL | a: &'a isize, LL | b: &'a isize, | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error: aborting due to 2 previous errors diff --git a/src/test/ui/regions/regions-name-undeclared.stderr b/src/test/ui/regions/regions-name-undeclared.stderr index 250752c9b9e68..4399263f716ed 100644 --- a/src/test/ui/regions/regions-name-undeclared.stderr +++ b/src/test/ui/regions/regions-name-undeclared.stderr @@ -5,8 +5,6 @@ LL | enum E { | - help: consider introducing lifetime `'a` here: `<'a>` LL | E1(&'a isize) | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-name-undeclared.rs:31:13 @@ -15,8 +13,6 @@ LL | struct S { | - help: consider introducing lifetime `'a` here: `<'a>` LL | f: &'a isize | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'b` --> $DIR/regions-name-undeclared.rs:16:24 @@ -24,7 +20,6 @@ error[E0261]: use of undeclared lifetime name `'b` LL | fn m4(&self, arg: &'b isize) { } | ^^ undeclared lifetime | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'b` here | LL | impl<'b, 'a> Foo<'a> { @@ -40,7 +35,6 @@ error[E0261]: use of undeclared lifetime name `'b` LL | fn m5(&'b self) { } | ^^ undeclared lifetime | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'b` here | LL | impl<'b, 'a> Foo<'a> { @@ -56,7 +50,6 @@ error[E0261]: use of undeclared lifetime name `'b` LL | fn m6(&self, arg: Foo<'b>) { } | ^^ undeclared lifetime | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'b` here | LL | impl<'b, 'a> Foo<'a> { @@ -73,8 +66,6 @@ LL | type X = Option<&'a isize>; | - ^^ undeclared lifetime | | | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-name-undeclared.rs:33:14 @@ -83,8 +74,6 @@ LL | fn f(a: &'a isize) { } | - ^^ undeclared lifetime | | | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-name-undeclared.rs:41:17 @@ -93,8 +82,6 @@ LL | fn fn_types(a: &'a isize, | - ^^ undeclared lifetime | | | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'b` --> $DIR/regions-name-undeclared.rs:43:36 @@ -103,7 +90,6 @@ LL | ... &'b isize, | ^^ undeclared lifetime | = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'b` here | LL | fn fn_types<'b>(a: &'a isize, @@ -120,7 +106,6 @@ LL | ... &'b isize)>, | ^^ undeclared lifetime | = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'b` here | LL | fn fn_types<'b>(a: &'a isize, @@ -138,8 +123,6 @@ LL | fn fn_types(a: &'a isize, ... LL | c: &'a isize) | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-name-undeclared.rs:53:31 @@ -147,7 +130,6 @@ error[E0261]: use of undeclared lifetime name `'a` LL | async fn buggy(&self) -> &'a str { | ^^ undeclared lifetime | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes help: consider introducing lifetime `'a` here | LL | impl<'a> Bug { diff --git a/src/test/ui/regions/regions-undeclared.stderr b/src/test/ui/regions/regions-undeclared.stderr index f3cae184ccde8..6bfde5524ac49 100644 --- a/src/test/ui/regions/regions-undeclared.stderr +++ b/src/test/ui/regions/regions-undeclared.stderr @@ -11,8 +11,6 @@ LL | enum EnumDecl { | - help: consider introducing lifetime `'a` here: `<'a>` LL | Foo(&'a isize), | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-undeclared.rs:5:10 @@ -22,8 +20,6 @@ LL | enum EnumDecl { LL | Foo(&'a isize), LL | Bar(&'a isize), | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-undeclared.rs:8:15 @@ -32,8 +28,6 @@ LL | fn fnDecl(x: &'a isize, | - ^^ undeclared lifetime | | | help: consider introducing lifetime `'a` here: `<'a>` - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'a` --> $DIR/regions-undeclared.rs:9:15 @@ -42,8 +36,6 @@ LL | fn fnDecl(x: &'a isize, | - help: consider introducing lifetime `'a` here: `<'a>` LL | y: &'a isize) | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error: aborting due to 5 previous errors diff --git a/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.fixed b/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.fixed deleted file mode 100644 index 6bc07afccbf39..0000000000000 --- a/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.fixed +++ /dev/null @@ -1,18 +0,0 @@ -// run-rustfix - -#![feature(in_band_lifetimes)] -#![deny(single_use_lifetimes)] -#![allow(dead_code)] -#![allow(unused_variables)] - -// Test that we DO warn when lifetime name is used only -// once in a fn argument, even with in band lifetimes. - -fn a(x: &u32, y: &u32) { - //~^ ERROR `'a` only used once - //~| ERROR `'b` only used once - //~| HELP elide the single-use lifetime - //~| HELP elide the single-use lifetime -} - -fn main() { } diff --git a/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.rs b/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.rs deleted file mode 100644 index 22c6a5a9d3869..0000000000000 --- a/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.rs +++ /dev/null @@ -1,18 +0,0 @@ -// run-rustfix - -#![feature(in_band_lifetimes)] -#![deny(single_use_lifetimes)] -#![allow(dead_code)] -#![allow(unused_variables)] - -// Test that we DO warn when lifetime name is used only -// once in a fn argument, even with in band lifetimes. - -fn a(x: &'a u32, y: &'b u32) { - //~^ ERROR `'a` only used once - //~| ERROR `'b` only used once - //~| HELP elide the single-use lifetime - //~| HELP elide the single-use lifetime -} - -fn main() { } diff --git a/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.stderr b/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.stderr deleted file mode 100644 index b251e8a438ac1..0000000000000 --- a/src/test/ui/single-use-lifetime/one-use-in-fn-argument-in-band.stderr +++ /dev/null @@ -1,26 +0,0 @@ -error: lifetime parameter `'a` only used once - --> $DIR/one-use-in-fn-argument-in-band.rs:11:10 - | -LL | fn a(x: &'a u32, y: &'b u32) { - | ^^- - | | - | this lifetime is only used here - | help: elide the single-use lifetime - | -note: the lint level is defined here - --> $DIR/one-use-in-fn-argument-in-band.rs:4:9 - | -LL | #![deny(single_use_lifetimes)] - | ^^^^^^^^^^^^^^^^^^^^ - -error: lifetime parameter `'b` only used once - --> $DIR/one-use-in-fn-argument-in-band.rs:11:22 - | -LL | fn a(x: &'a u32, y: &'b u32) { - | ^^- - | | - | this lifetime is only used here - | help: elide the single-use lifetime - -error: aborting due to 2 previous errors - diff --git a/src/test/ui/where-clauses/where-lifetime-resolution.stderr b/src/test/ui/where-clauses/where-lifetime-resolution.stderr index a704fea282899..6c52664154bbf 100644 --- a/src/test/ui/where-clauses/where-lifetime-resolution.stderr +++ b/src/test/ui/where-clauses/where-lifetime-resolution.stderr @@ -6,8 +6,6 @@ LL | fn f() where LL | for<'a> dyn Trait1<'a>: Trait1<'a>, // OK LL | (dyn for<'a> Trait1<'a>): Trait1<'a>, | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error[E0261]: use of undeclared lifetime name `'b` --> $DIR/where-lifetime-resolution.rs:8:52 @@ -17,8 +15,6 @@ LL | fn f() where ... LL | for<'a> dyn for<'b> Trait2<'a, 'b>: Trait2<'a, 'b>, | ^^ undeclared lifetime - | - = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes error: aborting due to 2 previous errors