From 9e60e0afb5cfec26ecf1d51392c16cab0bfed3be Mon Sep 17 00:00:00 2001 From: skippy10110 Date: Thu, 14 Apr 2022 23:55:54 -0300 Subject: [PATCH 1/7] add deprecated_safe attribute and lint --- Cargo.lock | 1 + compiler/rustc_feature/src/builtin_attrs.rs | 8 +- compiler/rustc_lint_defs/src/builtin.rs | 45 +++ compiler/rustc_middle/src/middle/stability.rs | 309 +++++++++++++++++- compiler/rustc_passes/src/check_attr.rs | 59 ++++ compiler/rustc_span/src/symbol.rs | 1 + compiler/rustc_typeck/Cargo.toml | 1 + 7 files changed, 420 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bdfb51761760f..424f44e34f8e4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4457,6 +4457,7 @@ dependencies = [ "rustc_index", "rustc_infer", "rustc_lint", + "rustc_lint_defs", "rustc_macros", "rustc_middle", "rustc_serialize", diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index 7c53f839a92e4..ee05695057146 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -454,7 +454,13 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ ), // lang-team MCP 147 gated!( - deprecated_safe, Normal, template!(List: r#"since = "version", note = "...""#), ErrorFollowing, + deprecated_safe, Normal, + template!( + Word, + List: r#"/*opt*/ since = "version", /*opt*/ note = "reason", /*opt*/ unsafe_edition = "edition""#, + NameValueStr: "reason" + ), + ErrorFollowing, experimental!(deprecated_safe), ), diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs index 5704c6ed3b25d..65720a93fcca3 100644 --- a/compiler/rustc_lint_defs/src/builtin.rs +++ b/compiler/rustc_lint_defs/src/builtin.rs @@ -3129,6 +3129,7 @@ declare_lint_pass! { UNEXPECTED_CFGS, DEPRECATED_WHERE_CLAUSE_LOCATION, TEST_UNSTABLE_LINT, + DEPRECATED_SAFE, ] } @@ -3794,3 +3795,47 @@ declare_lint! { "this unstable lint is only for testing", @feature_gate = sym::test_unstable_lint; } + +declare_lint! { + /// The `deprecated_safe` lint detects safe, unsound usage of items that are now marked ```[unsafe]```, + /// with safe usage being deprecated. + /// + /// ### Example + /// + /// ```rust + /// #![feature(deprecated_safe)] + /// + /// #[deprecated_safe(since = "1.61.0", note = "reason")] + /// unsafe fn previously_safe_function() {} + /// + /// fn main() { + /// previously_safe_function(); + /// } + /// ``` + /// + /// {{produces}} + /// + /// ### Explanation + /// + /// FIXME(skippy) broken link: [`deprecated_safe` attribute] + /// Items may be marked "deprecated_safe" with the [`deprecated_safe` attribute] to + /// indicate that they should no longer be used. Usually the attribute + /// should include a note on what to use instead, or check the + /// documentation. + /// + /// [`deprecated_safe` attribute]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-deprecated_safe-attribute + /// [`unsafe fn`]: https://doc.rust-lang.org/reference/unsafe-functions.html + /// [`unsafe` trait]: https://doc.rust-lang.org/reference/items/traits.html#unsafe-traits + /// [`unsafe` block]: https://doc.rust-lang.org/reference/expressions/block-expr.html#unsafe-blocks + /// [unsafe]: https://doc.rust-lang.org/reference/unsafety.html + pub DEPRECATED_SAFE, + Warn, + "detects unsound use of items that are now marked unsafe, when safe use is deprecated", + report_in_external_macro + // FIXME(skippy) use future_incompatible? + /* + @future_incompatible = FutureIncompatibleInfo { + reference: "issue #94978 ", + }; + */ +} diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs index fd6e241346db8..f7e26b8ca797e 100644 --- a/compiler/rustc_middle/src/middle/stability.rs +++ b/compiler/rustc_middle/src/middle/stability.rs @@ -4,23 +4,27 @@ pub use self::StabilityLevel::*; use crate::ty::{self, DefIdTree, TyCtxt}; -use rustc_ast::NodeId; +use rustc_ast::{Attribute, MetaItem, MetaItemKind, NestedMetaItem, NodeId}; use rustc_attr::{self as attr, ConstStability, Deprecation, Stability}; use rustc_data_structures::fx::FxHashMap; -use rustc_errors::{Applicability, Diagnostic}; +use rustc_errors::{struct_span_err, Applicability, Diagnostic}; use rustc_feature::GateIssue; use rustc_hir as hir; use rustc_hir::def::DefKind; use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_INDEX}; use rustc_hir::{self, HirId}; use rustc_middle::ty::print::with_no_trimmed_paths; -use rustc_session::lint::builtin::{DEPRECATED, DEPRECATED_IN_FUTURE, SOFT_UNSTABLE}; +use rustc_session::lint::builtin::{ + DEPRECATED, DEPRECATED_IN_FUTURE, DEPRECATED_SAFE, SOFT_UNSTABLE, +}; use rustc_session::lint::{BuiltinLintDiagnostics, Level, Lint, LintBuffer}; use rustc_session::parse::feature_err_issue; use rustc_session::Session; +use rustc_span::edition::Edition; use rustc_span::symbol::{sym, Symbol}; use rustc_span::Span; use std::num::NonZeroU32; +use std::str::FromStr; #[derive(PartialEq, Clone, Copy, Debug)] pub enum StabilityLevel { @@ -247,6 +251,305 @@ fn late_report_deprecation( }); } +// FIXME(skippy) specifically needs reviewer feedback +// FIXME(skippy) is stability::* the right place for all this stuff? +#[derive(Copy, Debug, Clone)] +pub struct DeprecationAsSafe { + pub since: Option, + /// The note to issue a reason. + pub note: Option, + + /// The edition where the item is treated as fully unsafe with + /// safe usage erroring instead of emitting a deprecated_safe lint + pub unsafe_edition: Option, +} + +pub enum DeprecationAsSafeKind { + FnCall { unsafe_op_in_unsafe_fn_allowed: bool }, + FnPointerCoercion, + FnTraitCoercion, + TraitImpl, + TraitFnImpl, +} + +// check whether this item should be treated as an unsafe item marked with #[deprecated_safe] +// - in stable usage the item will always be marked unsafe +// - in unstable usage the item will not be marked unsafe, but it will behave as if it is +// within libstd +pub fn check_deprecation_as_safe(tcx: TyCtxt<'_>, def_id: DefId, span: Span) -> bool { + // #[deprecated_safe] is unstable, ignore it completely on stable rust + if !tcx.sess.is_nightly_build() { + return false; + } + + // look up the atttribute + let Some(attr) = tcx.get_attrs(def_id).iter().find(|x| x.has_name(sym::deprecated_safe)) else { + return false; + }; + let Some(depr_as_safe) = parse_deprecation_as_safe(tcx, def_id, attr) else { + bug!("invalid #[deprecated_safe] attribute during reporting"); + }; + + // if the `unsafe_edition` has been reached, #[deprecated_safe] ceases to exist + // and the function/trait behaves fully unsafe with no escape hatch + // note: `unsafe_edition` is only checked once the ```since``` version is in effect + if let Some(unsafe_edition) = depr_as_safe.unsafe_edition + && span.edition() >= unsafe_edition + { + return false; + } + + true +} + +pub fn parse_deprecation_as_safe( + tcx: TyCtxt<'_>, + def_id: DefId, + attr: &Attribute, +) -> Option { + let Some(meta_kind) = attr.meta_kind() else { + return None; + }; + + let mut since = None; + let mut note = None; + let mut unsafe_edition = None; + + match &meta_kind { + MetaItemKind::Word => {} + MetaItemKind::NameValue(..) => note = attr.value_str(), + MetaItemKind::List(list) => { + let get = |meta: &MetaItem, item: &mut Option| { + if item.is_some() { + struct_span_err!( + tcx.sess, + attr.span, + E0538, + "multiple '{}' items", + &meta.name_or_empty() + ) + .emit(); + return false; + } + if let Some(v) = meta.value_str() { + *item = Some(v); + true + } else { + if let Some(lit) = meta.name_value_literal() { + struct_span_err!( + tcx.sess, + lit.span, + E0565, + "literal in `deprecated_safe` value must be a string", + ) + .emit(); + } else { + struct_span_err!( + tcx.sess, + meta.span, + E0551, + "incorrect meta item '{}'", + meta.name_or_empty() + ) + .emit(); + } + + false + } + }; + + for meta in list { + match meta { + NestedMetaItem::MetaItem(mi) => match mi.name_or_empty() { + sym::since => { + if !get(mi, &mut since) { + return None; + } + } + sym::note => { + if !get(mi, &mut note) { + return None; + } + } + sym::unsafe_edition => { + if !get(mi, &mut unsafe_edition) { + return None; + } + } + _ => { + struct_span_err!( + tcx.sess, + mi.span, + E0541, + "unknown meta item '{}'", + mi.name_or_empty() + ) + .emit(); + return None; + } + }, + NestedMetaItem::Literal(lit) => { + struct_span_err!( + tcx.sess, + lit.span, + E0565, + "item in `deprecated_safe` must be a key/value pair", + ) + .emit(); + return None; + } + } + } + } + } + + let is_rustc = tcx.features().staged_api || tcx.lookup_stability(def_id).is_some(); + if is_rustc { + if since.is_none() { + struct_span_err!( + tcx.sess, + attr.span, + // FIXME(skippy) wrong error code, need to create a new one + E0542, + "missing 'since'" + ) + .emit(); + return None; + } + + if note.is_none() { + struct_span_err!( + tcx.sess, + attr.span, + // FIXME(skippy) wrong error code, need to create a new one + E0543, + "missing 'note'" + ) + .emit(); + return None; + } + } else { + if unsafe_edition.is_some() { + struct_span_err!( + tcx.sess, + attr.span, + // FIXME(skippy) wrong error code, need to create a new one + E0543, + "'unsafe_edition' is invalid outside of rustc" + ) + .emit(); + return None; + } + } + + let mut unsafe_edition_parsed = None; + if let Some(unsafe_edition) = unsafe_edition { + if let Ok(unsafe_edition) = Edition::from_str(unsafe_edition.as_str()) { + unsafe_edition_parsed = Some(unsafe_edition); + } else { + struct_span_err!( + tcx.sess, + attr.span, + // FIXME(skippy) wrong error code, need to create a new one + E0543, + "invalid 'unsafe_edition' specified" + ) + .emit(); + return None; + } + } + + Some(DeprecationAsSafe { since, note, unsafe_edition: unsafe_edition_parsed }) +} + +pub fn report_deprecation_as_safe<'tcx>( + tcx: TyCtxt<'tcx>, + kind: DeprecationAsSafeKind, + def_id: DefId, + lint_root: HirId, + span: Span, +) { + let def_path = with_no_trimmed_paths!(tcx.def_path_str(def_id)); + let def_kind = tcx.def_kind(def_id).descr(def_id); + + // look up the atttribute + let Some(attr) = tcx.get_attrs(def_id).iter().find(|x| x.has_name(sym::deprecated_safe)) else { + bug!("missing #[deprecated_safe] attribute during reporting"); + }; + let Some(depr_as_safe) = parse_deprecation_as_safe(tcx, def_id, attr) else { + bug!("invalid #[deprecated_safe] attribute during reporting"); + }; + + let (message, span_label) = match kind { + DeprecationAsSafeKind::FnCall { unsafe_op_in_unsafe_fn_allowed } => { + let fn_sugg = if unsafe_op_in_unsafe_fn_allowed { " function or" } else { "" }; + ( + format!( + "use of {} `{}` without an unsafe{} block has been deprecated as it is now an unsafe {}", + def_kind, def_path, fn_sugg, def_kind + ), + Some("call to unsafe function"), + ) + } + DeprecationAsSafeKind::FnPointerCoercion => ( + format!( + "use of {} `{}` as a normal fn pointer has been deprecated as it is now an unsafe {}", + def_kind, def_path, def_kind + ), + Some("expected normal fn pointer, found unsafe fn pointer"), + ), + DeprecationAsSafeKind::FnTraitCoercion => ( + format!( + "use of {} `{}` as a closure has been deprecated as it is now an unsafe {}", + def_kind, def_path, def_kind + ), + None, + ), + DeprecationAsSafeKind::TraitImpl => ( + format!( + "use of {} `{}` without an `unsafe impl` declaration has been deprecated as it is now an unsafe {}", + def_kind, def_path, def_kind + ), + None, + ), + DeprecationAsSafeKind::TraitFnImpl => ( + format!( + "use of {} `{}` without an `unsafe fn` declaration has been deprecated as it is now an unsafe {}", + def_kind, def_path, def_kind + ), + None, + ), + }; + + tcx.struct_span_lint_hir(DEPRECATED_SAFE, lint_root, span, |lint| { + let mut diag = lint.build(&message); + if let Some(span_label) = span_label { + diag.span_label(span, span_label); + } + + let since_message = if let Some(since) = depr_as_safe.since { + format!(" since {}", since) + } else { + "".to_owned() + }; + diag.note(&format!( + "this {} was previously not marked unsafe, but has been marked unsafe{}", + def_kind, since_message, + )); + + diag.note(&format!( + "consult the {}'s documentation for information on how to avoid undefined behavior", + def_kind + )); + + if let Some(note) = depr_as_safe.note { + diag.note(note.as_str()); + } + + diag.emit(); + }); +} + /// Result of `TyCtxt::eval_stability`. pub enum EvalResult { /// We can use the item because it is stable or we provided the diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 1f12f99efb3d5..d923326591038 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -14,6 +14,7 @@ use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::{self, FnSig, ForeignItem, HirId, Item, ItemKind, TraitItem, CRATE_HIR_ID}; use rustc_hir::{MethodKind, Target}; use rustc_middle::hir::nested_filter; +use rustc_middle::middle::stability; use rustc_middle::ty::query::Providers; use rustc_middle::ty::TyCtxt; use rustc_session::lint::builtin::{ @@ -128,6 +129,7 @@ impl CheckAttrVisitor<'_> { | sym::unstable | sym::stable | sym::rustc_promotable => self.check_stability_promotable(&attr, span, target), + sym::deprecated_safe => self.check_deprecated_safe(hir_id, &attr, span, target), _ => true, }; is_valid &= attr_is_valid; @@ -2008,6 +2010,63 @@ impl CheckAttrVisitor<'_> { .emit(); }); } + + fn check_deprecated_safe( + &self, + hir_id: HirId, + attr: &Attribute, + span: Span, + _target: Target, + ) -> bool { + let mut unsafety = None; + + let node = self.tcx.hir().get(hir_id); + if let hir::Node::Item(item) = node { + if let Some(fn_sig) = node.fn_sig() { + unsafety = Some(fn_sig.header.unsafety); + } else if let hir::ItemKind::Trait(_, trait_unsafety, ..) = item.kind { + unsafety = Some(trait_unsafety); + } + } else if let hir::Node::TraitItem(_) = node { + if let Some(fn_sig) = node.fn_sig() { + unsafety = Some(fn_sig.header.unsafety); + } + } + + let Some(unsafety) = unsafety else { + struct_span_err!( + self.tcx.sess, + attr.span, + // FIXME(skippy) wrong error code, need to create a new one + E0543, + "this `#[deprecated_safe]` annotation has no effect" + ) + .emit(); + return false; + }; + + if let Some(_depr_as_safe) = stability::parse_deprecation_as_safe( + self.tcx, + self.tcx.hir().local_def_id(hir_id).to_def_id(), + attr, + ) { + if unsafety == hir::Unsafety::Normal { + struct_span_err!( + self.tcx.sess, + span, + // FIXME(skippy) wrong error code, need to create a new one + E0543, + "item must be marked unsafe" + ) + .emit(); + return false; + } + + true + } else { + false + } + } } impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> { diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index f5803aaa0786e..7a9bed688f275 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1466,6 +1466,7 @@ symbols! { unrestricted_attribute_tokens, unsafe_block_in_unsafe_fn, unsafe_cell, + unsafe_edition, unsafe_no_drop_flag, unsafe_pin_internals, unsize, diff --git a/compiler/rustc_typeck/Cargo.toml b/compiler/rustc_typeck/Cargo.toml index 57930a28a35a1..723a9a23c5a3a 100644 --- a/compiler/rustc_typeck/Cargo.toml +++ b/compiler/rustc_typeck/Cargo.toml @@ -18,6 +18,7 @@ rustc_errors = { path = "../rustc_errors" } rustc_graphviz = { path = "../rustc_graphviz" } rustc_hir = { path = "../rustc_hir" } rustc_hir_pretty = { path = "../rustc_hir_pretty" } +rustc_lint_defs = { path = "../rustc_lint_defs" } rustc_target = { path = "../rustc_target" } rustc_session = { path = "../rustc_session" } smallvec = { version = "1.6.1", features = ["union", "may_dangle"] } From dee2ace13402affba07ac55f339d5305e80b8138 Mon Sep 17 00:00:00 2001 From: skippy10110 Date: Thu, 14 Apr 2022 23:58:02 -0300 Subject: [PATCH 2/7] implement deprecated_safe checking of function calls (both thir & mir unsafety checkers) --- compiler/rustc_middle/src/mir/query.rs | 3 + .../rustc_mir_build/src/check_unsafety.rs | 45 +++++++++++--- .../rustc_mir_transform/src/check_unsafety.rs | 60 +++++++++++++++---- 3 files changed, 88 insertions(+), 20 deletions(-) diff --git a/compiler/rustc_middle/src/mir/query.rs b/compiler/rustc_middle/src/mir/query.rs index cee510a42413a..22496edd98cbc 100644 --- a/compiler/rustc_middle/src/mir/query.rs +++ b/compiler/rustc_middle/src/mir/query.rs @@ -25,6 +25,9 @@ pub enum UnsafetyViolationKind { /// Unsafe operation in an `unsafe fn` but outside an `unsafe` block. /// Has to be handled as a lint for backwards compatibility. UnsafeFn, + /// Unsafe operation that was previously marked safe but has been deprecated as such. + /// Has to be handled as a lint for backwards compatibility. + DeprecatedSafe { depr_as_safe: DefId }, } #[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)] diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs index eadce3dc9c467..0a232e5a69cfc 100644 --- a/compiler/rustc_mir_build/src/check_unsafety.rs +++ b/compiler/rustc_mir_build/src/check_unsafety.rs @@ -1,4 +1,5 @@ use crate::build::ExprCategory; +use rustc_middle::middle::stability::{self, DeprecationAsSafeKind}; use rustc_middle::thir::visit::{self, Visitor}; use rustc_errors::struct_span_err; @@ -72,16 +73,28 @@ impl<'tcx> UnsafetyVisitor<'_, 'tcx> { fn requires_unsafe(&mut self, span: Span, kind: UnsafeOpKind) { let (description, note) = kind.description_and_note(); let unsafe_op_in_unsafe_fn_allowed = self.unsafe_op_in_unsafe_fn_allowed(); - match self.safety_context { - SafetyContext::BuiltinUnsafeBlock => {} - SafetyContext::UnsafeBlock { ref mut used, .. } => { + match (&mut self.safety_context, kind) { + (SafetyContext::BuiltinUnsafeBlock, _) => {} + (SafetyContext::UnsafeBlock { ref mut used, .. }, _) => { if !self.body_unsafety.is_unsafe() || !unsafe_op_in_unsafe_fn_allowed { // Mark this block as useful *used = true; } } - SafetyContext::UnsafeFn if unsafe_op_in_unsafe_fn_allowed => {} - SafetyContext::UnsafeFn => { + (SafetyContext::UnsafeFn, _) if unsafe_op_in_unsafe_fn_allowed => {} + // check if this is a call to a #[deprecated_safe] fn() and lint if so + // instead of erroring + ( + SafetyContext::UnsafeFn | SafetyContext::Safe, + CallToDeprecatedSafeFunction { depr_as_safe }, + ) => stability::report_deprecation_as_safe( + self.tcx, + DeprecationAsSafeKind::FnCall { unsafe_op_in_unsafe_fn_allowed }, + depr_as_safe, + self.hir_context, + span, + ), + (SafetyContext::UnsafeFn, _) => { // unsafe_op_in_unsafe_fn is disallowed self.tcx.struct_span_lint_hir( UNSAFE_OP_IN_UNSAFE_FN, @@ -98,7 +111,7 @@ impl<'tcx> UnsafetyVisitor<'_, 'tcx> { }, ) } - SafetyContext::Safe => { + (SafetyContext::Safe, _) => { let fn_sugg = if unsafe_op_in_unsafe_fn_allowed { " function or" } else { "" }; struct_span_err!( self.tcx.sess, @@ -350,8 +363,21 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> { } ExprKind::Call { fun, ty: _, args: _, from_hir_call: _, fn_span: _ } => { if self.thir[fun].ty.fn_sig(self.tcx).unsafety() == hir::Unsafety::Unsafe { - self.requires_unsafe(expr.span, CallToUnsafeFunction); - } else if let &ty::FnDef(func_did, _) = self.thir[fun].ty.kind() { + // check if this is a call to a #[deprecated_safe] fn() and lint if so + // instead of erroring + if let ty::FnDef(func_id, _) = self.thir[fun].ty.kind() + && stability::check_deprecation_as_safe(self.tcx, *func_id, expr.span) + { + self.requires_unsafe( + expr.span, + CallToDeprecatedSafeFunction { depr_as_safe: *func_id }, + ); + } else { + self.requires_unsafe(expr.span, CallToUnsafeFunction); + } + } + + if let &ty::FnDef(func_did, _) = self.thir[fun].ty.kind() { // If the called function has target features the calling function hasn't, // the call requires `unsafe`. Don't check this on wasm // targets, though. For more information on wasm see the @@ -524,6 +550,7 @@ impl BodyUnsafety { #[derive(Clone, Copy, PartialEq)] enum UnsafeOpKind { CallToUnsafeFunction, + CallToDeprecatedSafeFunction { depr_as_safe: DefId }, UseOfInlineAssembly, InitializingTypeWith, UseOfMutableStatic, @@ -546,6 +573,8 @@ impl UnsafeOpKind { "consult the function's documentation for information on how to avoid undefined \ behavior", ), + // unused, report_deprecation_as_safe is used instead + CallToDeprecatedSafeFunction { .. } => ("", ""), UseOfInlineAssembly => ( "use of inline assembly", "inline assembly is entirely unchecked and can cause undefined behavior", diff --git a/compiler/rustc_mir_transform/src/check_unsafety.rs b/compiler/rustc_mir_transform/src/check_unsafety.rs index f5d82315c4e38..463db7a5e3811 100644 --- a/compiler/rustc_mir_transform/src/check_unsafety.rs +++ b/compiler/rustc_mir_transform/src/check_unsafety.rs @@ -4,6 +4,7 @@ use rustc_hir as hir; use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::hir_id::HirId; use rustc_hir::intravisit; +use rustc_middle::middle::stability::{self, DeprecationAsSafeKind}; use rustc_middle::mir::visit::{MutatingUseContext, PlaceContext, Visitor}; use rustc_middle::ty::query::Providers; use rustc_middle::ty::{self, TyCtxt}; @@ -72,10 +73,27 @@ impl<'tcx> Visitor<'tcx> for UnsafetyChecker<'_, 'tcx> { let func_ty = func.ty(self.body, self.tcx); let sig = func_ty.fn_sig(self.tcx); if let hir::Unsafety::Unsafe = sig.unsafety() { - self.require_unsafe( - UnsafetyViolationKind::General, - UnsafetyViolationDetails::CallToUnsafeFunction, - ) + // check if this is a call to a #[deprecated_safe] fn() and lint if so + // instead of erroring + if let ty::FnDef(func_id, _) = func_ty.kind() + && stability::check_deprecation_as_safe( + self.tcx, + *func_id, + self.source_info.span, + ) + { + self.require_unsafe( + UnsafetyViolationKind::DeprecatedSafe { + depr_as_safe: *func_id, + }, + UnsafetyViolationDetails::CallToUnsafeFunction, + ) + } else { + self.require_unsafe( + UnsafetyViolationKind::General, + UnsafetyViolationDetails::CallToUnsafeFunction, + ) + } } if let ty::FnDef(func_id, _) = func_ty.kind() { @@ -289,7 +307,8 @@ impl<'tcx> UnsafetyChecker<'_, 'tcx> { // `unsafe` blocks are required in safe code Safety::Safe => violations.into_iter().for_each(|&violation| { match violation.kind { - UnsafetyViolationKind::General => {} + UnsafetyViolationKind::General + | UnsafetyViolationKind::DeprecatedSafe { .. } => {} UnsafetyViolationKind::UnsafeFn => { bug!("`UnsafetyViolationKind::UnsafeFn` in an `Safe` context") } @@ -300,7 +319,15 @@ impl<'tcx> UnsafetyChecker<'_, 'tcx> { }), // With the RFC 2585, no longer allow `unsafe` operations in `unsafe fn`s Safety::FnUnsafe => violations.into_iter().for_each(|&(mut violation)| { - violation.kind = UnsafetyViolationKind::UnsafeFn; + if unsafe_op_in_unsafe_fn_allowed(self.tcx, violation.lint_root) { + return; + } + + // switch violation kind so that the unsafe_op_in_unsafe_fn lint is emitted instead, + // but preserve any deprecated_safe lint + if !matches!(violation.kind, UnsafetyViolationKind::DeprecatedSafe { .. }) { + violation.kind = UnsafetyViolationKind::UnsafeFn; + } if !self.violations.contains(&violation) { self.violations.push(violation) } @@ -310,10 +337,10 @@ impl<'tcx> UnsafetyChecker<'_, 'tcx> { update_entry( self, hir_id, - match self.tcx.lint_level_at_node(UNSAFE_OP_IN_UNSAFE_FN, violation.lint_root).0 - { - Level::Allow => AllAllowedInUnsafeFn(violation.lint_root), - _ => SomeDisallowedInUnsafeFn, + if unsafe_op_in_unsafe_fn_allowed(self.tcx, violation.lint_root) { + AllAllowedInUnsafeFn(violation.lint_root) + } else { + SomeDisallowedInUnsafeFn }, ) }), @@ -580,8 +607,8 @@ pub fn check_unsafety(tcx: TyCtxt<'_>, def_id: LocalDefId) { let (description, note) = details.description_and_note(); // Report an error. - let unsafe_fn_msg = - if unsafe_op_in_unsafe_fn_allowed(tcx, lint_root) { " function or" } else { "" }; + let unsafe_op_in_unsafe_fn_allowed = unsafe_op_in_unsafe_fn_allowed(tcx, lint_root); + let unsafe_fn_msg = if unsafe_op_in_unsafe_fn_allowed { " function or" } else { "" }; match kind { UnsafetyViolationKind::General => { @@ -612,6 +639,15 @@ pub fn check_unsafety(tcx: TyCtxt<'_>, def_id: LocalDefId) { .emit(); }, ), + UnsafetyViolationKind::DeprecatedSafe { depr_as_safe } => { + stability::report_deprecation_as_safe( + tcx, + DeprecationAsSafeKind::FnCall { unsafe_op_in_unsafe_fn_allowed }, + depr_as_safe, + lint_root, + source_info.span, + ) + } } } From 0e1dc8e8ee7f5004a7e81e8e147a3d51b570d266 Mon Sep 17 00:00:00 2001 From: skippy10110 Date: Fri, 15 Apr 2022 00:00:21 -0300 Subject: [PATCH 3/7] implement deprecated_safe for unsafe->safe fn pointer coercions --- compiler/rustc_borrowck/src/type_check/mod.rs | 14 ++++++- compiler/rustc_codegen_cranelift/src/base.rs | 5 +++ compiler/rustc_codegen_ssa/src/mir/rvalue.rs | 4 +- .../rustc_const_eval/src/interpret/cast.rs | 17 +++++++- .../src/transform/check_consts/check.rs | 1 + compiler/rustc_middle/src/ty/adjustment.rs | 4 ++ compiler/rustc_middle/src/ty/context.rs | 10 ++++- compiler/rustc_typeck/src/check/coercion.rs | 41 ++++++++++++++++++- .../clippy_utils/src/qualify_min_const_fn.rs | 2 +- 9 files changed, 90 insertions(+), 8 deletions(-) diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs index e9fa33f656f31..68f98c1a5c03d 100644 --- a/compiler/rustc_borrowck/src/type_check/mod.rs +++ b/compiler/rustc_borrowck/src/type_check/mod.rs @@ -2011,7 +2011,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { } } - CastKind::Pointer(PointerCast::UnsafeFnPointer) => { + CastKind::Pointer( + ptr_cast @ (PointerCast::UnsafeFnPointer + | PointerCast::DeprecatedSafeFnPointer), + ) => { let fn_sig = op.ty(body, tcx).fn_sig(tcx); // The type that we see in the fcx is like @@ -2021,7 +2024,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { // and hence may contain unnormalized results. let fn_sig = self.normalize(fn_sig, location); - let ty_fn_ptr_from = tcx.safe_to_unsafe_fn_ty(fn_sig); + let ty_fn_ptr_from = match ptr_cast { + PointerCast::UnsafeFnPointer => tcx.safe_to_unsafe_fn_ty(fn_sig), + PointerCast::DeprecatedSafeFnPointer => { + tcx.unsafe_to_safe_fn_ty(fn_sig) + } + // parent match arm matches only these two variants + _ => unreachable!(), + }; if let Err(terr) = self.eq_types( *ty, diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs index a9ff710c91ed6..1d29873b8d847 100644 --- a/compiler/rustc_codegen_cranelift/src/base.rs +++ b/compiler/rustc_codegen_cranelift/src/base.rs @@ -585,6 +585,11 @@ fn codegen_stmt<'tcx>( ref operand, to_ty, ) + | Rvalue::Cast( + CastKind::Pointer(PointerCast::DeprecatedSafeFnPointer), + ref operand, + to_ty, + ) | Rvalue::Cast( CastKind::Pointer(PointerCast::MutToConstPointer), ref operand, diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs index fd29c9e281b92..08eba40cdd6b5 100644 --- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs +++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs @@ -212,7 +212,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { _ => bug!("{} cannot be cast to a fn ptr", operand.layout.ty), } } - mir::CastKind::Pointer(PointerCast::UnsafeFnPointer) => { + mir::CastKind::Pointer( + PointerCast::UnsafeFnPointer | PointerCast::DeprecatedSafeFnPointer, + ) => { // This is a no-op at the LLVM level. operand.val } diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs index a244b79ed0754..a10c48304ca6f 100644 --- a/compiler/rustc_const_eval/src/interpret/cast.rs +++ b/compiler/rustc_const_eval/src/interpret/cast.rs @@ -63,14 +63,27 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { } } - Pointer(PointerCast::UnsafeFnPointer) => { + Pointer( + ptr_cast @ (PointerCast::UnsafeFnPointer | PointerCast::DeprecatedSafeFnPointer), + ) => { let src = self.read_immediate(src)?; match cast_ty.kind() { ty::FnPtr(_) => { // No change to value self.write_immediate(*src, dest)?; } - _ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty), + _ => { + match ptr_cast { + PointerCast::UnsafeFnPointer => { + span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty) + } + PointerCast::DeprecatedSafeFnPointer => { + span_bug!(self.cur_span(), "unsafe fn to fn cast on {:?}", cast_ty) + } + // parent match arm matches only these two variants + _ => unreachable!(), + }; + } } } diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs index e203c79030d20..b5d689027d7c9 100644 --- a/compiler/rustc_const_eval/src/transform/check_consts/check.rs +++ b/compiler/rustc_const_eval/src/transform/check_consts/check.rs @@ -545,6 +545,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> { Rvalue::Cast( CastKind::Pointer( PointerCast::UnsafeFnPointer + | PointerCast::DeprecatedSafeFnPointer | PointerCast::ClosureFnPointer(_) | PointerCast::ReifyFnPointer, ), diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs index 2676b7ab521d8..2476c07b9ec0e 100644 --- a/compiler/rustc_middle/src/ty/adjustment.rs +++ b/compiler/rustc_middle/src/ty/adjustment.rs @@ -14,6 +14,10 @@ pub enum PointerCast { /// Go from a safe fn pointer to an unsafe fn pointer. UnsafeFnPointer, + /// Go from an unsafe fn pointer to a safe fn pointer. + /// This is unsound, but used for backwards compatibility by `#[deprecated_safe]`. + DeprecatedSafeFnPointer, + /// Go from a non-capturing closure to an fn pointer or an unsafe fn pointer. /// It cannot convert a closure that requires unsafe. ClosureFnPointer(hir::Unsafety), diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 6ca8f8b1309fa..15b157637dc44 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -2186,13 +2186,21 @@ slice_interners!( impl<'tcx> TyCtxt<'tcx> { /// Given a `fn` type, returns an equivalent `unsafe fn` type; - /// that is, a `fn` type that is equivalent in every way for being + /// that is, a `fn` type that is equivalent in every way except for being /// unsafe. pub fn safe_to_unsafe_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> { assert_eq!(sig.unsafety(), hir::Unsafety::Normal); self.mk_fn_ptr(sig.map_bound(|sig| ty::FnSig { unsafety: hir::Unsafety::Unsafe, ..sig })) } + /// Given a `unsafe fn` type, returns an equivalent `fn` type; + /// that is, a `fn` type that is equivalent in every way except for being + /// safe. This is unsound, but used for backwards compatibility by `#[deprecated_safe]`. + pub fn unsafe_to_safe_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> { + assert_eq!(sig.unsafety(), hir::Unsafety::Unsafe); + self.mk_fn_ptr(sig.map_bound(|sig| ty::FnSig { unsafety: hir::Unsafety::Normal, ..sig })) + } + /// Given the def_id of a Trait `trait_def_id` and the name of an associated item `assoc_name` /// returns true if the `trait_def_id` defines an associated item of name `assoc_name`. pub fn trait_may_define_assoc_type(self, trait_def_id: DefId, assoc_name: Ident) -> bool { diff --git a/compiler/rustc_typeck/src/check/coercion.rs b/compiler/rustc_typeck/src/check/coercion.rs index 34fc177de6de0..bdb7d75235f6e 100644 --- a/compiler/rustc_typeck/src/check/coercion.rs +++ b/compiler/rustc_typeck/src/check/coercion.rs @@ -46,6 +46,7 @@ use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKi use rustc_infer::infer::{Coercion, InferOk, InferResult}; use rustc_infer::traits::{Obligation, TraitEngine, TraitEngineExt}; use rustc_middle::lint::in_external_macro; +use rustc_middle::middle::stability::{self, DeprecationAsSafeKind}; use rustc_middle::ty::adjustment::{ Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast, }; @@ -720,17 +721,20 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { Ok(coercion) } - fn coerce_from_safe_fn( + fn coerce_from_safe_fn( &self, a: Ty<'tcx>, fn_ty_a: ty::PolyFnSig<'tcx>, b: Ty<'tcx>, to_unsafe: F, normal: G, + fn_def_id_a: Option, + to_safe: H, ) -> CoerceResult<'tcx> where F: FnOnce(Ty<'tcx>) -> Vec>, G: FnOnce(Ty<'tcx>) -> Vec>, + H: FnOnce(Ty<'tcx>) -> Vec>, { if let ty::FnPtr(fn_ty_b) = b.kind() { if let (hir::Unsafety::Normal, hir::Unsafety::Unsafe) = @@ -739,6 +743,24 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { let unsafe_a = self.tcx.safe_to_unsafe_fn_ty(fn_ty_a); return self.unify_and(unsafe_a, b, to_unsafe); } + // check if this is a coercion from a #[deprecated_safe] fn() pointer + // to a safe fn() pointer and lint if so + else if let (hir::Unsafety::Unsafe, hir::Unsafety::Normal) = + (fn_ty_a.unsafety(), fn_ty_b.unsafety()) + && let Some(fn_def_id_a) = fn_def_id_a + && stability::check_deprecation_as_safe(self.tcx(), fn_def_id_a, self.cause.span) + { + stability::report_deprecation_as_safe( + self.tcx(), + DeprecationAsSafeKind::FnPointerCoercion, + fn_def_id_a, + self.cause.body_id, + self.cause.span, + ); + + let safe_a = self.tcx.unsafe_to_safe_fn_ty(fn_ty_a); + return self.unify_and(safe_a, b, to_safe); + } } self.unify_and(a, b, normal) } @@ -762,6 +784,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { b, simple(Adjust::Pointer(PointerCast::UnsafeFnPointer)), identity, + None, + |_| unreachable!(), ) } @@ -796,6 +820,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { obligations.extend(o1); let a_fn_pointer = self.tcx.mk_fn_ptr(a_sig); + let a_fn_def_id = + if let ty::FnDef(def_id, _) = *a.kind() { Some(def_id) } else { None }; let InferOk { value, obligations: o2 } = self.coerce_from_safe_fn( a_fn_pointer, a_sig, @@ -813,6 +839,19 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { ] }, simple(Adjust::Pointer(PointerCast::ReifyFnPointer)), + a_fn_def_id, + |safe_ty| { + vec![ + Adjustment { + kind: Adjust::Pointer(PointerCast::ReifyFnPointer), + target: a_fn_pointer, + }, + Adjustment { + kind: Adjust::Pointer(PointerCast::DeprecatedSafeFnPointer), + target: safe_ty, + }, + ] + }, )?; obligations.extend(o2); diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs index 891531951c1a0..a9c3ac1d4596b 100644 --- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs +++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs @@ -142,7 +142,7 @@ fn check_rvalue<'tcx>( }, Rvalue::Cast( CastKind::Pointer( - PointerCast::UnsafeFnPointer | PointerCast::ClosureFnPointer(_) | PointerCast::ReifyFnPointer, + PointerCast::UnsafeFnPointer | PointerCast::DeprecatedSafeFnPointer | PointerCast::ClosureFnPointer(_) | PointerCast::ReifyFnPointer, ), _, _, From 60a39f749f5d825eaf52bbffce57b1dc3c866a28 Mon Sep 17 00:00:00 2001 From: skippy10110 Date: Fri, 15 Apr 2022 00:01:58 -0300 Subject: [PATCH 4/7] implement deprecated_safe for trait impls and trait function impls --- .../rustc_typeck/src/check/compare_method.rs | 28 ++++++++++++++++-- .../rustc_typeck/src/coherence/unsafety.rs | 29 ++++++++++++++----- 2 files changed, 46 insertions(+), 11 deletions(-) diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs index 0bd5e018f4a38..27f9c9aadd3e2 100644 --- a/compiler/rustc_typeck/src/check/compare_method.rs +++ b/compiler/rustc_typeck/src/check/compare_method.rs @@ -7,6 +7,7 @@ use rustc_hir::intravisit; use rustc_hir::{GenericParamKind, ImplItemKind, TraitItemKind}; use rustc_infer::infer::{self, InferOk, TyCtxtInferExt}; use rustc_infer::traits::util; +use rustc_middle::middle::stability::{self, DeprecationAsSafeKind}; use rustc_middle::ty; use rustc_middle::ty::error::{ExpectedFound, TypeError}; use rustc_middle::ty::subst::{InternalSubsts, Subst}; @@ -262,8 +263,6 @@ fn compare_predicate_entailment<'tcx>( ); let impl_sig = inh.normalize_associated_types_in(impl_m_span, impl_m_hir_id, param_env, impl_sig); - let impl_fty = tcx.mk_fn_ptr(ty::Binder::dummy(impl_sig)); - debug!("compare_impl_method: impl_fty={:?}", impl_fty); // First liberate late bound regions and subst placeholders let trait_sig = tcx.liberate_late_bound_regions(impl_m.def_id, tcx.fn_sig(trait_m.def_id)); @@ -272,8 +271,31 @@ fn compare_predicate_entailment<'tcx>( inh.normalize_associated_types_in(impl_m_span, impl_m_hir_id, param_env, trait_sig); // Add the resulting inputs and output as well-formed. wf_tys.extend(trait_sig.inputs_and_output.iter()); - let trait_fty = tcx.mk_fn_ptr(ty::Binder::dummy(trait_sig)); + // check if this is an impl of a #[deprecated_safe] trait function + // lint if the impl isn't unsafe and match up the FnSig's unsafety + // so there won't be an error + let impl_sig = if impl_sig.unsafety == hir::Unsafety::Normal + && trait_sig.unsafety == hir::Unsafety::Unsafe + && stability::check_deprecation_as_safe(tcx, trait_m.def_id, impl_m_span) + { + stability::report_deprecation_as_safe( + tcx, + DeprecationAsSafeKind::TraitFnImpl, + trait_m.def_id, + impl_m_hir_id, + impl_m_span, + ); + + ty::FnSig { unsafety: trait_sig.unsafety, ..impl_sig } + } else { + impl_sig + }; + + let impl_fty = tcx.mk_fn_ptr(ty::Binder::dummy(impl_sig)); + debug!("compare_impl_method: impl_fty={:?}", impl_fty); + + let trait_fty = tcx.mk_fn_ptr(ty::Binder::dummy(trait_sig)); debug!("compare_impl_method: trait_fty={:?}", trait_fty); let sub_result = infcx.at(&cause, param_env).sup(trait_fty, impl_fty).map( diff --git a/compiler/rustc_typeck/src/coherence/unsafety.rs b/compiler/rustc_typeck/src/coherence/unsafety.rs index f7aabf2406f37..2c5032b31a4f1 100644 --- a/compiler/rustc_typeck/src/coherence/unsafety.rs +++ b/compiler/rustc_typeck/src/coherence/unsafety.rs @@ -5,6 +5,7 @@ use rustc_errors::struct_span_err; use rustc_hir as hir; use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_hir::Unsafety; +use rustc_middle::middle::stability::{self, DeprecationAsSafeKind}; use rustc_middle::ty::TyCtxt; pub fn check(tcx: TyCtxt<'_>) { @@ -42,14 +43,26 @@ impl<'tcx> UnsafetyChecker<'tcx> { } (Unsafety::Unsafe, _, Unsafety::Normal, hir::ImplPolarity::Positive) => { - struct_span_err!( - self.tcx.sess, - item.span, - E0200, - "the trait `{}` requires an `unsafe impl` declaration", - trait_ref.print_only_trait_path() - ) - .emit(); + // check if this is a safe impl of a #[deprecated_safe] trait and lint if so + // instead of erroring + if stability::check_deprecation_as_safe(self.tcx, trait_ref.def_id, item.span) { + stability::report_deprecation_as_safe( + self.tcx, + DeprecationAsSafeKind::TraitImpl, + trait_ref.def_id, + item.hir_id(), + item.span, + ) + } else { + struct_span_err!( + self.tcx.sess, + item.span, + E0200, + "the trait `{}` requires an `unsafe impl` declaration", + trait_ref.print_only_trait_path() + ) + .emit(); + } } ( From 10c17928e8a01bcaf4e02303d09d4d23cbccdb6a Mon Sep 17 00:00:00 2001 From: skippy10110 Date: Fri, 15 Apr 2022 00:02:45 -0300 Subject: [PATCH 5/7] implement deprecated_safe for fn() pointer closure coercions --- compiler/rustc_infer/src/infer/at.rs | 1 + compiler/rustc_infer/src/infer/mod.rs | 47 +++++++++++++-- compiler/rustc_middle/src/traits/select.rs | 11 +++- .../src/traits/error_reporting/mod.rs | 2 +- .../src/traits/fulfill.rs | 54 +++++++++++++++-- .../rustc_trait_selection/src/traits/mod.rs | 13 ---- .../src/traits/query/evaluate_obligation.rs | 6 +- .../src/traits/select/candidate_assembly.rs | 60 ++++++++++++++----- .../src/traits/select/confirmation.rs | 50 +++++++++++++++- .../src/traits/select/mod.rs | 20 +++---- .../rustc_traits/src/evaluate_obligation.rs | 5 +- 11 files changed, 209 insertions(+), 60 deletions(-) diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs index 09b02ba74a8de..a51410d156ee1 100644 --- a/compiler/rustc_infer/src/infer/at.rs +++ b/compiler/rustc_infer/src/infer/at.rs @@ -77,6 +77,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { err_count_on_creation: self.err_count_on_creation, in_snapshot: self.in_snapshot.clone(), universe: self.universe.clone(), + query_mode: self.query_mode.clone(), } } } diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs index 2524bd78355a1..e09aa18596d06 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -354,6 +354,30 @@ pub struct InferCtxt<'a, 'tcx> { /// when we enter into a higher-ranked (`for<..>`) type or trait /// bound. universe: Cell, + + // FIXME(skippy) specifically needs reviewer feedback + // FIXME(skippy) this is added so that i can detect when enter_with_canonical() + // is used, as a way to know that obligations will be coming in + // with bad cause spans that can't be used + // FIXME(skippy) what i really want (i think) is something like + // if !during_borrowck && !during_codegen + /// The mode that trait queries run in, which informs our error handling + /// policy. In essence, canonicalized queries need their errors propagated + /// rather than immediately reported because we do not have accurate spans. + pub query_mode: TraitQueryMode, +} + +/// The mode that trait queries run in. +#[derive(Copy, Clone, PartialEq, Eq, Debug)] +pub enum TraitQueryMode { + /// Standard/un-canonicalized queries get accurate + /// spans etc. passed in and hence can do reasonable + /// error reporting on their own. + Standard, + /// Canonicalized queries get dummy spans and hence + /// must generally propagate errors to + /// pre-canonicalization callsites. + Canonical, } /// See the `error_reporting` module for more details. @@ -615,14 +639,26 @@ impl<'tcx> InferCtxtBuilder<'tcx> { where T: TypeFoldable<'tcx>, { - self.enter(|infcx| { - let (value, subst) = - infcx.instantiate_canonical_with_fresh_inference_vars(span, canonical); - f(infcx, value, subst) - }) + self.enter_with_query_mode( + |infcx| { + let (value, subst) = + infcx.instantiate_canonical_with_fresh_inference_vars(span, canonical); + f(infcx, value, subst) + }, + TraitQueryMode::Canonical, + ) } pub fn enter(&mut self, f: impl for<'a> FnOnce(InferCtxt<'a, 'tcx>) -> R) -> R { + self.enter_with_query_mode(f, TraitQueryMode::Standard) + } + + // FIXME(skippy) specifically needs reviewer feedback (see query_mode field) + fn enter_with_query_mode( + &mut self, + f: impl for<'a> FnOnce(InferCtxt<'a, 'tcx>) -> R, + query_mode: TraitQueryMode, + ) -> R { let InferCtxtBuilder { tcx, defining_use_anchor, ref fresh_typeck_results } = *self; let in_progress_typeck_results = fresh_typeck_results.as_ref(); f(InferCtxt { @@ -640,6 +676,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> { in_snapshot: Cell::new(false), skip_leak_check: Cell::new(false), universe: Cell::new(ty::UniverseIndex::ROOT), + query_mode, }) } } diff --git a/compiler/rustc_middle/src/traits/select.rs b/compiler/rustc_middle/src/traits/select.rs index ffa70cddbd59c..3eb33e7df2263 100644 --- a/compiler/rustc_middle/src/traits/select.rs +++ b/compiler/rustc_middle/src/traits/select.rs @@ -130,6 +130,10 @@ pub enum SelectionCandidate<'tcx> { /// types generated for a fn pointer type (e.g., `fn(int) -> int`) FnPointerCandidate { is_const: bool, + // if a #[deprecated_safe] fn() is being used as a closure, this points + // to the FnDef of that fn(). a deprecated_safe lint must be emitted + // if this candidate is used + depr_as_safe: Option, }, /// Builtin implementation of `DiscriminantKind`. @@ -152,7 +156,12 @@ pub enum SelectionCandidate<'tcx> { BuiltinObjectCandidate, - BuiltinUnsizeCandidate, + BuiltinUnsizeCandidate { + // if a #[deprecated_safe] fn() is being used as a closure, this points + // to the FnDef of that fn(). a deprecated_safe lint must be emitted + // if this candidate is used + depr_as_safe: Option, + }, /// Implementation of `const Destruct`, optionally from a custom `impl const Drop`. ConstDestructCandidate(Option), diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs index 9998c5bb087e1..d2a31e29a6acf 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs @@ -2051,7 +2051,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> { ); let mut selcx = SelectionContext::with_query_mode( &self, - crate::traits::TraitQueryMode::Standard, + crate::infer::TraitQueryMode::Standard, ); match selcx.select_from_obligation(&obligation) { Err(SelectionError::Ambiguous(impls)) if impls.len() > 1 => { diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs index 053e871c14f6e..b60eb1e785e4a 100644 --- a/compiler/rustc_trait_selection/src/traits/fulfill.rs +++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs @@ -5,6 +5,7 @@ use rustc_data_structures::obligation_forest::{Error, ForestObligation, Outcome} use rustc_data_structures::obligation_forest::{ObligationForest, ObligationProcessor}; use rustc_infer::traits::ProjectionCacheKey; use rustc_infer::traits::{SelectionError, TraitEngine, TraitEngineExt as _, TraitObligation}; +use rustc_middle::middle::stability; use rustc_middle::mir::interpret::ErrorHandled; use rustc_middle::thir::abstract_const::NotConstEvaluatable; use rustc_middle::ty::error::{ExpectedFound, TypeError}; @@ -674,8 +675,30 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> { stalled_on: &mut Vec>, ) -> ProcessResult, FulfillmentErrorCode<'tcx>> { let infcx = self.selcx.infcx(); - if obligation.predicate.is_global() { - // no type variables present, can use evaluation for better caching. + let is_global = obligation.predicate.is_global(); + + // FIXME(skippy) specifically needs reviewer feedback + // check if this predicate can't be treated as global due to this being a + // #[deprecated_safe] fn() to closure coercion, if evaluation is used there + // won't be a proper cause span to lint against + let mut is_depr_safe_fn_closure = false; + if is_global && let trait_ty = trait_obligation.self_ty().skip_binder() + && let ty::FnDef(func_id, _) = trait_ty.kind() + && self.selcx.tcx().fn_trait_kind_from_lang_item( + trait_obligation.predicate.skip_binder().trait_ref.def_id + ).is_some() + && stability::check_deprecation_as_safe( + self.selcx.tcx(), + *func_id, + obligation.cause.span, + ) + { + is_depr_safe_fn_closure = true; + } + + if is_global && !is_depr_safe_fn_closure { + // no type variables present and not a #[deprecated_safe] fn() to closure coercion, + // can use evaluation for better caching. // FIXME: consider caching errors too. if infcx.predicate_must_hold_considering_regions(obligation) { debug!( @@ -728,8 +751,31 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> { ) -> ProcessResult, FulfillmentErrorCode<'tcx>> { let tcx = self.selcx.tcx(); - if obligation.predicate.is_global() { - // no type variables present, can use evaluation for better caching. + let is_global = obligation.predicate.is_global(); + + // FIXME(skippy) specifically needs reviewer feedback + // check if this predicate can't be treated as global due to this being a + // #[deprecated_safe] fn() to closure coercion, if evaluation is used there + // won't be a proper cause span to lint against + let mut is_depr_safe_fn_closure = false; + + if is_global && let trait_ty = project_obligation.predicate.skip_binder().projection_ty.self_ty() + && let ty::FnDef(func_id, _) = trait_ty.kind() + && self.selcx.tcx().fn_trait_kind_from_lang_item( + project_obligation.predicate.trait_def_id(self.selcx.tcx()) + ).is_some() + && stability::check_deprecation_as_safe( + self.selcx.tcx(), + *func_id, + obligation.cause.span, + ) + { + is_depr_safe_fn_closure = true; + } + + if is_global && !is_depr_safe_fn_closure { + // no type variables present and not a #[deprecated_safe] fn() to closure coercion, + // can use evaluation for better caching. // FIXME: consider caching errors too. if self.selcx.infcx().predicate_must_hold_considering_regions(obligation) { if let Some(key) = ProjectionCacheKey::from_poly_projection_predicate( diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs index 8240f5c542a61..4491bf75e21db 100644 --- a/compiler/rustc_trait_selection/src/traits/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/mod.rs @@ -98,19 +98,6 @@ impl SkipLeakCheck { } } -/// The mode that trait queries run in. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum TraitQueryMode { - /// Standard/un-canonicalized queries get accurate - /// spans etc. passed in and hence can do reasonable - /// error reporting on their own. - Standard, - /// Canonicalized queries get dummy spans and hence - /// must generally propagate errors to - /// pre-canonicalization callsites. - Canonical, -} - /// Creates predicate obligations from the generic bounds. pub fn predicates_for_generics<'tcx>( cause: ObligationCause<'tcx>, diff --git a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs index db45ee3fed7db..c341d63d4e1b3 100644 --- a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs +++ b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs @@ -1,10 +1,8 @@ use rustc_middle::ty; use crate::infer::canonical::OriginalQueryValues; -use crate::infer::InferCtxt; -use crate::traits::{ - EvaluationResult, OverflowError, PredicateObligation, SelectionContext, TraitQueryMode, -}; +use crate::infer::{InferCtxt, TraitQueryMode}; +use crate::traits::{EvaluationResult, OverflowError, PredicateObligation, SelectionContext}; pub trait InferCtxtExt<'tcx> { fn predicate_may_hold(&self, obligation: &PredicateObligation<'tcx>) -> bool; diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs index 06f5824099237..07bbec2a56d77 100644 --- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs +++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs @@ -11,6 +11,7 @@ use rustc_hir::def_id::DefId; use rustc_infer::traits::TraitEngine; use rustc_infer::traits::{Obligation, SelectionError, TraitObligation}; use rustc_lint_defs::builtin::DEREF_INTO_DYN_SUPERTRAIT; +use rustc_middle::middle::stability; use rustc_middle::ty::print::with_no_trimmed_paths; use rustc_middle::ty::{self, ToPredicate, Ty, TypeFoldable}; use rustc_target::spec::abi::Abi; @@ -495,22 +496,34 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { .. } = self_ty.fn_sig(self.tcx()).skip_binder() { - candidates.vec.push(FnPointerCandidate { is_const: false }); + candidates.vec.push(FnPointerCandidate { is_const: false, depr_as_safe: None }); } } // Provide an impl for suitable functions, rejecting `#[target_feature]` functions (RFC 2396). ty::FnDef(def_id, _) => { - if let ty::FnSig { - unsafety: hir::Unsafety::Normal, - abi: Abi::Rust, - c_variadic: false, - .. - } = self_ty.fn_sig(self.tcx()).skip_binder() + if let ty::FnSig { unsafety, abi: Abi::Rust, c_variadic: false, .. } = + self_ty.fn_sig(self.tcx()).skip_binder() { if self.tcx().codegen_fn_attrs(def_id).target_features.is_empty() { - candidates - .vec - .push(FnPointerCandidate { is_const: self.tcx().is_const_fn(def_id) }); + // check if a #[deprecated_safe] fn() is being used as a closure, a + // deprecated_safe lint must be emitted if this candidate is used + if unsafety == hir::Unsafety::Unsafe + && stability::check_deprecation_as_safe( + self.tcx(), + def_id, + obligation.cause.span, + ) + { + candidates.vec.push(FnPointerCandidate { + is_const: self.tcx().is_const_fn(def_id), + depr_as_safe: Some(def_id), + }); + } else if unsafety == hir::Unsafety::Normal { + candidates.vec.push(FnPointerCandidate { + is_const: self.tcx().is_const_fn(def_id), + depr_as_safe: None, + }); + } } } } @@ -792,7 +805,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let principal_def_id_b = data_b.principal_def_id(); if principal_def_id_a == principal_def_id_b { // no cyclic - candidates.vec.push(BuiltinUnsizeCandidate); + candidates.vec.push(BuiltinUnsizeCandidate { depr_as_safe: None }); } else if principal_def_id_a.is_some() && principal_def_id_b.is_some() { // not casual unsizing, now check whether this is trait upcasting coercion. let principal_a = data_a.principal().unwrap(); @@ -834,8 +847,23 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // `T` -> `Trait` - (_, &ty::Dynamic(..)) => { - candidates.vec.push(BuiltinUnsizeCandidate); + (from, &ty::Dynamic(to_preds, ..)) => { + // check if a #[deprecated_safe] fn() is being used as a closure, a + // deprecated_safe lint must be emitted if this candidate is used + if let ty::FnDef(def_id, _) = *from + && source.fn_sig(self.tcx()).unsafety() == hir::Unsafety::Unsafe + && let Some(trait_def_id) = to_preds.principal_def_id() + && self.tcx().fn_trait_kind_from_lang_item(trait_def_id).is_some() + && stability::check_deprecation_as_safe( + self.tcx(), + def_id, + obligation.cause.span, + ) + { + candidates.vec.push(BuiltinUnsizeCandidate { depr_as_safe: Some(def_id) }); + } else { + candidates.vec.push(BuiltinUnsizeCandidate { depr_as_safe: None }); + } } // Ambiguous handling is below `T` -> `Trait`, because inference @@ -848,20 +876,20 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // `[T; n]` -> `[T]` (&ty::Array(..), &ty::Slice(_)) => { - candidates.vec.push(BuiltinUnsizeCandidate); + candidates.vec.push(BuiltinUnsizeCandidate { depr_as_safe: None }); } // `Struct` -> `Struct` (&ty::Adt(def_id_a, _), &ty::Adt(def_id_b, _)) if def_id_a.is_struct() => { if def_id_a == def_id_b { - candidates.vec.push(BuiltinUnsizeCandidate); + candidates.vec.push(BuiltinUnsizeCandidate { depr_as_safe: None }); } } // `(.., T)` -> `(.., U)` (&ty::Tuple(tys_a), &ty::Tuple(tys_b)) => { if tys_a.len() == tys_b.len() { - candidates.vec.push(BuiltinUnsizeCandidate); + candidates.vec.push(BuiltinUnsizeCandidate { depr_as_safe: None }); } } diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs index b97ab39d991fe..938463b6377f1 100644 --- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs +++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs @@ -9,8 +9,10 @@ use rustc_data_structures::stack::ensure_sufficient_stack; use rustc_hir::lang_items::LangItem; use rustc_index::bit_set::GrowableBitSet; -use rustc_infer::infer::InferOk; use rustc_infer::infer::LateBoundRegionConversionTime::HigherRankedType; +use rustc_infer::infer::{InferOk, TraitQueryMode}; +use rustc_middle::middle::stability::{self, DeprecationAsSafeKind}; +use rustc_middle::traits; use rustc_middle::ty::subst::{GenericArg, GenericArgKind, InternalSubsts, Subst, SubstsRef}; use rustc_middle::ty::{self, GenericParamDefKind, Ty}; use rustc_middle::ty::{ToPolyTraitRef, ToPredicate}; @@ -115,8 +117,29 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(ImplSource::Generator(vtable_generator)) } - FnPointerCandidate { .. } => { + FnPointerCandidate { depr_as_safe, .. } => { let data = self.confirm_fn_pointer_candidate(obligation)?; + // FIXME(skippy) specifically needs reviewer feedback + // FIXME(skippy) the self.infcx.query_mode == TraitQueryMode::Standard is to + // prevent lints during mir_borrowck, when there will be + // DUMMY_SP cause spans + // FIXME(skippy) the param_env.reveal() == traits::Reveal::UserFacing is to prevent + // lints during codegen, when there will be DUMMY_SP cause spans + // FIXME(skippy) this is all very ad-hoc + // emit deprecated_safe lint if this candidate is from a #[deprecated_safe] fn() + // to closure coercion + if let Some(depr_as_safe) = depr_as_safe + && self.infcx.query_mode == TraitQueryMode::Standard + && obligation.param_env.reveal() == traits::Reveal::UserFacing + { + stability::report_deprecation_as_safe( + self.tcx(), + DeprecationAsSafeKind::FnTraitCoercion, + depr_as_safe, + obligation.cause.body_id, + obligation.cause.span, + ); + } Ok(ImplSource::FnPointer(data)) } @@ -138,8 +161,29 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(ImplSource::Param(Vec::new(), ty::BoundConstness::NotConst)) } - BuiltinUnsizeCandidate => { + BuiltinUnsizeCandidate { depr_as_safe } => { let data = self.confirm_builtin_unsize_candidate(obligation)?; + // FIXME(skippy) specifically needs reviewer feedback + // FIXME(skippy) the self.infcx.query_mode == TraitQueryMode::Standard is to + // prevent lints during mir_borrowck, when there will be + // DUMMY_SP cause spans + // FIXME(skippy) the param_env.reveal() == traits::Reveal::UserFacing is to prevent + // lints during codegen, when there will be DUMMY_SP cause spans + // FIXME(skippy) this is all very ad-hoc + // emit deprecated_safe lint if this candidate is from a #[deprecated_safe] fn() + // to closure coercion + if let Some(depr_as_safe) = depr_as_safe + && self.infcx.query_mode == TraitQueryMode::Standard + && obligation.param_env.reveal() == traits::Reveal::UserFacing + { + stability::report_deprecation_as_safe( + self.tcx(), + DeprecationAsSafeKind::FnTraitCoercion, + depr_as_safe, + obligation.cause.body_id, + obligation.cause.span, + ); + } Ok(ImplSource::Builtin(data)) } diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs index e69bf6eca90ef..e44859fd1c633 100644 --- a/compiler/rustc_trait_selection/src/traits/select/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs @@ -16,7 +16,7 @@ use super::wf; use super::{ DerivedObligationCause, ErrorReporting, ImplDerivedObligation, ImplDerivedObligationCause, Normalized, Obligation, ObligationCause, ObligationCauseCode, Overflow, PredicateObligation, - Selection, SelectionError, SelectionResult, TraitObligation, TraitQueryMode, + Selection, SelectionError, SelectionResult, TraitObligation, }; use crate::infer::{InferCtxt, InferOk, TypeFreshener}; @@ -29,7 +29,7 @@ use rustc_data_structures::stack::ensure_sufficient_stack; use rustc_errors::{Diagnostic, ErrorGuaranteed}; use rustc_hir as hir; use rustc_hir::def_id::DefId; -use rustc_infer::infer::LateBoundRegionConversionTime; +use rustc_infer::infer::{LateBoundRegionConversionTime, TraitQueryMode}; use rustc_middle::dep_graph::{DepKind, DepNodeIndex}; use rustc_middle::mir::interpret::ErrorHandled; use rustc_middle::thir::abstract_const::NotConstEvaluatable; @@ -1159,7 +1159,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // or ignore error with const_async_blocks feature GeneratorCandidate => {} // FnDef where the function is const - FnPointerCandidate { is_const: true } => {} + FnPointerCandidate { is_const: true, .. } => {} ConstDestructCandidate(_) => {} _ => { // reject all other types of candidates @@ -1623,7 +1623,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // Drop otherwise equivalent non-const fn pointer candidates - (FnPointerCandidate { .. }, FnPointerCandidate { is_const: false }) => true, + (FnPointerCandidate { .. }, FnPointerCandidate { is_const: false, .. }) => true, // If obligation is a sized predicate or the where-clause bound is // global, prefer the projection or object candidate. See issue @@ -1647,7 +1647,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | GeneratorCandidate | FnPointerCandidate { .. } | BuiltinObjectCandidate - | BuiltinUnsizeCandidate + | BuiltinUnsizeCandidate { .. } | TraitUpcastingUnsizeCandidate(_) | BuiltinCandidate { .. } | TraitAliasCandidate(..), @@ -1658,7 +1658,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | GeneratorCandidate | FnPointerCandidate { .. } | BuiltinObjectCandidate - | BuiltinUnsizeCandidate + | BuiltinUnsizeCandidate { .. } | TraitUpcastingUnsizeCandidate(_) | BuiltinCandidate { has_nested: true } | TraitAliasCandidate(..), @@ -1688,7 +1688,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | GeneratorCandidate | FnPointerCandidate { .. } | BuiltinObjectCandidate - | BuiltinUnsizeCandidate + | BuiltinUnsizeCandidate { .. } | TraitUpcastingUnsizeCandidate(_) | BuiltinCandidate { .. } | TraitAliasCandidate(..), @@ -1700,7 +1700,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | GeneratorCandidate | FnPointerCandidate { .. } | BuiltinObjectCandidate - | BuiltinUnsizeCandidate + | BuiltinUnsizeCandidate { .. } | TraitUpcastingUnsizeCandidate(_) | BuiltinCandidate { .. } | TraitAliasCandidate(..), @@ -1781,7 +1781,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | GeneratorCandidate | FnPointerCandidate { .. } | BuiltinObjectCandidate - | BuiltinUnsizeCandidate + | BuiltinUnsizeCandidate { .. } | TraitUpcastingUnsizeCandidate(_) | BuiltinCandidate { has_nested: true } | TraitAliasCandidate(..), @@ -1790,7 +1790,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | GeneratorCandidate | FnPointerCandidate { .. } | BuiltinObjectCandidate - | BuiltinUnsizeCandidate + | BuiltinUnsizeCandidate { .. } | TraitUpcastingUnsizeCandidate(_) | BuiltinCandidate { has_nested: true } | TraitAliasCandidate(..), diff --git a/compiler/rustc_traits/src/evaluate_obligation.rs b/compiler/rustc_traits/src/evaluate_obligation.rs index 2404b7ff4b54a..b617df71ba107 100644 --- a/compiler/rustc_traits/src/evaluate_obligation.rs +++ b/compiler/rustc_traits/src/evaluate_obligation.rs @@ -1,12 +1,11 @@ -use rustc_infer::infer::TyCtxtInferExt; +use rustc_infer::infer::{TraitQueryMode, TyCtxtInferExt}; use rustc_middle::ty::query::Providers; use rustc_middle::ty::{ParamEnvAnd, TyCtxt}; use rustc_span::source_map::DUMMY_SP; use rustc_trait_selection::traits::query::CanonicalPredicateGoal; use rustc_trait_selection::traits::{ - EvaluationResult, Obligation, ObligationCause, OverflowError, SelectionContext, TraitQueryMode, + EvaluationResult, Obligation, ObligationCause, OverflowError, SelectionContext, }; - crate fn provide(p: &mut Providers) { *p = Providers { evaluate_obligation, ..*p }; } From dceec513df97cd03b2af1a48e82e86cb56ef6489 Mon Sep 17 00:00:00 2001 From: skippy10110 Date: Fri, 15 Apr 2022 00:03:33 -0300 Subject: [PATCH 6/7] add ui tests (better organization needed) --- .../auxiliary/deprecated-safe.rs | 61 + .../deprecated-safe-attr.mir.stderr | 76 + .../deprecated-safe/deprecated-safe-attr.rs | 64 + .../deprecated-safe-attr.thir.stderr | 76 + .../deprecated-safe-mismatch.mir.stderr | 21 + .../deprecated-safe-mismatch.rs | 22 + .../deprecated-safe-mismatch.thir.stderr | 21 + .../deprecated-safe-trait-fn.mir.stderr | 43 + .../deprecated-safe-trait-fn.rs | 31 + .../deprecated-safe-trait-fn.thir.stderr | 43 + .../deprecated-safe-trait-impl.mir.stderr | 58 + .../deprecated-safe-trait-impl.rs | 50 + .../deprecated-safe-trait-impl.thir.stderr | 58 + ...ecated-safe-unsafe-edition-call.mir.stderr | 22 + .../deprecated-safe-unsafe-edition-call.rs | 26 + ...cated-safe-unsafe-edition-call.thir.stderr | 22 + ...ecated-safe-unsafe-edition-impl.mir.stderr | 20 + .../deprecated-safe-unsafe-edition-impl.rs | 24 + ...cated-safe-unsafe-edition-impl.thir.stderr | 20 + .../deprecated-safe-unsafe-edition.mir.stderr | 453 ++++++ .../deprecated-safe-unsafe-edition.rs | 111 ++ ...deprecated-safe-unsafe-edition.thir.stderr | 453 ++++++ ...ted-safe-unsafe-op-in-unsafe-fn.mir.stderr | 119 ++ .../deprecated-safe-unsafe-op-in-unsafe-fn.rs | 56 + ...ed-safe-unsafe-op-in-unsafe-fn.thir.stderr | 137 ++ .../deprecated-safe.mir.stderr | 1238 +++++++++++++++++ .../ui/deprecated-safe/deprecated-safe.rs | 355 +++++ .../deprecated-safe.thir.stderr | 1238 +++++++++++++++++ 28 files changed, 4918 insertions(+) create mode 100644 src/test/ui/deprecated-safe/auxiliary/deprecated-safe.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-attr.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-attr.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-attr.thir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-mismatch.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-mismatch.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-mismatch.thir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-trait-fn.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-trait-fn.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-trait-fn.thir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-trait-impl.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-trait-impl.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-trait-impl.thir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.thir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.thir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.thir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.thir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe.mir.stderr create mode 100644 src/test/ui/deprecated-safe/deprecated-safe.rs create mode 100644 src/test/ui/deprecated-safe/deprecated-safe.thir.stderr diff --git a/src/test/ui/deprecated-safe/auxiliary/deprecated-safe.rs b/src/test/ui/deprecated-safe/auxiliary/deprecated-safe.rs new file mode 100644 index 0000000000000..887baf0e4a626 --- /dev/null +++ b/src/test/ui/deprecated-safe/auxiliary/deprecated-safe.rs @@ -0,0 +1,61 @@ +#![feature(deprecated_safe)] +#![feature(staged_api)] +#![stable(feature = "deprecated-safe-test", since = "1.61.0")] +#![warn(unused_unsafe)] + +use std::ffi::OsStr; + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +#[deprecated_safe(since = "1.61.0", note = "reason")] +pub unsafe fn depr_safe() {} + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +#[deprecated_safe(since = "1.61.0", note = "reason")] +pub unsafe fn depr_safe_params(_: u32, _: u64) {} + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +#[deprecated_safe(since = "1.61.0", note = "reason")] +pub unsafe fn depr_safe_generic, V: AsRef>(key: K, value: V) {} + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +#[deprecated_safe(since = "1.61.0", note = "reason", unsafe_edition = "2015")] +pub unsafe fn depr_safe_2015() {} + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +#[deprecated_safe(since = "1.61.0", note = "reason", unsafe_edition = "2018")] +pub unsafe fn depr_safe_2018() {} + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +#[deprecated_safe(since = "1.61.0", note = "reason")] +pub unsafe trait DeprSafe {} + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +#[deprecated_safe(since = "1.61.0", note = "reason", unsafe_edition = "2015")] +pub unsafe trait DeprSafe2015 {} + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +#[deprecated_safe(since = "1.61.0", note = "reason", unsafe_edition = "2018")] +pub unsafe trait DeprSafe2018 {} + +#[stable(feature = "deprecated-safe-test", since = "1.61.0")] +pub trait DeprSafeFns { + #[stable(feature = "deprecated-safe-test", since = "1.61.0")] + #[deprecated_safe(since = "1.61.0", note = "reason")] + unsafe fn depr_safe_fn(&self) {} + + #[stable(feature = "deprecated-safe-test", since = "1.61.0")] + #[deprecated_safe(since = "1.61.0", note = "reason")] + unsafe fn depr_safe_params(&self, _: u32, _: u64) {} + + #[stable(feature = "deprecated-safe-test", since = "1.61.0")] + #[deprecated_safe(since = "1.61.0", note = "reason")] + unsafe fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} + + #[stable(feature = "deprecated-safe-test", since = "1.61.0")] + #[deprecated_safe(since = "1.61.0", note = "reason", unsafe_edition = "2015")] + unsafe fn depr_safe_fn_2015(&self) {} + + #[stable(feature = "deprecated-safe-test", since = "1.61.0")] + #[deprecated_safe(since = "1.61.0", note = "reason", unsafe_edition = "2018")] + unsafe fn depr_safe_fn_2018(&self) {} +} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-attr.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-attr.mir.stderr new file mode 100644 index 0000000000000..ba1a7bd41c6f5 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-attr.mir.stderr @@ -0,0 +1,76 @@ +error[E0543]: 'unsafe_edition' is invalid outside of rustc + --> $DIR/deprecated-safe-attr.rs:15:1 + | +LL | #[deprecated_safe(since = "1.61.0", unsafe_edition = "2015", note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0543]: 'unsafe_edition' is invalid outside of rustc + --> $DIR/deprecated-safe-attr.rs:18:1 + | +LL | #[deprecated_safe(since = "1.61.0", unsafe_edition = "BAD", note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0543]: 'unsafe_edition' is invalid outside of rustc + --> $DIR/deprecated-safe-attr.rs:21:1 + | +LL | #[deprecated_safe(since = "TBD", unsafe_edition = "BAD", note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: multiple `deprecated_safe` attributes + --> $DIR/deprecated-safe-attr.rs:37:1 + | +LL | #[deprecated_safe(note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute + | +note: attribute also specified here + --> $DIR/deprecated-safe-attr.rs:36:1 + | +LL | #[deprecated_safe(since = "1.61.0")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0541]: unknown meta item 'extra' + --> $DIR/deprecated-safe-attr.rs:40:37 + | +LL | #[deprecated_safe(since = "1.61.0", extra = "")] + | ^^^^^^^^^^ + +error[E0538]: multiple 'since' items + --> $DIR/deprecated-safe-attr.rs:43:1 + | +LL | #[deprecated_safe(since = "1.61.0", since = "1.61.0")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0551]: incorrect meta item 'since' + --> $DIR/deprecated-safe-attr.rs:46:19 + | +LL | #[deprecated_safe(since)] + | ^^^^^ + +error[E0565]: literal in `deprecated_safe` value must be a string + --> $DIR/deprecated-safe-attr.rs:49:27 + | +LL | #[deprecated_safe(since = 1_61_0)] + | ^^^^^^ + +error[E0565]: item in `deprecated_safe` must be a key/value pair + --> $DIR/deprecated-safe-attr.rs:52:19 + | +LL | #[deprecated_safe(1_61_0)] + | ^^^^^^ + +error[E0543]: this `#[deprecated_safe]` annotation has no effect + --> $DIR/deprecated-safe-attr.rs:55:1 + | +LL | #[deprecated_safe(since = "1.61.0")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0543]: this `#[deprecated_safe]` annotation has no effect + --> $DIR/deprecated-safe-attr.rs:60:5 + | +LL | #[deprecated_safe(since = "1.61.0", note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 11 previous errors + +Some errors have detailed explanations: E0538, E0541, E0543, E0551, E0565. +For more information about an error, try `rustc --explain E0538`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-attr.rs b/src/test/ui/deprecated-safe/deprecated-safe-attr.rs new file mode 100644 index 0000000000000..149603dd4c6d3 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-attr.rs @@ -0,0 +1,64 @@ +// aux-build:deprecated-safe.rs +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +#![feature(deprecated_safe)] +#![feature(type_alias_impl_trait)] +#![warn(unused_unsafe)] + +extern crate deprecated_safe; + +use deprecated_safe::DeprSafeFns; + +#[deprecated_safe(since = "1.61.0", unsafe_edition = "2015", note = "reason")] //~ ERROR 'unsafe_edition' is invalid outside of rustc +unsafe fn foo0() {} + +#[deprecated_safe(since = "1.61.0", unsafe_edition = "BAD", note = "reason")] //~ ERROR 'unsafe_edition' is invalid outside of rustc +unsafe fn foo1() {} + +#[deprecated_safe(since = "TBD", unsafe_edition = "BAD", note = "reason")] //~ ERROR 'unsafe_edition' is invalid outside of rustc +unsafe fn foo2() {} + +#[deprecated_safe] +unsafe fn foo3() {} + +#[deprecated_safe = "hi"] +unsafe fn foo4() {} + +#[deprecated_safe(since = "1.61.0")] +unsafe fn foo5() {} + +#[deprecated_safe(note = "reason")] +unsafe fn foo6() {} + +#[deprecated_safe(since = "1.61.0")] +#[deprecated_safe(note = "reason")] //~ ERROR multiple `deprecated_safe` attributes +unsafe fn foo7() {} + +#[deprecated_safe(since = "1.61.0", extra = "")] //~ ERROR unknown meta item 'extra' +unsafe fn foo8() {} + +#[deprecated_safe(since = "1.61.0", since = "1.61.0")] //~ ERROR multiple 'since' items +unsafe fn foo9() {} + +#[deprecated_safe(since)] //~ ERROR incorrect meta item +unsafe fn foo10() {} + +#[deprecated_safe(since = 1_61_0)] //~ ERROR literal in `deprecated_safe` value must be a string +unsafe fn foo11() {} + +#[deprecated_safe(1_61_0)] //~ ERROR item in `deprecated_safe` must be a key/value pair +unsafe fn foo12() {} + +#[deprecated_safe(since = "1.61.0")] //~ ERROR this `#[deprecated_safe]` annotation has no effect +static FOO0: u32 = 0; + +struct BadAnnotation; +impl DeprSafeFns for BadAnnotation { + #[deprecated_safe(since = "1.61.0", note = "reason")] //~ ERROR this `#[deprecated_safe]` annotation has no effect + unsafe fn depr_safe_fn(&self) {} +} + +fn main() {} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-attr.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-attr.thir.stderr new file mode 100644 index 0000000000000..ba1a7bd41c6f5 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-attr.thir.stderr @@ -0,0 +1,76 @@ +error[E0543]: 'unsafe_edition' is invalid outside of rustc + --> $DIR/deprecated-safe-attr.rs:15:1 + | +LL | #[deprecated_safe(since = "1.61.0", unsafe_edition = "2015", note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0543]: 'unsafe_edition' is invalid outside of rustc + --> $DIR/deprecated-safe-attr.rs:18:1 + | +LL | #[deprecated_safe(since = "1.61.0", unsafe_edition = "BAD", note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0543]: 'unsafe_edition' is invalid outside of rustc + --> $DIR/deprecated-safe-attr.rs:21:1 + | +LL | #[deprecated_safe(since = "TBD", unsafe_edition = "BAD", note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: multiple `deprecated_safe` attributes + --> $DIR/deprecated-safe-attr.rs:37:1 + | +LL | #[deprecated_safe(note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute + | +note: attribute also specified here + --> $DIR/deprecated-safe-attr.rs:36:1 + | +LL | #[deprecated_safe(since = "1.61.0")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0541]: unknown meta item 'extra' + --> $DIR/deprecated-safe-attr.rs:40:37 + | +LL | #[deprecated_safe(since = "1.61.0", extra = "")] + | ^^^^^^^^^^ + +error[E0538]: multiple 'since' items + --> $DIR/deprecated-safe-attr.rs:43:1 + | +LL | #[deprecated_safe(since = "1.61.0", since = "1.61.0")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0551]: incorrect meta item 'since' + --> $DIR/deprecated-safe-attr.rs:46:19 + | +LL | #[deprecated_safe(since)] + | ^^^^^ + +error[E0565]: literal in `deprecated_safe` value must be a string + --> $DIR/deprecated-safe-attr.rs:49:27 + | +LL | #[deprecated_safe(since = 1_61_0)] + | ^^^^^^ + +error[E0565]: item in `deprecated_safe` must be a key/value pair + --> $DIR/deprecated-safe-attr.rs:52:19 + | +LL | #[deprecated_safe(1_61_0)] + | ^^^^^^ + +error[E0543]: this `#[deprecated_safe]` annotation has no effect + --> $DIR/deprecated-safe-attr.rs:55:1 + | +LL | #[deprecated_safe(since = "1.61.0")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0543]: this `#[deprecated_safe]` annotation has no effect + --> $DIR/deprecated-safe-attr.rs:60:5 + | +LL | #[deprecated_safe(since = "1.61.0", note = "reason")] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 11 previous errors + +Some errors have detailed explanations: E0538, E0541, E0543, E0551, E0565. +For more information about an error, try `rustc --explain E0538`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-mismatch.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-mismatch.mir.stderr new file mode 100644 index 0000000000000..499f504172214 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-mismatch.mir.stderr @@ -0,0 +1,21 @@ +error[E0543]: item must be marked unsafe + --> $DIR/deprecated-safe-mismatch.rs:12:1 + | +LL | fn foo0() {} + | ^^^^^^^^^^^^ + +error[E0543]: item must be marked unsafe + --> $DIR/deprecated-safe-mismatch.rs:15:1 + | +LL | trait PreviouslySafeTrait {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0543]: item must be marked unsafe + --> $DIR/deprecated-safe-mismatch.rs:19:5 + | +LL | fn foo0(); + | ^^^^^^^^^^ + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0543`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-mismatch.rs b/src/test/ui/deprecated-safe/deprecated-safe-mismatch.rs new file mode 100644 index 0000000000000..4159b210e5bb9 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-mismatch.rs @@ -0,0 +1,22 @@ +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +#![feature(deprecated_safe)] +#![warn(unused_unsafe)] + +use std::ffi::{OsStr, OsString}; + +#[deprecated_safe(since = "1.61.0", note = "reason")] +fn foo0() {} //~ ERROR item must be marked unsafe + +#[deprecated_safe(since = "1.61.0", note = "reason")] +trait PreviouslySafeTrait {} //~ ERROR item must be marked unsafe + +trait PreviouslySafeFunctions { + #[deprecated_safe(since = "1.61.0", note = "reason")] + fn foo0(); //~ ERROR item must be marked unsafe +} + +fn main() {} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-mismatch.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-mismatch.thir.stderr new file mode 100644 index 0000000000000..499f504172214 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-mismatch.thir.stderr @@ -0,0 +1,21 @@ +error[E0543]: item must be marked unsafe + --> $DIR/deprecated-safe-mismatch.rs:12:1 + | +LL | fn foo0() {} + | ^^^^^^^^^^^^ + +error[E0543]: item must be marked unsafe + --> $DIR/deprecated-safe-mismatch.rs:15:1 + | +LL | trait PreviouslySafeTrait {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0543]: item must be marked unsafe + --> $DIR/deprecated-safe-mismatch.rs:19:5 + | +LL | fn foo0(); + | ^^^^^^^^^^ + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0543`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.mir.stderr new file mode 100644 index 0000000000000..37fb3d640b13f --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.mir.stderr @@ -0,0 +1,43 @@ +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe-trait-fn.rs:17:5 + | +LL | fn depr_safe_fn(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe-trait-fn.rs:18:5 + | +LL | fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +error[E0053]: method `depr_safe_fn_2015` has an incompatible type for trait + --> $DIR/deprecated-safe-trait-fn.rs:19:5 + | +LL | fn depr_safe_fn_2015(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected unsafe fn, found normal fn + | + = note: expected fn pointer `unsafe fn(&BadImpls)` + found fn pointer `fn(&BadImpls)` + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe-trait-fn.rs:20:5 + | +LL | fn depr_safe_fn_2018(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to previous error; 3 warnings emitted + +For more information about this error, try `rustc --explain E0053`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.rs b/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.rs new file mode 100644 index 0000000000000..04fd8b4c35e73 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.rs @@ -0,0 +1,31 @@ +// aux-build:deprecated-safe.rs +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +#![feature(deprecated_safe)] +#![warn(unused_unsafe)] + +extern crate deprecated_safe; + +use deprecated_safe::DeprSafeFns; +use std::ffi::OsStr; + +struct BadImpls; +impl DeprSafeFns for BadImpls { + fn depr_safe_fn(&self) {} //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + fn depr_safe_fn_2015(&self) {} //~ ERROR method `depr_safe_fn_2015` has an incompatible type for trait + fn depr_safe_fn_2018(&self) {} //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function +} + +struct GoodImpls; +impl DeprSafeFns for GoodImpls { + unsafe fn depr_safe_fn(&self) {} + unsafe fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} + unsafe fn depr_safe_fn_2015(&self) {} + unsafe fn depr_safe_fn_2018(&self) {} +} + +fn main() {} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.thir.stderr new file mode 100644 index 0000000000000..37fb3d640b13f --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-trait-fn.thir.stderr @@ -0,0 +1,43 @@ +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe-trait-fn.rs:17:5 + | +LL | fn depr_safe_fn(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe-trait-fn.rs:18:5 + | +LL | fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +error[E0053]: method `depr_safe_fn_2015` has an incompatible type for trait + --> $DIR/deprecated-safe-trait-fn.rs:19:5 + | +LL | fn depr_safe_fn_2015(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected unsafe fn, found normal fn + | + = note: expected fn pointer `unsafe fn(&BadImpls)` + found fn pointer `fn(&BadImpls)` + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe-trait-fn.rs:20:5 + | +LL | fn depr_safe_fn_2018(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to previous error; 3 warnings emitted + +For more information about this error, try `rustc --explain E0053`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.mir.stderr new file mode 100644 index 0000000000000..50c688d2ae34f --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.mir.stderr @@ -0,0 +1,58 @@ +error[E0198]: negative impls cannot be unsafe + --> $DIR/deprecated-safe-trait-impl.rs:24:13 + | +LL | unsafe impl !DeprSafe for D {} + | ------ -^^^^^^^^ + | | | + | | negative because of this + | unsafe because of this + +error[E0198]: negative impls cannot be unsafe + --> $DIR/deprecated-safe-trait-impl.rs:36:13 + | +LL | unsafe impl !DeprSafe2015 for L {} + | ------ -^^^^^^^^^^^^ + | | | + | | negative because of this + | unsafe because of this + +error[E0198]: negative impls cannot be unsafe + --> $DIR/deprecated-safe-trait-impl.rs:48:13 + | +LL | unsafe impl !DeprSafe2018 for T {} + | ------ -^^^^^^^^^^^^ + | | | + | | negative because of this + | unsafe because of this + +warning: use of trait `deprecated_safe::DeprSafe` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + --> $DIR/deprecated-safe-trait-impl.rs:15:1 + | +LL | impl DeprSafe for A {} + | ^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this trait was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the trait's documentation for information on how to avoid undefined behavior + = note: reason + +error[E0200]: the trait `DeprSafe2015` requires an `unsafe impl` declaration + --> $DIR/deprecated-safe-trait-impl.rs:27:1 + | +LL | impl DeprSafe2015 for I {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + +warning: use of trait `deprecated_safe::DeprSafe2018` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + --> $DIR/deprecated-safe-trait-impl.rs:39:1 + | +LL | impl DeprSafe2018 for M {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this trait was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the trait's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to 4 previous errors; 2 warnings emitted + +Some errors have detailed explanations: E0198, E0200. +For more information about an error, try `rustc --explain E0198`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.rs b/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.rs new file mode 100644 index 0000000000000..c022a8f90ccc7 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.rs @@ -0,0 +1,50 @@ +// aux-build:deprecated-safe.rs +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +#![feature(negative_impls)] +#![warn(unused_unsafe)] + +extern crate deprecated_safe; + +use deprecated_safe::{DeprSafe, DeprSafe2015, DeprSafe2018}; + +struct A; +impl DeprSafe for A {} //~ WARN use of trait `deprecated_safe::DeprSafe` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + +struct B; +unsafe impl DeprSafe for B {} + +struct C; +impl !DeprSafe for C {} + +struct D; +unsafe impl !DeprSafe for D {} //~ ERROR negative impls cannot be unsafe + +struct I; +impl DeprSafe2015 for I {} //~ ERROR the trait `DeprSafe2015` requires an `unsafe impl` declaration + +struct J; +unsafe impl DeprSafe2015 for J {} + +struct K; +impl !DeprSafe2015 for K {} + +struct L; +unsafe impl !DeprSafe2015 for L {} //~ ERROR negative impls cannot be unsafe + +struct M; +impl DeprSafe2018 for M {} //~ WARN use of trait `deprecated_safe::DeprSafe2018` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + +struct R; +unsafe impl DeprSafe2018 for R {} + +struct S; +impl !DeprSafe2018 for S {} + +struct T; +unsafe impl !DeprSafe2018 for T {} //~ ERROR negative impls cannot be unsafe + +fn main() {} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.thir.stderr new file mode 100644 index 0000000000000..50c688d2ae34f --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-trait-impl.thir.stderr @@ -0,0 +1,58 @@ +error[E0198]: negative impls cannot be unsafe + --> $DIR/deprecated-safe-trait-impl.rs:24:13 + | +LL | unsafe impl !DeprSafe for D {} + | ------ -^^^^^^^^ + | | | + | | negative because of this + | unsafe because of this + +error[E0198]: negative impls cannot be unsafe + --> $DIR/deprecated-safe-trait-impl.rs:36:13 + | +LL | unsafe impl !DeprSafe2015 for L {} + | ------ -^^^^^^^^^^^^ + | | | + | | negative because of this + | unsafe because of this + +error[E0198]: negative impls cannot be unsafe + --> $DIR/deprecated-safe-trait-impl.rs:48:13 + | +LL | unsafe impl !DeprSafe2018 for T {} + | ------ -^^^^^^^^^^^^ + | | | + | | negative because of this + | unsafe because of this + +warning: use of trait `deprecated_safe::DeprSafe` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + --> $DIR/deprecated-safe-trait-impl.rs:15:1 + | +LL | impl DeprSafe for A {} + | ^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this trait was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the trait's documentation for information on how to avoid undefined behavior + = note: reason + +error[E0200]: the trait `DeprSafe2015` requires an `unsafe impl` declaration + --> $DIR/deprecated-safe-trait-impl.rs:27:1 + | +LL | impl DeprSafe2015 for I {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + +warning: use of trait `deprecated_safe::DeprSafe2018` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + --> $DIR/deprecated-safe-trait-impl.rs:39:1 + | +LL | impl DeprSafe2018 for M {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this trait was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the trait's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to 4 previous errors; 2 warnings emitted + +Some errors have detailed explanations: E0198, E0200. +For more information about an error, try `rustc --explain E0198`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.mir.stderr new file mode 100644 index 0000000000000..0c397228e769d --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.mir.stderr @@ -0,0 +1,22 @@ +error[E0133]: call to unsafe function is unsafe and requires unsafe function or block + --> $DIR/deprecated-safe-unsafe-edition-call.rs:18:5 + | +LL | depr_safe_2015(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: consult the function's documentation for information on how to avoid undefined behavior + +warning: use of function `deprecated_safe::depr_safe_2018` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition-call.rs:19:5 + | +LL | depr_safe_2018(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to previous error; 1 warning emitted + +For more information about this error, try `rustc --explain E0133`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.rs b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.rs new file mode 100644 index 0000000000000..51eea3cd8ad0a --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.rs @@ -0,0 +1,26 @@ +// aux-build:deprecated-safe.rs +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +#![warn(unused_unsafe)] + +extern crate deprecated_safe; + +use deprecated_safe::{depr_safe_2015, depr_safe_2018}; + +fn main() { + // NOTE: this test is separate from deprecated-safe-unsafe-edition as the other compiler + // errors will stop compilation before these calls are checked + + // usage without unsafe should lint + depr_safe_2015(); //~ ERROR call to unsafe function is unsafe and requires unsafe function or block + depr_safe_2018(); //~ WARN use of function `deprecated_safe::depr_safe_2018` without an unsafe function or block has been deprecated as it is now an unsafe function + + // these shouldn't lint, appropriate unsafe usage + unsafe { + depr_safe_2015(); + depr_safe_2018(); + } +} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.thir.stderr new file mode 100644 index 0000000000000..0c397228e769d --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-call.thir.stderr @@ -0,0 +1,22 @@ +error[E0133]: call to unsafe function is unsafe and requires unsafe function or block + --> $DIR/deprecated-safe-unsafe-edition-call.rs:18:5 + | +LL | depr_safe_2015(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: consult the function's documentation for information on how to avoid undefined behavior + +warning: use of function `deprecated_safe::depr_safe_2018` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition-call.rs:19:5 + | +LL | depr_safe_2018(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to previous error; 1 warning emitted + +For more information about this error, try `rustc --explain E0133`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.mir.stderr new file mode 100644 index 0000000000000..ed3f354335c52 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.mir.stderr @@ -0,0 +1,20 @@ +error[E0200]: the trait `DeprSafe2015` requires an `unsafe impl` declaration + --> $DIR/deprecated-safe-unsafe-edition-impl.rs:14:1 + | +LL | impl DeprSafe2015 for DeprSafeImpl {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +warning: use of trait `deprecated_safe::DeprSafe2018` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + --> $DIR/deprecated-safe-unsafe-edition-impl.rs:15:1 + | +LL | impl DeprSafe2018 for DeprSafeImpl {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this trait was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the trait's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to previous error; 1 warning emitted + +For more information about this error, try `rustc --explain E0200`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.rs b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.rs new file mode 100644 index 0000000000000..6a8817ebe1697 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.rs @@ -0,0 +1,24 @@ +// aux-build:deprecated-safe.rs +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +#![warn(unused_unsafe)] + +extern crate deprecated_safe; + +use deprecated_safe::{DeprSafe2015, DeprSafe2018}; + +struct DeprSafeImpl; +impl DeprSafe2015 for DeprSafeImpl {} //~ ERROR the trait `DeprSafe2015` requires an `unsafe impl` declaration +impl DeprSafe2018 for DeprSafeImpl {} //~ WARN use of trait `deprecated_safe::DeprSafe2018` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + +struct DeprSafeUnsafeImpl; +unsafe impl DeprSafe2015 for DeprSafeUnsafeImpl {} +unsafe impl DeprSafe2018 for DeprSafeUnsafeImpl {} + +fn main() { + // NOTE: this test is separate from deprecated-safe-unsafe-edition as the other compiler + // errors will stop compilation before these calls are checked +} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.thir.stderr new file mode 100644 index 0000000000000..ed3f354335c52 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition-impl.thir.stderr @@ -0,0 +1,20 @@ +error[E0200]: the trait `DeprSafe2015` requires an `unsafe impl` declaration + --> $DIR/deprecated-safe-unsafe-edition-impl.rs:14:1 + | +LL | impl DeprSafe2015 for DeprSafeImpl {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +warning: use of trait `deprecated_safe::DeprSafe2018` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + --> $DIR/deprecated-safe-unsafe-edition-impl.rs:15:1 + | +LL | impl DeprSafe2018 for DeprSafeImpl {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this trait was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the trait's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to previous error; 1 warning emitted + +For more information about this error, try `rustc --explain E0200`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.mir.stderr new file mode 100644 index 0000000000000..8f29122291cbb --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.mir.stderr @@ -0,0 +1,453 @@ +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:23:34 + | +LL | let fn_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn Fn()` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:24:37 + | +LL | let fn_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnMut()` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:25:38 + | +LL | let fn_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnOnce()` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:28:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe_2015)); + | --------------------- ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn Fn()` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:29:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2015)); + | ------------------------ ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnMut()` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:30:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2015)); + | ------------------------- ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnOnce()` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:33:23 + | +LL | fn_taking_fn_impl(depr_safe_2015); + | ----------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fn_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:109:30 + | +LL | fn fn_taking_fn_impl(_: impl Fn()) {} + | ^^^^ required by this bound in `fn_taking_fn_impl` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:34:26 + | +LL | fn_taking_fnmut_impl(depr_safe_2015); + | -------------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fnmut_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:110:33 + | +LL | fn fn_taking_fnmut_impl(_: impl FnMut()) {} + | ^^^^^^^ required by this bound in `fn_taking_fnmut_impl` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:35:27 + | +LL | fn_taking_fnonce_impl(depr_safe_2015); + | --------------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fnonce_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:111:34 + | +LL | fn fn_taking_fnonce_impl(_: impl FnOnce()) {} + | ^^^^^^^^ required by this bound in `fn_taking_fnonce_impl` + +error[E0308]: mismatched types + --> $DIR/deprecated-safe-unsafe-edition.rs:39:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe_2015; + | ---- ^^^^^^^^^^^^^^ expected normal fn, found unsafe fn + | | + | expected due to this + | + = note: expected fn pointer `fn()` + found fn item `unsafe fn() {depr_safe_2015}` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:40:44 + | +LL | let depr_safe_fn_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn Fn()` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:41:54 + | +LL | ...impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnMut()` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:42:52 + | +LL | let depr_safe_fnonce_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnOnce()` + +error[E0308]: mismatched types + --> $DIR/deprecated-safe-unsafe-edition.rs:52:22 + | +LL | fn_taking_fn_ptr(depr_safe_2015); + | ^^^^^^^^^^^^^^ expected normal fn, found unsafe fn + | + = note: expected fn pointer `fn()` + found fn item `unsafe fn() {depr_safe_2015}` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:53:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe_2015)); + | --------------------- ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn Fn()` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:54:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2015)); + | ------------------------ ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnMut()` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:55:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2015)); + | ------------------------- ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnOnce()` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:56:23 + | +LL | fn_taking_fn_impl(depr_safe_2015); + | ----------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fn_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:109:30 + | +LL | fn fn_taking_fn_impl(_: impl Fn()) {} + | ^^^^ required by this bound in `fn_taking_fn_impl` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:57:26 + | +LL | fn_taking_fnmut_impl(depr_safe_2015); + | -------------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fnmut_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:110:33 + | +LL | fn fn_taking_fnmut_impl(_: impl FnMut()) {} + | ^^^^^^^ required by this bound in `fn_taking_fnmut_impl` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:58:27 + | +LL | fn_taking_fnonce_impl(depr_safe_2015); + | --------------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fnonce_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:111:34 + | +LL | fn fn_taking_fnonce_impl(_: impl FnOnce()) {} + | ^^^^^^^^ required by this bound in `fn_taking_fnonce_impl` + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:64:34 + | +LL | let fn_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:65:37 + | +LL | let fn_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:66:38 + | +LL | let fn_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:69:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:70:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:71:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:74:5 + | +LL | fn_taking_fn_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:75:5 + | +LL | fn_taking_fnmut_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:76:5 + | +LL | fn_taking_fnonce_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:80:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe_2018; + | ^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:81:44 + | +LL | let depr_safe_fn_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:82:54 + | +LL | let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:83:52 + | +LL | let depr_safe_fnonce_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:93:22 + | +LL | fn_taking_fn_ptr(depr_safe_2018); + | ^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:94:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:95:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:96:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:97:5 + | +LL | fn_taking_fn_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:98:5 + | +LL | fn_taking_fnmut_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:99:5 + | +LL | fn_taking_fnonce_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to 20 previous errors; 20 warnings emitted + +Some errors have detailed explanations: E0277, E0308. +For more information about an error, try `rustc --explain E0277`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.rs b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.rs new file mode 100644 index 0000000000000..a49fdc3e324ab --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.rs @@ -0,0 +1,111 @@ +// aux-build:deprecated-safe.rs +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +#![feature(deprecated_safe)] +#![warn(unused_unsafe)] + +extern crate deprecated_safe; + +use deprecated_safe::{depr_safe_2015, depr_safe_2018}; +use std::ffi::{OsStr, OsString}; + +unsafe fn unsafe_fn() { + depr_safe_2015(); + depr_safe_2018(); +} + +fn main() { + // test for dyn Fn() coercion where arguments don't match, where an + // intermediate fn() will be used + let fn_impl: Box = Box::new(depr_safe_2015); //~ ERROR expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + let fn_impl: Box = Box::new(depr_safe_2015); //~ ERROR expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + let fn_impl: Box = Box::new(depr_safe_2015); //~ ERROR expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + + // test variant where coercion occurs on a function argument instead of a variable + fn_taking_dyn_fn_impl(Box::new(depr_safe_2015)); //~ ERROR expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2015)); //~ ERROR expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2015)); //~ ERROR expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + + // test for non-dyn Fn() coercion (no unsizing) + fn_taking_fn_impl(depr_safe_2015); //~ ERROR expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_fnmut_impl(depr_safe_2015); //~ ERROR expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_fnonce_impl(depr_safe_2015); //~ ERROR expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + + // test for fn() coercion where arguments don't match, where an + // intermediate fn() will be used + let depr_safe_fn_ptr: fn() = depr_safe_2015; //~ ERROR mismatched types + let depr_safe_fn_impl: Box = Box::new(depr_safe_2015); //~ ERROR expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe_2015); //~ ERROR expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + let depr_safe_fnonce_impl: Box = Box::new(depr_safe_2015); //~ ERROR expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + + // these shouldn't lint, appropriate unsafe usage + let unsafe_depr_safe_fn_ptr: unsafe fn() = depr_safe_2015; + fn_taking_unsafe_fn_ptr(depr_safe_2015); + unsafe { + depr_safe_2015(); + } + + // all of these coercions should lint + fn_taking_fn_ptr(depr_safe_2015); //~ ERROR mismatched types + fn_taking_dyn_fn_impl(Box::new(depr_safe_2015)); //~ ERROR expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2015)); //~ ERROR expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2015)); //~ ERROR expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_fn_impl(depr_safe_2015); //~ ERROR expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_fnmut_impl(depr_safe_2015); //~ ERROR expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + fn_taking_fnonce_impl(depr_safe_2015); //~ ERROR expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` +} + +fn main_2018() { + // test for dyn Fn() coercion where arguments don't match, where an + // intermediate fn() will be used + let fn_impl: Box = Box::new(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + + // test variant where coercion occurs on a function argument instead of a variable + fn_taking_dyn_fn_impl(Box::new(depr_safe_2018)); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2018)); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2018)); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + + // test for non-dyn Fn() coercion (no unsizing) + fn_taking_fn_impl(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + + // test for fn() coercion where arguments don't match, where an + // intermediate fn() will be used + let depr_safe_fn_ptr: fn() = depr_safe_2018; //~ WARN use of function `deprecated_safe::depr_safe_2018` as a normal fn pointer has been deprecated as it is now an unsafe function + let depr_safe_fn_impl: Box = Box::new(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + let depr_safe_fnonce_impl: Box = Box::new(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + + // these shouldn't lint, appropriate unsafe usage + let unsafe_depr_safe_fn_ptr: unsafe fn() = depr_safe_2018; + fn_taking_unsafe_fn_ptr(depr_safe_2018); + unsafe { + depr_safe_2018(); + } + + // all of these coercions should lint + fn_taking_fn_ptr(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a normal fn pointer has been deprecated as it is now an unsafe function + fn_taking_dyn_fn_impl(Box::new(depr_safe_2018)); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2018)); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2018)); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_fn_impl(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl(depr_safe_2018); //~ WARN use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function +} + +fn fn_taking_fn_ptr(_: fn()) {} +fn fn_taking_unsafe_fn_ptr(_: unsafe fn()) {} + +fn fn_taking_dyn_fn_impl(_: Box) {} +fn fn_taking_dyn_fnmut_impl(_: Box) {} +fn fn_taking_dyn_fnonce_impl(_: Box) {} + +fn fn_taking_fn_impl(_: impl Fn()) {} +fn fn_taking_fnmut_impl(_: impl FnMut()) {} +fn fn_taking_fnonce_impl(_: impl FnOnce()) {} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.thir.stderr new file mode 100644 index 0000000000000..8f29122291cbb --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-edition.thir.stderr @@ -0,0 +1,453 @@ +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:23:34 + | +LL | let fn_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn Fn()` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:24:37 + | +LL | let fn_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnMut()` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:25:38 + | +LL | let fn_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnOnce()` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:28:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe_2015)); + | --------------------- ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn Fn()` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:29:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2015)); + | ------------------------ ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnMut()` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:30:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2015)); + | ------------------------- ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnOnce()` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:33:23 + | +LL | fn_taking_fn_impl(depr_safe_2015); + | ----------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fn_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:109:30 + | +LL | fn fn_taking_fn_impl(_: impl Fn()) {} + | ^^^^ required by this bound in `fn_taking_fn_impl` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:34:26 + | +LL | fn_taking_fnmut_impl(depr_safe_2015); + | -------------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fnmut_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:110:33 + | +LL | fn fn_taking_fnmut_impl(_: impl FnMut()) {} + | ^^^^^^^ required by this bound in `fn_taking_fnmut_impl` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:35:27 + | +LL | fn_taking_fnonce_impl(depr_safe_2015); + | --------------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fnonce_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:111:34 + | +LL | fn fn_taking_fnonce_impl(_: impl FnOnce()) {} + | ^^^^^^^^ required by this bound in `fn_taking_fnonce_impl` + +error[E0308]: mismatched types + --> $DIR/deprecated-safe-unsafe-edition.rs:39:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe_2015; + | ---- ^^^^^^^^^^^^^^ expected normal fn, found unsafe fn + | | + | expected due to this + | + = note: expected fn pointer `fn()` + found fn item `unsafe fn() {depr_safe_2015}` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:40:44 + | +LL | let depr_safe_fn_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn Fn()` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:41:54 + | +LL | ...impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnMut()` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:42:52 + | +LL | let depr_safe_fnonce_impl: Box = Box::new(depr_safe_2015); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnOnce()` + +error[E0308]: mismatched types + --> $DIR/deprecated-safe-unsafe-edition.rs:52:22 + | +LL | fn_taking_fn_ptr(depr_safe_2015); + | ^^^^^^^^^^^^^^ expected normal fn, found unsafe fn + | + = note: expected fn pointer `fn()` + found fn item `unsafe fn() {depr_safe_2015}` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:53:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe_2015)); + | --------------------- ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn Fn()` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:54:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2015)); + | ------------------------ ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnMut()` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:55:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2015)); + | ------------------------- ^^^^^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` + = note: required for the cast to the object type `dyn FnOnce()` + +error[E0277]: expected a `Fn<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:56:23 + | +LL | fn_taking_fn_impl(depr_safe_2015); + | ----------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `Fn<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fn_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:109:30 + | +LL | fn fn_taking_fn_impl(_: impl Fn()) {} + | ^^^^ required by this bound in `fn_taking_fn_impl` + +error[E0277]: expected a `FnMut<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:57:26 + | +LL | fn_taking_fnmut_impl(depr_safe_2015); + | -------------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnMut<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fnmut_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:110:33 + | +LL | fn fn_taking_fnmut_impl(_: impl FnMut()) {} + | ^^^^^^^ required by this bound in `fn_taking_fnmut_impl` + +error[E0277]: expected a `FnOnce<()>` closure, found `unsafe fn() {depr_safe_2015}` + --> $DIR/deprecated-safe-unsafe-edition.rs:58:27 + | +LL | fn_taking_fnonce_impl(depr_safe_2015); + | --------------------- ^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }` + | | + | required by a bound introduced by this call + | + = help: the trait `FnOnce<()>` is not implemented for `unsafe fn() {depr_safe_2015}` + = note: wrap the `unsafe fn() {depr_safe_2015}` in a closure with no arguments: `|| { /* code */ }` +note: required by a bound in `fn_taking_fnonce_impl` + --> $DIR/deprecated-safe-unsafe-edition.rs:111:34 + | +LL | fn fn_taking_fnonce_impl(_: impl FnOnce()) {} + | ^^^^^^^^ required by this bound in `fn_taking_fnonce_impl` + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:64:34 + | +LL | let fn_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:65:37 + | +LL | let fn_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:66:38 + | +LL | let fn_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:69:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:70:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:71:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:74:5 + | +LL | fn_taking_fn_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:75:5 + | +LL | fn_taking_fnmut_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:76:5 + | +LL | fn_taking_fnonce_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:80:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe_2018; + | ^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:81:44 + | +LL | let depr_safe_fn_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:82:54 + | +LL | let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:83:52 + | +LL | let depr_safe_fnonce_impl: Box = Box::new(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:93:22 + | +LL | fn_taking_fn_ptr(depr_safe_2018); + | ^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:94:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:95:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:96:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe_2018)); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:97:5 + | +LL | fn_taking_fn_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:98:5 + | +LL | fn_taking_fnmut_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_2018` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-edition.rs:99:5 + | +LL | fn_taking_fnonce_impl(depr_safe_2018); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +error: aborting due to 20 previous errors; 20 warnings emitted + +Some errors have detailed explanations: E0277, E0308. +For more information about an error, try `rustc --explain E0277`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.mir.stderr new file mode 100644 index 0000000000000..e18dea3087a34 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.mir.stderr @@ -0,0 +1,119 @@ +warning: use of function `deprecated_safe::depr_safe` without an unsafe block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:17:5 + | +LL | depr_safe(); + | ^^^^^^^^^^^ call to unsafe function + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +error: call to unsafe function is unsafe and requires unsafe block (error E0133) + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:23:5 + | +LL | depr_safe_2015(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | +note: the lint level is defined here + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:7:9 + | +LL | #![deny(unsafe_op_in_unsafe_fn)] + | ^^^^^^^^^^^^^^^^^^^^^^ + = note: consult the function's documentation for information on how to avoid undefined behavior + +warning: use of function `deprecated_safe::depr_safe_2018` without an unsafe block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:29:5 + | +LL | depr_safe_2018(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:15:5 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + | +note: the lint level is defined here + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:8:9 + | +LL | #![warn(unused_unsafe)] + | ^^^^^^^^^^^^^ + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:20:9 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:26:9 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:32:9 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: use of function `deprecated_safe::depr_safe` without an unsafe block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:39:5 + | +LL | depr_safe(); + | ^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +error[E0133]: call to unsafe function is unsafe and requires unsafe block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:45:5 + | +LL | depr_safe_2015(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: consult the function's documentation for information on how to avoid undefined behavior + +warning: use of function `deprecated_safe::depr_safe_2018` without an unsafe block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:51:5 + | +LL | depr_safe_2018(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:37:5 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:42:9 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:48:9 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:54:9 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +error: aborting due to 2 previous errors; 12 warnings emitted + +For more information about this error, try `rustc --explain E0133`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.rs b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.rs new file mode 100644 index 0000000000000..97d8c4b1a203a --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.rs @@ -0,0 +1,56 @@ +// aux-build:deprecated-safe.rs +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +#![deny(unsafe_op_in_unsafe_fn)] +#![warn(unused_unsafe)] + +extern crate deprecated_safe; + +use deprecated_safe::{depr_safe, depr_safe_2015, depr_safe_2018}; + +unsafe fn unsafe_fn() { + unsafe {} //~ WARN unnecessary `unsafe` block + + depr_safe(); //~ WARN use of function `deprecated_safe::depr_safe` without an unsafe block has been deprecated as it is now an unsafe function + unsafe { + depr_safe(); + unsafe {} //~ WARN unnecessary `unsafe` block + } + + depr_safe_2015(); //~ ERROR call to unsafe function is unsafe and requires unsafe block + unsafe { + depr_safe_2015(); + unsafe {} //~ WARN unnecessary `unsafe` block + } + + depr_safe_2018(); //~ WARN use of function `deprecated_safe::depr_safe_2018` without an unsafe block has been deprecated as it is now an unsafe function + unsafe { + depr_safe_2018(); + unsafe {} //~ WARN unnecessary `unsafe` block + } +} + +fn main() { + unsafe {} //~ WARN unnecessary `unsafe` block + + depr_safe(); //~ WARN use of function `deprecated_safe::depr_safe` without an unsafe block has been deprecated as it is now an unsafe function + unsafe { + depr_safe(); + unsafe {} //~ WARN unnecessary `unsafe` block + } + + depr_safe_2015(); //~ ERROR call to unsafe function is unsafe and requires unsafe block + unsafe { + depr_safe_2015(); + unsafe {} //~ WARN unnecessary `unsafe` block + } + + depr_safe_2018(); //~ WARN use of function `deprecated_safe::depr_safe_2018` without an unsafe block has been deprecated as it is now an unsafe function + unsafe { + depr_safe_2018(); + unsafe {} //~ WARN unnecessary `unsafe` block + } +} diff --git a/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.thir.stderr new file mode 100644 index 0000000000000..d7774276d1ccd --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe-unsafe-op-in-unsafe-fn.thir.stderr @@ -0,0 +1,137 @@ +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:15:5 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + | +note: the lint level is defined here + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:8:9 + | +LL | #![warn(unused_unsafe)] + | ^^^^^^^^^^^^^ + +warning: use of function `deprecated_safe::depr_safe` without an unsafe block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:17:5 + | +LL | depr_safe(); + | ^^^^^^^^^^^ call to unsafe function + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:20:9 + | +LL | unsafe { + | ------ because it's nested under this `unsafe` block +LL | depr_safe(); +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +error: call to unsafe function is unsafe and requires unsafe block (error E0133) + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:23:5 + | +LL | depr_safe_2015(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | +note: the lint level is defined here + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:7:9 + | +LL | #![deny(unsafe_op_in_unsafe_fn)] + | ^^^^^^^^^^^^^^^^^^^^^^ + = note: consult the function's documentation for information on how to avoid undefined behavior + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:26:9 + | +LL | unsafe { + | ------ because it's nested under this `unsafe` block +LL | depr_safe_2015(); +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: use of function `deprecated_safe::depr_safe_2018` without an unsafe block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:29:5 + | +LL | depr_safe_2018(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:32:9 + | +LL | unsafe { + | ------ because it's nested under this `unsafe` block +LL | depr_safe_2018(); +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:37:5 + | +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: use of function `deprecated_safe::depr_safe` without an unsafe block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:39:5 + | +LL | depr_safe(); + | ^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:42:9 + | +LL | unsafe { + | ------ because it's nested under this `unsafe` block +LL | depr_safe(); +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +error[E0133]: call to unsafe function is unsafe and requires unsafe block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:45:5 + | +LL | depr_safe_2015(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: consult the function's documentation for information on how to avoid undefined behavior + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:48:9 + | +LL | unsafe { + | ------ because it's nested under this `unsafe` block +LL | depr_safe_2015(); +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +warning: use of function `deprecated_safe::depr_safe_2018` without an unsafe block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:51:5 + | +LL | depr_safe_2018(); + | ^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: unnecessary `unsafe` block + --> $DIR/deprecated-safe-unsafe-op-in-unsafe-fn.rs:54:9 + | +LL | unsafe { + | ------ because it's nested under this `unsafe` block +LL | depr_safe_2018(); +LL | unsafe {} + | ^^^^^^ unnecessary `unsafe` block + +error: aborting due to 2 previous errors; 12 warnings emitted + +For more information about this error, try `rustc --explain E0133`. diff --git a/src/test/ui/deprecated-safe/deprecated-safe.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe.mir.stderr new file mode 100644 index 0000000000000..c3cdf5f312367 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe.mir.stderr @@ -0,0 +1,1238 @@ +warning: use of trait `deprecated_safe::DeprSafe` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + --> $DIR/deprecated-safe.rs:108:1 + | +LL | impl DeprSafe for DeprSafeImpl {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this trait was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the trait's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:54:5 + | +LL | depr_safe + | ^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:57:14 + | +LL | fn foo2() -> impl FnOnce() { + | ^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:57:28 + | +LL | fn foo2() -> impl FnOnce() { + | ____________________________^ +LL | | +LL | | +LL | | depr_safe +LL | | } + | |_^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:64:5 + | +LL | depr_safe_params + | ^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:67:14 + | +LL | fn foo4() -> impl FnOnce(u32, u64) { + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:67:36 + | +LL | fn foo4() -> impl FnOnce(u32, u64) { + | ____________________________________^ +LL | | +LL | | +LL | | depr_safe_params +LL | | } + | |_^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:74:5 + | +LL | depr_safe_generic + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:77:14 + | +LL | fn foo6() -> impl FnOnce(OsString, OsString) { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:77:46 + | +LL | fn foo6() -> impl FnOnce(OsString, OsString) { + | ______________________________________________^ +LL | | +LL | | +LL | | depr_safe_generic +LL | | } + | |_^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:84:5 + | +LL | Box::new(depr_safe) + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:88:5 + | +LL | Box::new(depr_safe) + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:92:5 + | +LL | Box::new(depr_safe_params) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:96:5 + | +LL | Box::new(depr_safe_params) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:100:5 + | +LL | Box::new(depr_safe_generic) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:104:5 + | +LL | Box::new(depr_safe_generic) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:174:34 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:175:37 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:176:38 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:179:34 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:180:37 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:181:38 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:184:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:185:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:186:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:189:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:190:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:191:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:194:5 + | +LL | fn_taking_fn_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:195:5 + | +LL | fn_taking_fnmut_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:196:5 + | +LL | fn_taking_fnonce_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:199:5 + | +LL | fn_taking_fn_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:200:5 + | +LL | fn_taking_fnmut_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:201:5 + | +LL | fn_taking_fnonce_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:208:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:211:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:215:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:216:44 + | +LL | let depr_safe_fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:217:54 + | +LL | let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:218:52 + | +LL | let depr_safe_fnonce_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:221:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:222:44 + | +LL | let depr_safe_fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:223:54 + | +LL | let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:224:52 + | +LL | let depr_safe_fnonce_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:234:22 + | +LL | fn_taking_fn_ptr(depr_safe); + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:235:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:236:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:237:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:238:5 + | +LL | fn_taking_fn_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:239:5 + | +LL | fn_taking_fnmut_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:240:5 + | +LL | fn_taking_fnonce_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:243:22 + | +LL | fn_taking_fn_ptr(depr_safe); + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:244:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:245:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:246:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:247:5 + | +LL | fn_taking_fn_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:248:5 + | +LL | fn_taking_fnmut_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:249:5 + | +LL | fn_taking_fnonce_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:253:52 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:254:55 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:255:56 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:258:52 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:259:55 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:260:56 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:263:35 + | +LL | fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:264:38 + | +LL | fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:265:39 + | +LL | fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:268:35 + | +LL | fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:269:38 + | +LL | fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:270:39 + | +LL | fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:273:5 + | +LL | fn_taking_fn_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:274:5 + | +LL | fn_taking_fnmut_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:275:5 + | +LL | fn_taking_fnonce_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:278:5 + | +LL | fn_taking_fn_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:279:5 + | +LL | fn_taking_fnmut_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:280:5 + | +LL | fn_taking_fnonce_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:287:42 + | +LL | let depr_safe_generic_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:290:42 + | +LL | let depr_safe_generic_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:294:60 + | +LL | let depr_safe_generic_fn_ptr: fn(OsString, OsString) = depr_safe_generic; + | ^^^^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:295:70 + | +LL | let depr_safe_generic_fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:297:9 + | +LL | ... Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:299:9 + | +LL | ... Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:302:60 + | +LL | let depr_safe_generic_fn_ptr: fn(OsString, OsString) = depr_safe_generic; + | ^^^^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:303:70 + | +LL | let depr_safe_generic_fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:305:9 + | +LL | ... Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:307:9 + | +LL | ... Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:317:30 + | +LL | fn_taking_fn_ptr_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:318:35 + | +LL | fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:319:38 + | +LL | fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:320:39 + | +LL | fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:321:5 + | +LL | fn_taking_fn_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:322:5 + | +LL | fn_taking_fnmut_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:323:5 + | +LL | fn_taking_fnonce_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:326:30 + | +LL | fn_taking_fn_ptr_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:327:35 + | +LL | fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:328:38 + | +LL | fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:329:39 + | +LL | fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:330:5 + | +LL | fn_taking_fn_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:331:5 + | +LL | fn_taking_fnmut_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:332:5 + | +LL | fn_taking_fnonce_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:23:14 + | +LL | type Tait1 = impl FnOnce(); + | ^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:24:14 + | +LL | type Tait2 = impl FnOnce(u32, u64); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:25:14 + | +LL | type Tait3 = impl FnOnce(OsString, OsString); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:60:5 + | +LL | depr_safe + | ^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:70:5 + | +LL | depr_safe_params + | ^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:80:5 + | +LL | depr_safe_generic + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:133:5 + | +LL | fn depr_safe_fn(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:135:5 + | +LL | fn depr_safe_params(&self, _: u32, _: u64) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:137:5 + | +LL | fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:141:5 + | +LL | fn depr_safe_fn_2018(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:146:5 + | +LL | good.depr_safe_fn(); + | ^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:147:5 + | +LL | good.depr_safe_params(0, 0); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:148:5 + | +LL | good.depr_safe_fn_generic("", ""); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:152:5 + | +LL | good.depr_safe_fn_2018(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:155:5 + | +LL | bad.depr_safe_fn(); + | ^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:156:5 + | +LL | bad.depr_safe_params(0, 0); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:157:5 + | +LL | bad.depr_safe_fn_generic("", ""); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:161:5 + | +LL | bad.depr_safe_fn_2018(); + | ^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:204:5 + | +LL | depr_safe(); + | ^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:205:5 + | +LL | depr_safe(); + | ^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:283:5 + | +LL | depr_safe_generic("", ""); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:284:5 + | +LL | depr_safe_generic("", ""); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: 122 warnings emitted + diff --git a/src/test/ui/deprecated-safe/deprecated-safe.rs b/src/test/ui/deprecated-safe/deprecated-safe.rs new file mode 100644 index 0000000000000..1db94f77ea239 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe.rs @@ -0,0 +1,355 @@ +// aux-build:deprecated-safe.rs +// check-pass +// revisions: mir thir +// NOTE(skippy) these tests output many duplicates, so deduplicate or they become brittle to changes +// [mir]compile-flags: -Zdeduplicate-diagnostics=yes +// [thir]compile-flags: -Z thir-unsafeck -Zdeduplicate-diagnostics=yes + +// FIXME(skippy) add tests in combination with #[target_feature], ensure #[deprecated_safe] +// doesn't silence these accidentally + +#![feature(type_alias_impl_trait)] +#![warn(unused_unsafe)] + +extern crate deprecated_safe; + +use deprecated_safe::{depr_safe, depr_safe_generic, depr_safe_params, DeprSafe, DeprSafeFns}; +use std::ffi::{OsStr, OsString}; + +trait Bla { + type T; +} + +type Tait1 = impl FnOnce(); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function +type Tait2 = impl FnOnce(u32, u64); //~ WARN use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function +type Tait3 = impl FnOnce(OsString, OsString); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function +type Tait5 = Box; +type Tait6 = Box; +type Tait7 = Box; +type Tait8 = Box; + +impl Bla for u8 { + type T = Tait1; +} +impl Bla for u16 { + type T = Tait2; +} +impl Bla for u32 { + type T = Tait3; +} +impl Bla for i8 { + type T = Tait5; +} +impl Bla for i16 { + type T = Tait6; +} +impl Bla for i32 { + type T = Tait7; +} +impl Bla for i64 { + type T = Tait8; +} + +fn foo1() -> Tait1 { + depr_safe //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function +} + +fn foo2() -> impl FnOnce() { + //~^ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + //~| WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + depr_safe //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function +} + +fn foo3() -> Tait2 { + depr_safe_params //~ WARN use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function +} + +fn foo4() -> impl FnOnce(u32, u64) { + //~^ WARN use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + //~| WARN use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + depr_safe_params //~ WARN use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function +} + +fn foo5() -> Tait3 { + depr_safe_generic //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function +} + +fn foo6() -> impl FnOnce(OsString, OsString) { + //~^ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + //~| WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + depr_safe_generic //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function +} + +fn foo10() -> Tait5 { + Box::new(depr_safe) //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function +} + +fn foo11() -> Box { + Box::new(depr_safe) //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function +} + +fn foo12() -> Tait6 { + Box::new(depr_safe_params) //~ WARN use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function +} + +fn foo13() -> Box { + Box::new(depr_safe_params) //~ WARN use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function +} + +fn foo14() -> Tait7 { + Box::new(depr_safe_generic) //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function +} + +fn foo15() -> Box { + Box::new(depr_safe_generic) //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function +} + +struct DeprSafeImpl; +impl DeprSafe for DeprSafeImpl {} //~ WARN use of trait `deprecated_safe::DeprSafe` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + +struct DeprSafeUnsafeImpl; +unsafe impl DeprSafe for DeprSafeUnsafeImpl {} + +unsafe fn unsafe_fn() { + depr_safe(); + depr_safe_generic("", ""); +} + +struct DeprSafeFnsGood; +impl DeprSafeFns for DeprSafeFnsGood { + unsafe fn depr_safe_fn(&self) {} + + unsafe fn depr_safe_params(&self, _: u32, _: u64) {} + + unsafe fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} + + unsafe fn depr_safe_fn_2015(&self) {} + + unsafe fn depr_safe_fn_2018(&self) {} +} + +struct DeprSafeFnsBad; +impl DeprSafeFns for DeprSafeFnsBad { + fn depr_safe_fn(&self) {} //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + + fn depr_safe_params(&self, _: u32, _: u64) {} //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + + fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + + unsafe fn depr_safe_fn_2015(&self) {} + + fn depr_safe_fn_2018(&self) {} //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function +} + +fn foo0() { + let good = DeprSafeFnsGood; + good.depr_safe_fn(); //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an unsafe function or block has been deprecated as it is now an unsafe associated function + good.depr_safe_params(0, 0); //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an unsafe function or block has been deprecated as it is now an unsafe associated function + good.depr_safe_fn_generic("", ""); //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an unsafe function or block has been deprecated as it is now an unsafe associated function + unsafe { + good.depr_safe_fn_2015(); + } + good.depr_safe_fn_2018(); //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an unsafe function or block has been deprecated as it is now an unsafe associated function + + let bad = DeprSafeFnsBad; + bad.depr_safe_fn(); //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an unsafe function or block has been deprecated as it is now an unsafe associated function + bad.depr_safe_params(0, 0); //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an unsafe function or block has been deprecated as it is now an unsafe associated function + bad.depr_safe_fn_generic("", ""); //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an unsafe function or block has been deprecated as it is now an unsafe associated function + unsafe { + bad.depr_safe_fn_2015(); + } + bad.depr_safe_fn_2018(); //~ WARN use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an unsafe function or block has been deprecated as it is now an unsafe associated function + + unsafe { + good.depr_safe_fn(); + good.depr_safe_params(0, 0); + good.depr_safe_fn_generic("", ""); + good.depr_safe_fn_2015(); + good.depr_safe_fn_2018(); + } +} + +fn main() { + // test for dyn Fn() coercion where arguments match (no args) + let fn_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // test that second usage still lints + let fn_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // test variant where coercion occurs on a function argument instead of a variable + fn_taking_dyn_fn_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // test that second usage still lints + fn_taking_dyn_fn_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // test for non-dyn Fn() coercion (no unsizing) + fn_taking_fn_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // test that second usage still lints + fn_taking_fn_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // usage without unsafe should lint + depr_safe(); //~ WARN use of function `deprecated_safe::depr_safe` without an unsafe function or block has been deprecated as it is now an unsafe function + depr_safe(); //~ WARN use of function `deprecated_safe::depr_safe` without an unsafe function or block has been deprecated as it is now an unsafe function + + // test for fn() coercion where arguments match (no args) + let depr_safe_fn_ptr: fn() = depr_safe; //~ WARN use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + + // test that second usage still lints + let depr_safe_fn_ptr: fn() = depr_safe; //~ WARN use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + + // test for fn() coercion where arguments don't match, where an + // intermediate fn() will be used + let depr_safe_fn_ptr: fn() = depr_safe; //~ WARN use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + let depr_safe_fn_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + let depr_safe_fnonce_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // test that second usage still lints + let depr_safe_fn_ptr: fn() = depr_safe; //~ WARN use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + let depr_safe_fn_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + let depr_safe_fnonce_impl: Box = Box::new(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // these shouldn't lint, appropriate unsafe usage + let unsafe_depr_safe_fn_ptr: unsafe fn() = depr_safe; + fn_taking_unsafe_fn_ptr(depr_safe); + unsafe { + depr_safe(); + } + + // all of these coercions should lint + fn_taking_fn_ptr(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + fn_taking_dyn_fn_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fn_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // ensure lint still fires if coerced again + fn_taking_fn_ptr(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + fn_taking_dyn_fn_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fn_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl(depr_safe); //~ WARN use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + + // test for dyn Fn() coercion where arguments don't match, where an + // intermediate fn() will be used + let fn_impl: Box = Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // test that second usage still lints + let fn_impl: Box = Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + let fn_impl: Box = Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // test variant where coercion occurs on a function argument instead of a variable + fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // test that second usage still lints + fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // test for non-dyn Fn() coercion (no unsizing) + fn_taking_fn_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // test that second usage still lints + fn_taking_fn_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // usage without unsafe should lint + depr_safe_generic("", ""); //~ WARN use of function `deprecated_safe::depr_safe_generic` without an unsafe function or block has been deprecated as it is now an unsafe function + depr_safe_generic("", ""); //~ WARN use of function `deprecated_safe::depr_safe_generic` without an unsafe function or block has been deprecated as it is now an unsafe function + + // test for fn() coercion where arguments match (no args) + let depr_safe_generic_fn_ptr: fn() = depr_safe; //~ WARN use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + + // test that second usage still lints + let depr_safe_generic_fn_ptr: fn() = depr_safe; //~ WARN use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + + // test for fn() coercion where arguments don't match, where an + // intermediate fn() will be used + let depr_safe_generic_fn_ptr: fn(OsString, OsString) = depr_safe_generic; //~ WARN use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + let depr_safe_generic_fn_impl: Box = Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + let mut depr_safe_generic_fnmut_impl: Box = + Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + let depr_safe_generic_fnonce_impl: Box = + Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // test that second usage still lints + let depr_safe_generic_fn_ptr: fn(OsString, OsString) = depr_safe_generic; //~ WARN use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + let depr_safe_generic_fn_impl: Box = Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + let mut depr_safe_generic_fnmut_impl: Box = + Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + let depr_safe_generic_fnonce_impl: Box = + Box::new(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // these shouldn't lint, appropriate unsafe usage + let unsafe_depr_safe_generic_fn_ptr: unsafe fn(OsString, OsString) = depr_safe_generic; + fn_taking_unsafe_fn_ptr_generic(depr_safe_generic); + unsafe { + depr_safe_generic("", ""); + } + + // all of these coercions should lint + fn_taking_fn_ptr_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fn_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + + // ensure lint still fires if coerced again + fn_taking_fn_ptr_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fn_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnmut_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + fn_taking_fnonce_impl_generic(depr_safe_generic); //~ WARN use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function +} + +fn fn_taking_fn_ptr(_: fn()) {} +fn fn_taking_unsafe_fn_ptr(_: unsafe fn()) {} + +fn fn_taking_dyn_fn_impl(_: Box) {} +fn fn_taking_dyn_fnmut_impl(_: Box) {} +fn fn_taking_dyn_fnonce_impl(_: Box) {} + +fn fn_taking_fn_impl(_: impl Fn()) {} +fn fn_taking_fnmut_impl(_: impl FnMut()) {} +fn fn_taking_fnonce_impl(_: impl FnOnce()) {} + +fn fn_taking_fn_ptr_generic(_: fn(OsString, OsString)) {} +fn fn_taking_unsafe_fn_ptr_generic(_: unsafe fn(OsString, OsString)) {} + +fn fn_taking_dyn_fn_impl_generic(_: Box) {} +fn fn_taking_dyn_fnmut_impl_generic(_: Box) {} +fn fn_taking_dyn_fnonce_impl_generic(_: Box) {} + +fn fn_taking_fn_impl_generic(_: impl Fn(OsString, OsString)) {} +fn fn_taking_fnmut_impl_generic(_: impl FnMut(OsString, OsString)) {} +fn fn_taking_fnonce_impl_generic(_: impl FnOnce(OsString, OsString)) {} diff --git a/src/test/ui/deprecated-safe/deprecated-safe.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe.thir.stderr new file mode 100644 index 0000000000000..c3cdf5f312367 --- /dev/null +++ b/src/test/ui/deprecated-safe/deprecated-safe.thir.stderr @@ -0,0 +1,1238 @@ +warning: use of trait `deprecated_safe::DeprSafe` without an `unsafe impl` declaration has been deprecated as it is now an unsafe trait + --> $DIR/deprecated-safe.rs:108:1 + | +LL | impl DeprSafe for DeprSafeImpl {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(deprecated_safe)]` on by default + = note: this trait was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the trait's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:54:5 + | +LL | depr_safe + | ^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:57:14 + | +LL | fn foo2() -> impl FnOnce() { + | ^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:57:28 + | +LL | fn foo2() -> impl FnOnce() { + | ____________________________^ +LL | | +LL | | +LL | | depr_safe +LL | | } + | |_^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:64:5 + | +LL | depr_safe_params + | ^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:67:14 + | +LL | fn foo4() -> impl FnOnce(u32, u64) { + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:67:36 + | +LL | fn foo4() -> impl FnOnce(u32, u64) { + | ____________________________________^ +LL | | +LL | | +LL | | depr_safe_params +LL | | } + | |_^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:74:5 + | +LL | depr_safe_generic + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:77:14 + | +LL | fn foo6() -> impl FnOnce(OsString, OsString) { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:77:46 + | +LL | fn foo6() -> impl FnOnce(OsString, OsString) { + | ______________________________________________^ +LL | | +LL | | +LL | | depr_safe_generic +LL | | } + | |_^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:84:5 + | +LL | Box::new(depr_safe) + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:88:5 + | +LL | Box::new(depr_safe) + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:92:5 + | +LL | Box::new(depr_safe_params) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:96:5 + | +LL | Box::new(depr_safe_params) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:100:5 + | +LL | Box::new(depr_safe_generic) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:104:5 + | +LL | Box::new(depr_safe_generic) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:174:34 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:175:37 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:176:38 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:179:34 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:180:37 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:181:38 + | +LL | let fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:184:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:185:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:186:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:189:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:190:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:191:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:194:5 + | +LL | fn_taking_fn_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:195:5 + | +LL | fn_taking_fnmut_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:196:5 + | +LL | fn_taking_fnonce_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:199:5 + | +LL | fn_taking_fn_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:200:5 + | +LL | fn_taking_fnmut_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:201:5 + | +LL | fn_taking_fnonce_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:208:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:211:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:215:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:216:44 + | +LL | let depr_safe_fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:217:54 + | +LL | let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:218:52 + | +LL | let depr_safe_fnonce_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:221:34 + | +LL | let depr_safe_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:222:44 + | +LL | let depr_safe_fn_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:223:54 + | +LL | let mut depr_safe_fnmut_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:224:52 + | +LL | let depr_safe_fnonce_impl: Box = Box::new(depr_safe); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:234:22 + | +LL | fn_taking_fn_ptr(depr_safe); + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:235:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:236:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:237:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:238:5 + | +LL | fn_taking_fn_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:239:5 + | +LL | fn_taking_fnmut_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:240:5 + | +LL | fn_taking_fnonce_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:243:22 + | +LL | fn_taking_fn_ptr(depr_safe); + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:244:27 + | +LL | fn_taking_dyn_fn_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:245:30 + | +LL | fn_taking_dyn_fnmut_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:246:31 + | +LL | fn_taking_dyn_fnonce_impl(Box::new(depr_safe)); + | ^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:247:5 + | +LL | fn_taking_fn_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:248:5 + | +LL | fn_taking_fnmut_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:249:5 + | +LL | fn_taking_fnonce_impl(depr_safe); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:253:52 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:254:55 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:255:56 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:258:52 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:259:55 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:260:56 + | +LL | let fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:263:35 + | +LL | fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:264:38 + | +LL | fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:265:39 + | +LL | fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:268:35 + | +LL | fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:269:38 + | +LL | fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:270:39 + | +LL | fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:273:5 + | +LL | fn_taking_fn_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:274:5 + | +LL | fn_taking_fnmut_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:275:5 + | +LL | fn_taking_fnonce_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:278:5 + | +LL | fn_taking_fn_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:279:5 + | +LL | fn_taking_fnmut_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:280:5 + | +LL | fn_taking_fnonce_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:287:42 + | +LL | let depr_safe_generic_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:290:42 + | +LL | let depr_safe_generic_fn_ptr: fn() = depr_safe; + | ^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:294:60 + | +LL | let depr_safe_generic_fn_ptr: fn(OsString, OsString) = depr_safe_generic; + | ^^^^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:295:70 + | +LL | let depr_safe_generic_fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:297:9 + | +LL | ... Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:299:9 + | +LL | ... Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:302:60 + | +LL | let depr_safe_generic_fn_ptr: fn(OsString, OsString) = depr_safe_generic; + | ^^^^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:303:70 + | +LL | let depr_safe_generic_fn_impl: Box = Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:305:9 + | +LL | ... Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:307:9 + | +LL | ... Box::new(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:317:30 + | +LL | fn_taking_fn_ptr_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:318:35 + | +LL | fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:319:38 + | +LL | fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:320:39 + | +LL | fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:321:5 + | +LL | fn_taking_fn_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:322:5 + | +LL | fn_taking_fnmut_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:323:5 + | +LL | fn_taking_fnonce_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a normal fn pointer has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:326:30 + | +LL | fn_taking_fn_ptr_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^ expected normal fn pointer, found unsafe fn pointer + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:327:35 + | +LL | fn_taking_dyn_fn_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:328:38 + | +LL | fn_taking_dyn_fnmut_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:329:39 + | +LL | fn_taking_dyn_fnonce_impl_generic(Box::new(depr_safe_generic)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:330:5 + | +LL | fn_taking_fn_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:331:5 + | +LL | fn_taking_fnmut_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:332:5 + | +LL | fn_taking_fnonce_impl_generic(depr_safe_generic); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:23:14 + | +LL | type Tait1 = impl FnOnce(); + | ^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:24:14 + | +LL | type Tait2 = impl FnOnce(u32, u64); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:25:14 + | +LL | type Tait3 = impl FnOnce(OsString, OsString); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:60:5 + | +LL | depr_safe + | ^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_params` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:70:5 + | +LL | depr_safe_params + | ^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` as a closure has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:80:5 + | +LL | depr_safe_generic + | ^^^^^^^^^^^^^^^^^ + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:133:5 + | +LL | fn depr_safe_fn(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:135:5 + | +LL | fn depr_safe_params(&self, _: u32, _: u64) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:137:5 + | +LL | fn depr_safe_fn_generic, V: AsRef>(&self, key: K, value: V) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an `unsafe fn` declaration has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:141:5 + | +LL | fn depr_safe_fn_2018(&self) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:146:5 + | +LL | good.depr_safe_fn(); + | ^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:147:5 + | +LL | good.depr_safe_params(0, 0); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:148:5 + | +LL | good.depr_safe_fn_generic("", ""); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:152:5 + | +LL | good.depr_safe_fn_2018(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:155:5 + | +LL | bad.depr_safe_fn(); + | ^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_params` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:156:5 + | +LL | bad.depr_safe_params(0, 0); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_generic` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:157:5 + | +LL | bad.depr_safe_fn_generic("", ""); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of associated function `deprecated_safe::DeprSafeFns::depr_safe_fn_2018` without an unsafe function or block has been deprecated as it is now an unsafe associated function + --> $DIR/deprecated-safe.rs:161:5 + | +LL | bad.depr_safe_fn_2018(); + | ^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this associated function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the associated function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:204:5 + | +LL | depr_safe(); + | ^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:205:5 + | +LL | depr_safe(); + | ^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:283:5 + | +LL | depr_safe_generic("", ""); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: use of function `deprecated_safe::depr_safe_generic` without an unsafe function or block has been deprecated as it is now an unsafe function + --> $DIR/deprecated-safe.rs:284:5 + | +LL | depr_safe_generic("", ""); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: this function was previously not marked unsafe, but has been marked unsafe since 1.61.0 + = note: consult the function's documentation for information on how to avoid undefined behavior + = note: reason + +warning: 122 warnings emitted + From 25191011adc297adc42fad3e62a5c89d1447a6a6 Mon Sep 17 00:00:00 2001 From: skippy10110 Date: Fri, 15 Apr 2022 20:20:18 -0300 Subject: [PATCH 7/7] consolidate attribute checking --- compiler/rustc_middle/src/middle/stability.rs | 49 ++---------------- compiler/rustc_passes/src/check_attr.rs | 51 ++++++++++++++++--- .../deprecated-safe-attr.mir.stderr | 4 +- .../deprecated-safe/deprecated-safe-attr.rs | 4 +- .../deprecated-safe-attr.thir.stderr | 4 +- 5 files changed, 53 insertions(+), 59 deletions(-) diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs index f7e26b8ca797e..1ceaa7b79c475 100644 --- a/compiler/rustc_middle/src/middle/stability.rs +++ b/compiler/rustc_middle/src/middle/stability.rs @@ -286,7 +286,7 @@ pub fn check_deprecation_as_safe(tcx: TyCtxt<'_>, def_id: DefId, span: Span) -> let Some(attr) = tcx.get_attrs(def_id).iter().find(|x| x.has_name(sym::deprecated_safe)) else { return false; }; - let Some(depr_as_safe) = parse_deprecation_as_safe(tcx, def_id, attr) else { + let Some(depr_as_safe) = parse_deprecation_as_safe(tcx, attr) else { bug!("invalid #[deprecated_safe] attribute during reporting"); }; @@ -302,11 +302,7 @@ pub fn check_deprecation_as_safe(tcx: TyCtxt<'_>, def_id: DefId, span: Span) -> true } -pub fn parse_deprecation_as_safe( - tcx: TyCtxt<'_>, - def_id: DefId, - attr: &Attribute, -) -> Option { +pub fn parse_deprecation_as_safe(tcx: TyCtxt<'_>, attr: &Attribute) -> Option { let Some(meta_kind) = attr.meta_kind() else { return None; }; @@ -403,45 +399,6 @@ pub fn parse_deprecation_as_safe( } } - let is_rustc = tcx.features().staged_api || tcx.lookup_stability(def_id).is_some(); - if is_rustc { - if since.is_none() { - struct_span_err!( - tcx.sess, - attr.span, - // FIXME(skippy) wrong error code, need to create a new one - E0542, - "missing 'since'" - ) - .emit(); - return None; - } - - if note.is_none() { - struct_span_err!( - tcx.sess, - attr.span, - // FIXME(skippy) wrong error code, need to create a new one - E0543, - "missing 'note'" - ) - .emit(); - return None; - } - } else { - if unsafe_edition.is_some() { - struct_span_err!( - tcx.sess, - attr.span, - // FIXME(skippy) wrong error code, need to create a new one - E0543, - "'unsafe_edition' is invalid outside of rustc" - ) - .emit(); - return None; - } - } - let mut unsafe_edition_parsed = None; if let Some(unsafe_edition) = unsafe_edition { if let Ok(unsafe_edition) = Edition::from_str(unsafe_edition.as_str()) { @@ -476,7 +433,7 @@ pub fn report_deprecation_as_safe<'tcx>( let Some(attr) = tcx.get_attrs(def_id).iter().find(|x| x.has_name(sym::deprecated_safe)) else { bug!("missing #[deprecated_safe] attribute during reporting"); }; - let Some(depr_as_safe) = parse_deprecation_as_safe(tcx, def_id, attr) else { + let Some(depr_as_safe) = parse_deprecation_as_safe(tcx, attr) else { bug!("invalid #[deprecated_safe] attribute during reporting"); }; diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index d923326591038..0adc4cda28100 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -2018,9 +2018,10 @@ impl CheckAttrVisitor<'_> { span: Span, _target: Target, ) -> bool { - let mut unsafety = None; - let node = self.tcx.hir().get(hir_id); + let def_id = self.tcx.hir().local_def_id(hir_id).to_def_id(); + + let mut unsafety = None; if let hir::Node::Item(item) = node { if let Some(fn_sig) = node.fn_sig() { unsafety = Some(fn_sig.header.unsafety); @@ -2045,11 +2046,7 @@ impl CheckAttrVisitor<'_> { return false; }; - if let Some(_depr_as_safe) = stability::parse_deprecation_as_safe( - self.tcx, - self.tcx.hir().local_def_id(hir_id).to_def_id(), - attr, - ) { + if let Some(depr_as_safe) = stability::parse_deprecation_as_safe(self.tcx, attr) { if unsafety == hir::Unsafety::Normal { struct_span_err!( self.tcx.sess, @@ -2062,6 +2059,46 @@ impl CheckAttrVisitor<'_> { return false; } + let is_rustc = + self.tcx.features().staged_api || self.tcx.lookup_stability(def_id).is_some(); + if is_rustc { + if depr_as_safe.since.is_none() { + struct_span_err!( + self.tcx.sess, + attr.span, + // FIXME(skippy) wrong error code, need to create a new one + E0542, + "missing 'since'" + ) + .emit(); + return false; + } + + if depr_as_safe.note.is_none() { + struct_span_err!( + self.tcx.sess, + attr.span, + // FIXME(skippy) wrong error code, need to create a new one + E0543, + "missing 'note'" + ) + .emit(); + return false; + } + } else { + if depr_as_safe.unsafe_edition.is_some() { + struct_span_err!( + self.tcx.sess, + attr.span, + // FIXME(skippy) wrong error code, need to create a new one + E0543, + "'unsafe_edition' is invalid outside of rustc" + ) + .emit(); + return false; + } + } + true } else { false diff --git a/src/test/ui/deprecated-safe/deprecated-safe-attr.mir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-attr.mir.stderr index ba1a7bd41c6f5..6449dbf2bc863 100644 --- a/src/test/ui/deprecated-safe/deprecated-safe-attr.mir.stderr +++ b/src/test/ui/deprecated-safe/deprecated-safe-attr.mir.stderr @@ -4,13 +4,13 @@ error[E0543]: 'unsafe_edition' is invalid outside of rustc LL | #[deprecated_safe(since = "1.61.0", unsafe_edition = "2015", note = "reason")] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0543]: 'unsafe_edition' is invalid outside of rustc +error[E0543]: invalid 'unsafe_edition' specified --> $DIR/deprecated-safe-attr.rs:18:1 | LL | #[deprecated_safe(since = "1.61.0", unsafe_edition = "BAD", note = "reason")] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0543]: 'unsafe_edition' is invalid outside of rustc +error[E0543]: invalid 'unsafe_edition' specified --> $DIR/deprecated-safe-attr.rs:21:1 | LL | #[deprecated_safe(since = "TBD", unsafe_edition = "BAD", note = "reason")] diff --git a/src/test/ui/deprecated-safe/deprecated-safe-attr.rs b/src/test/ui/deprecated-safe/deprecated-safe-attr.rs index 149603dd4c6d3..be5ff1778bc24 100644 --- a/src/test/ui/deprecated-safe/deprecated-safe-attr.rs +++ b/src/test/ui/deprecated-safe/deprecated-safe-attr.rs @@ -15,10 +15,10 @@ use deprecated_safe::DeprSafeFns; #[deprecated_safe(since = "1.61.0", unsafe_edition = "2015", note = "reason")] //~ ERROR 'unsafe_edition' is invalid outside of rustc unsafe fn foo0() {} -#[deprecated_safe(since = "1.61.0", unsafe_edition = "BAD", note = "reason")] //~ ERROR 'unsafe_edition' is invalid outside of rustc +#[deprecated_safe(since = "1.61.0", unsafe_edition = "BAD", note = "reason")] //~ ERROR invalid 'unsafe_edition' specified unsafe fn foo1() {} -#[deprecated_safe(since = "TBD", unsafe_edition = "BAD", note = "reason")] //~ ERROR 'unsafe_edition' is invalid outside of rustc +#[deprecated_safe(since = "TBD", unsafe_edition = "BAD", note = "reason")] //~ ERROR invalid 'unsafe_edition' specified unsafe fn foo2() {} #[deprecated_safe] diff --git a/src/test/ui/deprecated-safe/deprecated-safe-attr.thir.stderr b/src/test/ui/deprecated-safe/deprecated-safe-attr.thir.stderr index ba1a7bd41c6f5..6449dbf2bc863 100644 --- a/src/test/ui/deprecated-safe/deprecated-safe-attr.thir.stderr +++ b/src/test/ui/deprecated-safe/deprecated-safe-attr.thir.stderr @@ -4,13 +4,13 @@ error[E0543]: 'unsafe_edition' is invalid outside of rustc LL | #[deprecated_safe(since = "1.61.0", unsafe_edition = "2015", note = "reason")] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0543]: 'unsafe_edition' is invalid outside of rustc +error[E0543]: invalid 'unsafe_edition' specified --> $DIR/deprecated-safe-attr.rs:18:1 | LL | #[deprecated_safe(since = "1.61.0", unsafe_edition = "BAD", note = "reason")] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0543]: 'unsafe_edition' is invalid outside of rustc +error[E0543]: invalid 'unsafe_edition' specified --> $DIR/deprecated-safe-attr.rs:21:1 | LL | #[deprecated_safe(since = "TBD", unsafe_edition = "BAD", note = "reason")]