diff --git a/compiler/rustc_mir/src/transform/function_references.rs b/compiler/rustc_mir/src/transform/function_references.rs index 2daa468136f..8adeac7623b 100644 --- a/compiler/rustc_mir/src/transform/function_references.rs +++ b/compiler/rustc_mir/src/transform/function_references.rs @@ -1,134 +1,154 @@ use rustc_hir::def_id::DefId; use rustc_middle::mir::visit::Visitor; use rustc_middle::mir::*; -use rustc_middle::ty::{self, Ty, TyCtxt}; -use rustc_session::lint::builtin::FUNCTION_REFERENCES; -use rustc_span::Span; +use rustc_middle::ty::{self, subst::GenericArgKind, PredicateAtom, Ty, TyCtxt, TyS}; +use rustc_session::lint::builtin::FUNCTION_ITEM_REFERENCES; +use rustc_span::{symbol::sym, Span}; use rustc_target::spec::abi::Abi; -use crate::transform::{MirPass, MirSource}; +use crate::transform::MirPass; -pub struct FunctionReferences; +pub struct FunctionItemReferences; -impl<'tcx> MirPass<'tcx> for FunctionReferences { - fn run_pass(&self, tcx: TyCtxt<'tcx>, _src: MirSource<'tcx>, body: &mut Body<'tcx>) { - let source_info = SourceInfo::outermost(body.span); - let mut checker = FunctionRefChecker { - tcx, - body, - potential_lints: Vec::new(), - casts: Vec::new(), - calls: Vec::new(), - source_info, - }; +impl<'tcx> MirPass<'tcx> for FunctionItemReferences { + fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) { + let mut checker = FunctionItemRefChecker { tcx, body }; checker.visit_body(&body); } } -struct FunctionRefChecker<'a, 'tcx> { +struct FunctionItemRefChecker<'a, 'tcx> { tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, - potential_lints: Vec, - casts: Vec, - calls: Vec, - source_info: SourceInfo, } -impl<'a, 'tcx> Visitor<'tcx> for FunctionRefChecker<'a, 'tcx> { - fn visit_basic_block_data(&mut self, block: BasicBlock, data: &BasicBlockData<'tcx>) { - self.super_basic_block_data(block, data); - for cast_span in self.casts.drain(..) { - self.potential_lints.retain(|lint| lint.source_info.span != cast_span); - } - for call_span in self.calls.drain(..) { - self.potential_lints.retain(|lint| lint.source_info.span != call_span); - } - for lint in self.potential_lints.drain(..) { - lint.emit(self.tcx, self.body); - } - } - fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) { - self.source_info = statement.source_info; - self.super_statement(statement, location); - } +impl<'a, 'tcx> Visitor<'tcx> for FunctionItemRefChecker<'a, 'tcx> { fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) { - self.source_info = terminator.source_info; if let TerminatorKind::Call { func, - args: _, + args, destination: _, cleanup: _, from_hir_call: _, fn_span: _, } = &terminator.kind { - let span = match func { - Operand::Copy(place) | Operand::Move(place) => { - self.body.local_decls[place.local].source_info.span + let func_ty = func.ty(self.body, self.tcx); + if let ty::FnDef(def_id, substs_ref) = *func_ty.kind() { + //check arguments for `std::mem::transmute` + if self.tcx.is_diagnostic_item(sym::transmute, def_id) { + let arg_ty = args[0].ty(self.body, self.tcx); + for generic_inner_ty in arg_ty.walk() { + if let GenericArgKind::Type(inner_ty) = generic_inner_ty.unpack() { + if let Some(fn_id) = FunctionItemRefChecker::is_fn_ref(inner_ty) { + let ident = self.tcx.item_name(fn_id).to_ident_string(); + let source_info = *self.body.source_info(location); + let span = self.nth_arg_span(&args, 0); + self.emit_lint(ident, fn_id, source_info, span); + } + } + } + } else { + //check arguments for any function with `std::fmt::Pointer` as a bound trait + let param_env = self.tcx.param_env(def_id); + let bounds = param_env.caller_bounds(); + for bound in bounds { + if let Some(bound_ty) = self.is_pointer_trait(&bound.skip_binders()) { + let arg_defs = self.tcx.fn_sig(def_id).skip_binder().inputs(); + for (arg_num, arg_def) in arg_defs.iter().enumerate() { + for generic_inner_ty in arg_def.walk() { + if let GenericArgKind::Type(inner_ty) = + generic_inner_ty.unpack() + { + //if any type reachable from the argument types in the fn sig matches the type bound by `Pointer` + if TyS::same_type(inner_ty, bound_ty) { + //check if this type is a function reference in the function call + let norm_ty = + self.tcx.subst_and_normalize_erasing_regions( + substs_ref, param_env, &inner_ty, + ); + if let Some(fn_id) = + FunctionItemRefChecker::is_fn_ref(norm_ty) + { + let ident = + self.tcx.item_name(fn_id).to_ident_string(); + let source_info = *self.body.source_info(location); + let span = self.nth_arg_span(&args, arg_num); + self.emit_lint(ident, fn_id, source_info, span); + } + } + } + } + } + } + } } - Operand::Constant(constant) => constant.span, - }; - self.calls.push(span); - }; + } + } self.super_terminator(terminator, location); } - fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) { - match rvalue { - Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => { - let decl = &self.body.local_decls[place.local]; - if let ty::FnDef(def_id, _) = decl.ty.kind { - let ident = self - .body - .var_debug_info - .iter() - .find(|info| info.source_info.span == decl.source_info.span) - .map(|info| info.name.to_ident_string()) - .unwrap_or(self.tcx.def_path_str(def_id)); - let lint = FunctionRefLint { ident, def_id, source_info: self.source_info }; - self.potential_lints.push(lint); + //check for `std::fmt::Pointer::::fmt` where T is a function reference + //this is used in formatting macros, but doesn't rely on the specific expansion + fn visit_operand(&mut self, operand: &Operand<'tcx>, location: Location) { + let op_ty = operand.ty(self.body, self.tcx); + if let ty::FnDef(def_id, substs_ref) = *op_ty.kind() { + if self.tcx.is_diagnostic_item(sym::pointer_trait_fmt, def_id) { + let param_ty = substs_ref.type_at(0); + if let Some(fn_id) = FunctionItemRefChecker::is_fn_ref(param_ty) { + let source_info = *self.body.source_info(location); + let callsite_ctxt = source_info.span.source_callsite().ctxt(); + let span = source_info.span.with_ctxt(callsite_ctxt); + let ident = self.tcx.item_name(fn_id).to_ident_string(); + self.emit_lint(ident, fn_id, source_info, span); } } - Rvalue::Cast(_, op, _) => { - let op_ty = op.ty(self.body, self.tcx); - if self.is_fn_ref(op_ty) { - self.casts.push(self.source_info.span); - } - } - _ => {} } - self.super_rvalue(rvalue, location); + self.super_operand(operand, location); } } -impl<'a, 'tcx> FunctionRefChecker<'a, 'tcx> { - fn is_fn_ref(&self, ty: Ty<'tcx>) -> bool { - let referent_ty = match ty.kind { +impl<'a, 'tcx> FunctionItemRefChecker<'a, 'tcx> { + //return the bound parameter type if the trait is `std::fmt::Pointer` + fn is_pointer_trait(&self, bound: &PredicateAtom<'tcx>) -> Option> { + if let ty::PredicateAtom::Trait(predicate, _) = bound { + if self.tcx.is_diagnostic_item(sym::pointer_trait, predicate.def_id()) { + Some(predicate.trait_ref.self_ty()) + } else { + None + } + } else { + None + } + } + fn is_fn_ref(ty: Ty<'tcx>) -> Option { + let referent_ty = match ty.kind() { ty::Ref(_, referent_ty, _) => Some(referent_ty), - ty::RawPtr(ty_and_mut) => Some(ty_and_mut.ty), + ty::RawPtr(ty_and_mut) => Some(&ty_and_mut.ty), _ => None, }; referent_ty - .map(|ref_ty| if let ty::FnDef(..) = ref_ty.kind { true } else { false }) - .unwrap_or(false) + .map( + |ref_ty| { + if let ty::FnDef(def_id, _) = *ref_ty.kind() { Some(def_id) } else { None } + }, + ) + .unwrap_or(None) } -} - -struct FunctionRefLint { - ident: String, - def_id: DefId, - source_info: SourceInfo, -} - -impl<'tcx> FunctionRefLint { - fn emit(&self, tcx: TyCtxt<'tcx>, body: &Body<'tcx>) { - let def_id = self.def_id; - let source_info = self.source_info; - let lint_root = body.source_scopes[source_info.scope] + fn nth_arg_span(&self, args: &Vec>, n: usize) -> Span { + match &args[n] { + Operand::Copy(place) | Operand::Move(place) => { + self.body.local_decls[place.local].source_info.span + } + Operand::Constant(constant) => constant.span, + } + } + fn emit_lint(&self, ident: String, fn_id: DefId, source_info: SourceInfo, span: Span) { + let lint_root = self.body.source_scopes[source_info.scope] .local_data .as_ref() .assert_crate_local() .lint_root; - let fn_sig = tcx.fn_sig(def_id); + let fn_sig = self.tcx.fn_sig(fn_id); let unsafety = fn_sig.unsafety().prefix_str(); let abi = match fn_sig.abi() { Abi::Rust => String::from(""), @@ -142,17 +162,17 @@ impl<'tcx> FunctionRefLint { let num_args = fn_sig.inputs().map_bound(|inputs| inputs.len()).skip_binder(); let variadic = if fn_sig.c_variadic() { ", ..." } else { "" }; let ret = if fn_sig.output().skip_binder().is_unit() { "" } else { " -> _" }; - tcx.struct_span_lint_hir(FUNCTION_REFERENCES, lint_root, source_info.span, |lint| { + self.tcx.struct_span_lint_hir(FUNCTION_ITEM_REFERENCES, lint_root, span, |lint| { lint.build(&format!( "cast `{}` with `as {}{}fn({}{}){}` to use it as a pointer", - self.ident, + ident, unsafety, abi, vec!["_"; num_args].join(", "), variadic, ret, )) - .emit() + .emit(); }); } } diff --git a/compiler/rustc_mir/src/transform/mod.rs b/compiler/rustc_mir/src/transform/mod.rs index 3f50420b86b..e43a238c1ba 100644 --- a/compiler/rustc_mir/src/transform/mod.rs +++ b/compiler/rustc_mir/src/transform/mod.rs @@ -267,7 +267,7 @@ fn mir_const<'tcx>( // MIR-level lints. &check_packed_ref::CheckPackedRef, &check_const_item_mutation::CheckConstItemMutation, - &function_references::FunctionReferences, + &function_references::FunctionItemReferences, // What we need to do constant evaluation. &simplify::SimplifyCfg::new("initial"), &rustc_peek::SanityCheck, diff --git a/compiler/rustc_session/src/lint/builtin.rs b/compiler/rustc_session/src/lint/builtin.rs index 4cfd3277202..41abdacb54c 100644 --- a/compiler/rustc_session/src/lint/builtin.rs +++ b/compiler/rustc_session/src/lint/builtin.rs @@ -2645,9 +2645,10 @@ declare_lint! { reference: "issue #76200 ", edition: None, }; +} declare_lint! { - pub FUNCTION_REFERENCES, + pub FUNCTION_ITEM_REFERENCES, Warn, "suggest casting functions to pointers when attempting to take references", } @@ -2767,7 +2768,7 @@ declare_lint_pass! { CONST_EVALUATABLE_UNCHECKED, INEFFECTIVE_UNSTABLE_TRAIT_IMPL, UNINHABITED_STATIC, - FUNCTION_REFERENCES, + FUNCTION_ITEM_REFERENCES, ] } diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 080afdcd2c0..ef0f09ae818 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -796,6 +796,8 @@ symbols! { plugin_registrar, plugins, pointer, + pointer_trait, + pointer_trait_fmt, poll, position, post_dash_lto: "post-lto", diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs index 0963c6d6cd7..506d7780686 100644 --- a/library/core/src/fmt/mod.rs +++ b/library/core/src/fmt/mod.rs @@ -920,9 +920,11 @@ pub trait UpperHex { /// assert_eq!(&l_ptr[..2], "0x"); /// ``` #[stable(feature = "rust1", since = "1.0.0")] +#[rustc_diagnostic_item = "pointer_trait"] pub trait Pointer { /// Formats the value using the given formatter. #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_diagnostic_item = "pointer_trait_fmt"] fn fmt(&self, f: &mut Formatter<'_>) -> Result; } diff --git a/src/test/ui/lint/function-references.rs b/src/test/ui/lint/function-references.rs index ad0380375d6..1a8dde85790 100644 --- a/src/test/ui/lint/function-references.rs +++ b/src/test/ui/lint/function-references.rs @@ -1,7 +1,9 @@ // check-pass #![feature(c_variadic)] -#![allow(dead_code)] +#![warn(function_item_references)] +use std::fmt::Pointer; +fn nop() { } fn foo() -> u32 { 42 } fn bar(x: u32) -> u32 { x } fn baz(x: u32, y: u32) -> u32 { x + y } @@ -9,63 +11,127 @@ unsafe fn unsafe_fn() { } extern "C" fn c_fn() { } unsafe extern "C" fn unsafe_c_fn() { } unsafe extern fn variadic_fn(_x: u32, _args: ...) { } + +//function references passed to these functions should never lint fn call_fn(f: &dyn Fn(u32) -> u32, x: u32) { f(x); } fn parameterized_call_fn u32>(f: &F, x: u32) { f(x); } -fn main() { - let _zst_ref = &foo; - //~^ WARN cast `foo` with `as fn() -> _` to use it as a pointer - let fn_item = foo; - let _indirect_ref = &fn_item; - //~^ WARN cast `fn_item` with `as fn() -> _` to use it as a pointer - let _cast_zst_ptr = &foo as *const _; - //~^ WARN cast `foo` with `as fn() -> _` to use it as a pointer - let _coerced_zst_ptr: *const _ = &foo; - //~^ WARN cast `foo` with `as fn() -> _` to use it as a pointer +//function references passed to these functions should lint +fn print_ptr(f: F) { println!("{:p}", f); } +fn bound_by_ptr_trait(_f: F) { } +fn bound_by_ptr_trait_tuple(_t: (F, G)) { } +fn implicit_ptr_trait(f: &F) { println!("{:p}", f); } - let _zst_ref = &mut foo; - //~^ WARN cast `foo` with `as fn() -> _` to use it as a pointer +fn main() { + //`let` bindings with function references shouldn't lint + let _ = &foo; + let _ = &mut foo; + + let zst_ref = &foo; + let fn_item = foo; + let indirect_ref = &fn_item; + + let _mut_zst_ref = &mut foo; let mut mut_fn_item = foo; - let _indirect_ref = &mut mut_fn_item; - //~^ WARN cast `fn_item` with `as fn() -> _` to use it as a pointer - let _cast_zst_ptr = &mut foo as *mut _; - //~^ WARN cast `foo` with `as fn() -> _` to use it as a pointer - let _coerced_zst_ptr: *mut _ = &mut foo; - //~^ WARN cast `foo` with `as fn() -> _` to use it as a pointer + let _mut_indirect_ref = &mut mut_fn_item; + + let cast_zst_ptr = &foo as *const _; + let coerced_zst_ptr: *const _ = &foo; + + let _mut_cast_zst_ptr = &mut foo as *mut _; + let _mut_coerced_zst_ptr: *mut _ = &mut foo; let _cast_zst_ref = &foo as &dyn Fn() -> u32; let _coerced_zst_ref: &dyn Fn() -> u32 = &foo; - let _cast_zst_ref = &mut foo as &mut dyn Fn() -> u32; - let _coerced_zst_ref: &mut dyn Fn() -> u32 = &mut foo; - let _fn_ptr = foo as fn() -> u32; + let _mut_cast_zst_ref = &mut foo as &mut dyn Fn() -> u32; + let _mut_coerced_zst_ref: &mut dyn Fn() -> u32 = &mut foo; - println!("{:p}", &foo); - //~^ WARN cast `foo` with as fn() -> _` to use it as a pointer - println!("{:p}", &bar); - //~^ WARN cast `bar` with as fn(_) -> _` to use it as a pointer - println!("{:p}", &baz); - //~^ WARN cast `baz` with as fn(_, _) -> _` to use it as a pointer - println!("{:p}", &unsafe_fn); - //~^ WARN cast `baz` with as unsafe fn()` to use it as a pointer - println!("{:p}", &c_fn); - //~^ WARN cast `baz` with as extern "C" fn()` to use it as a pointer - println!("{:p}", &unsafe_c_fn); - //~^ WARN cast `baz` with as unsafe extern "C" fn()` to use it as a pointer - println!("{:p}", &variadic_fn); - //~^ WARN cast `baz` with as unsafe extern "C" fn(_, ...) -> _` to use it as a pointer - println!("{:p}", &std::env::var::); - //~^ WARN cast `std::env::var` with as fn(_) -> _` to use it as a pointer + //the suggested way to cast to a function pointer + let fn_ptr = foo as fn() -> u32; + //correct ways to print function pointers println!("{:p}", foo as fn() -> u32); + println!("{:p}", fn_ptr); - unsafe { - std::mem::transmute::<_, usize>(&foo); - //~^ WARN cast `foo` with as fn() -> _` to use it as a pointer - std::mem::transmute::<_, usize>(foo as fn() -> u32); - } + //potential ways to incorrectly try printing function pointers + println!("{:p}", &foo); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + print!("{:p}", &foo); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + format!("{:p}", &foo); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + println!("{:p}", &foo as *const _); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + println!("{:p}", zst_ref); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + println!("{:p}", cast_zst_ptr); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + println!("{:p}", coerced_zst_ptr); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + + println!("{:p}", &fn_item); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + println!("{:p}", indirect_ref); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + + println!("{:p}", &nop); + //~^ WARNING cast `nop` with `as fn()` to use it as a pointer + println!("{:p}", &bar); + //~^ WARNING cast `bar` with `as fn(_) -> _` to use it as a pointer + println!("{:p}", &baz); + //~^ WARNING cast `baz` with `as fn(_, _) -> _` to use it as a pointer + println!("{:p}", &unsafe_fn); + //~^ WARNING cast `unsafe_fn` with `as unsafe fn()` to use it as a pointer + println!("{:p}", &c_fn); + //~^ WARNING cast `c_fn` with `as extern "C" fn()` to use it as a pointer + println!("{:p}", &unsafe_c_fn); + //~^ WARNING cast `unsafe_c_fn` with `as unsafe extern "C" fn()` to use it as a pointer + println!("{:p}", &variadic_fn); + //~^ WARNING cast `variadic_fn` with `as unsafe extern "C" fn(_, ...)` to use it as a pointer + println!("{:p}", &std::env::var::); + //~^ WARNING cast `var` with `as fn(_) -> _` to use it as a pointer + + println!("{:p} {:p} {:p}", &nop, &foo, &bar); + //~^ WARNING cast `nop` with `as fn()` to use it as a pointer + //~^^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + //~^^^ WARNING cast `bar` with `as fn(_) -> _` to use it as a pointer + + //using a function reference to call a function shouldn't lint (&bar)(1); + + //passing a function reference to an arbitrary function shouldn't lint call_fn(&bar, 1); parameterized_call_fn(&bar, 1); + std::mem::size_of_val(&foo); + + unsafe { + //potential ways to incorrectly try transmuting function pointers + std::mem::transmute::<_, usize>(&foo); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + std::mem::transmute::<_, (usize, usize)>((&foo, &bar)); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + //~^^ WARNING cast `bar` with `as fn(_) -> _` to use it as a pointer + + //the correct way to transmute function pointers + std::mem::transmute::<_, usize>(foo as fn() -> u32); + std::mem::transmute::<_, (usize, usize)>((foo as fn() -> u32, bar as fn(u32) -> u32)); + } + + //function references as arguments required to be bound by std::fmt::Pointer should lint + print_ptr(&bar); + //~^ WARNING cast `bar` with `as fn(_) -> _` to use it as a pointer + bound_by_ptr_trait(&bar); + //~^ WARNING cast `bar` with `as fn(_) -> _` to use it as a pointer + bound_by_ptr_trait_tuple((&foo, &bar)); + //~^ WARNING cast `foo` with `as fn() -> _` to use it as a pointer + //~^^ WARNING cast `bar` with `as fn(_) -> _` to use it as a pointer + implicit_ptr_trait(&bar); + //~^ WARNING cast `bar` with `as fn(_) -> _` to use it as a pointer + + //correct ways to pass function pointers as arguments bound by std::fmt::Pointer + print_ptr(bar as fn(u32) -> u32); + bound_by_ptr_trait(bar as fn(u32) -> u32); + bound_by_ptr_trait_tuple((foo as fn() -> u32, bar as fn(u32) -> u32)); } diff --git a/src/test/ui/lint/function-references.stderr b/src/test/ui/lint/function-references.stderr index 62dbf7f835d..bc4947b3d70 100644 --- a/src/test/ui/lint/function-references.stderr +++ b/src/test/ui/lint/function-references.stderr @@ -1,105 +1,170 @@ warning: cast `foo` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:16:20 - | -LL | let _zst_ref = &foo; - | ^^^^ - | - = note: `#[warn(function_references)]` on by default - -warning: cast `fn_item` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:19:25 - | -LL | let _indirect_ref = &fn_item; - | ^^^^^^^^ - -warning: cast `foo` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:21:25 - | -LL | let _cast_zst_ptr = &foo as *const _; - | ^^^^ - -warning: cast `foo` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:23:38 - | -LL | let _coerced_zst_ptr: *const _ = &foo; - | ^^^^ - -warning: cast `foo` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:26:20 - | -LL | let _zst_ref = &mut foo; - | ^^^^^^^^ - -warning: cast `mut_fn_item` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:29:25 - | -LL | let _indirect_ref = &mut mut_fn_item; - | ^^^^^^^^^^^^^^^^ - -warning: cast `foo` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:31:25 - | -LL | let _cast_zst_ptr = &mut foo as *mut _; - | ^^^^^^^^ - -warning: cast `foo` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:33:36 - | -LL | let _coerced_zst_ptr: *mut _ = &mut foo; - | ^^^^^^^^ - -warning: cast `foo` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:43:22 + --> $DIR/function-references.rs:58:22 | LL | println!("{:p}", &foo); | ^^^^ + | +note: the lint level is defined here + --> $DIR/function-references.rs:3:9 + | +LL | #![warn(function_item_references)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:60:20 + | +LL | print!("{:p}", &foo); + | ^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:62:21 + | +LL | format!("{:p}", &foo); + | ^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:65:22 + | +LL | println!("{:p}", &foo as *const _); + | ^^^^^^^^^^^^^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:67:22 + | +LL | println!("{:p}", zst_ref); + | ^^^^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:69:22 + | +LL | println!("{:p}", cast_zst_ptr); + | ^^^^^^^^^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:71:22 + | +LL | println!("{:p}", coerced_zst_ptr); + | ^^^^^^^^^^^^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:74:22 + | +LL | println!("{:p}", &fn_item); + | ^^^^^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:76:22 + | +LL | println!("{:p}", indirect_ref); + | ^^^^^^^^^^^^ + +warning: cast `nop` with `as fn()` to use it as a pointer + --> $DIR/function-references.rs:79:22 + | +LL | println!("{:p}", &nop); + | ^^^^ warning: cast `bar` with `as fn(_) -> _` to use it as a pointer - --> $DIR/function-references.rs:45:22 + --> $DIR/function-references.rs:81:22 | LL | println!("{:p}", &bar); | ^^^^ warning: cast `baz` with `as fn(_, _) -> _` to use it as a pointer - --> $DIR/function-references.rs:47:22 + --> $DIR/function-references.rs:83:22 | LL | println!("{:p}", &baz); | ^^^^ warning: cast `unsafe_fn` with `as unsafe fn()` to use it as a pointer - --> $DIR/function-references.rs:49:22 + --> $DIR/function-references.rs:85:22 | LL | println!("{:p}", &unsafe_fn); | ^^^^^^^^^^ warning: cast `c_fn` with `as extern "C" fn()` to use it as a pointer - --> $DIR/function-references.rs:51:22 + --> $DIR/function-references.rs:87:22 | LL | println!("{:p}", &c_fn); | ^^^^^ warning: cast `unsafe_c_fn` with `as unsafe extern "C" fn()` to use it as a pointer - --> $DIR/function-references.rs:53:22 + --> $DIR/function-references.rs:89:22 | LL | println!("{:p}", &unsafe_c_fn); | ^^^^^^^^^^^^ warning: cast `variadic_fn` with `as unsafe extern "C" fn(_, ...)` to use it as a pointer - --> $DIR/function-references.rs:55:22 + --> $DIR/function-references.rs:91:22 | LL | println!("{:p}", &variadic_fn); | ^^^^^^^^^^^^ -warning: cast `std::env::var` with `as fn(_) -> _` to use it as a pointer - --> $DIR/function-references.rs:57:22 +warning: cast `var` with `as fn(_) -> _` to use it as a pointer + --> $DIR/function-references.rs:93:22 | LL | println!("{:p}", &std::env::var::); | ^^^^^^^^^^^^^^^^^^^^^^^^ +warning: cast `nop` with `as fn()` to use it as a pointer + --> $DIR/function-references.rs:96:32 + | +LL | println!("{:p} {:p} {:p}", &nop, &foo, &bar); + | ^^^^ + warning: cast `foo` with `as fn() -> _` to use it as a pointer - --> $DIR/function-references.rs:63:41 + --> $DIR/function-references.rs:96:38 + | +LL | println!("{:p} {:p} {:p}", &nop, &foo, &bar); + | ^^^^ + +warning: cast `bar` with `as fn(_) -> _` to use it as a pointer + --> $DIR/function-references.rs:96:44 + | +LL | println!("{:p} {:p} {:p}", &nop, &foo, &bar); + | ^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:111:41 | LL | std::mem::transmute::<_, usize>(&foo); | ^^^^ -warning: 17 warnings emitted +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:113:50 + | +LL | std::mem::transmute::<_, (usize, usize)>((&foo, &bar)); + | ^^^^^^^^^^^^ + +warning: cast `bar` with `as fn(_) -> _` to use it as a pointer + --> $DIR/function-references.rs:113:50 + | +LL | std::mem::transmute::<_, (usize, usize)>((&foo, &bar)); + | ^^^^^^^^^^^^ + +warning: cast `bar` with `as fn(_) -> _` to use it as a pointer + --> $DIR/function-references.rs:123:15 + | +LL | print_ptr(&bar); + | ^^^^ + +warning: cast `bar` with `as fn(_) -> _` to use it as a pointer + --> $DIR/function-references.rs:125:24 + | +LL | bound_by_ptr_trait(&bar); + | ^^^^ + +warning: cast `bar` with `as fn(_) -> _` to use it as a pointer + --> $DIR/function-references.rs:127:30 + | +LL | bound_by_ptr_trait_tuple((&foo, &bar)); + | ^^^^^^^^^^^^ + +warning: cast `foo` with `as fn() -> _` to use it as a pointer + --> $DIR/function-references.rs:127:30 + | +LL | bound_by_ptr_trait_tuple((&foo, &bar)); + | ^^^^^^^^^^^^ + +warning: 27 warnings emitted +