From 5800dc1faa391d878077cd79ac4820055ca6c0e4 Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Thu, 11 Apr 2024 17:16:28 -0700 Subject: New slice indexing pre-codegen MIR test --- tests/mir-opt/pre-codegen/slice_index.rs | 9 +++++++++ ...t_unchecked_range.PreCodegen.after.panic-abort.mir | 19 +++++++++++++++++++ ..._unchecked_range.PreCodegen.after.panic-unwind.mir | 19 +++++++++++++++++++ 3 files changed, 47 insertions(+) create mode 100644 tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir create mode 100644 tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir (limited to 'tests') diff --git a/tests/mir-opt/pre-codegen/slice_index.rs b/tests/mir-opt/pre-codegen/slice_index.rs index c9dd72d8be2..04bbbff57b3 100644 --- a/tests/mir-opt/pre-codegen/slice_index.rs +++ b/tests/mir-opt/pre-codegen/slice_index.rs @@ -3,6 +3,7 @@ // EMIT_MIR_FOR_EACH_PANIC_STRATEGY #![crate_type = "lib"] +#![feature(slice_ptr_get)] use std::ops::Range; @@ -25,3 +26,11 @@ pub fn slice_index_range(slice: &[u32], index: Range) -> &[u32] { pub unsafe fn slice_get_unchecked_mut_range(slice: &mut [u32], index: Range) -> &mut [u32] { slice.get_unchecked_mut(index) } + +// EMIT_MIR slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.mir +pub unsafe fn slice_ptr_get_unchecked_range( + slice: *const [u32], + index: Range, +) -> *const [u32] { + slice.get_unchecked(index) +} diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir new file mode 100644 index 00000000000..79c6a05b48d --- /dev/null +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir @@ -0,0 +1,19 @@ +// MIR for `slice_ptr_get_unchecked_range` after PreCodegen + +fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) -> *const [u32] { + debug slice => _1; + debug index => _2; + let mut _0: *const [u32]; + scope 1 (inlined std::ptr::const_ptr::::get_unchecked::>) { + debug self => _1; + debug index => _2; + } + + bb0: { + _0 = as SliceIndex<[u32]>>::get_unchecked(move _2, move _1) -> [return: bb1, unwind unreachable]; + } + + bb1: { + return; + } +} diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir new file mode 100644 index 00000000000..5231f858d04 --- /dev/null +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir @@ -0,0 +1,19 @@ +// MIR for `slice_ptr_get_unchecked_range` after PreCodegen + +fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) -> *const [u32] { + debug slice => _1; + debug index => _2; + let mut _0: *const [u32]; + scope 1 (inlined std::ptr::const_ptr::::get_unchecked::>) { + debug self => _1; + debug index => _2; + } + + bb0: { + _0 = as SliceIndex<[u32]>>::get_unchecked(move _2, move _1) -> [return: bb1, unwind continue]; + } + + bb1: { + return; + } +} -- cgit 1.4.1-3-g733a5 From b76faff1b281fdf199e5abe8ff0c8d6d2e2e2a85 Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Fri, 29 Mar 2024 00:37:31 -0700 Subject: Add a MIR pre-codegen test for Vec::deref --- tests/mir-opt/pre-codegen/vec_deref.rs | 13 +++++++++++++ ...ref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir | 14 ++++++++++++++ ...ef.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir | 14 ++++++++++++++ 3 files changed, 41 insertions(+) create mode 100644 tests/mir-opt/pre-codegen/vec_deref.rs create mode 100644 tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir create mode 100644 tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir (limited to 'tests') diff --git a/tests/mir-opt/pre-codegen/vec_deref.rs b/tests/mir-opt/pre-codegen/vec_deref.rs new file mode 100644 index 00000000000..3476e1760c0 --- /dev/null +++ b/tests/mir-opt/pre-codegen/vec_deref.rs @@ -0,0 +1,13 @@ +// skip-filecheck +//@ compile-flags: -O -Zmir-opt-level=2 -Cdebuginfo=2 +// EMIT_MIR_FOR_EACH_PANIC_STRATEGY + +#![crate_type = "lib"] + +// Added after it stopped inlining in a nightly; see +// + +// EMIT_MIR vec_deref.vec_deref_to_slice.PreCodegen.after.mir +pub fn vec_deref_to_slice(v: &Vec) -> &[u8] { + v +} diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir new file mode 100644 index 00000000000..df8d5c3836f --- /dev/null +++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir @@ -0,0 +1,14 @@ +// MIR for `vec_deref_to_slice` after PreCodegen + +fn vec_deref_to_slice(_1: &Vec) -> &[u8] { + debug v => _1; + let mut _0: &[u8]; + + bb0: { + _0 = as Deref>::deref(move _1) -> [return: bb1, unwind unreachable]; + } + + bb1: { + return; + } +} diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir new file mode 100644 index 00000000000..d26afef4653 --- /dev/null +++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir @@ -0,0 +1,14 @@ +// MIR for `vec_deref_to_slice` after PreCodegen + +fn vec_deref_to_slice(_1: &Vec) -> &[u8] { + debug v => _1; + let mut _0: &[u8]; + + bb0: { + _0 = as Deref>::deref(move _1) -> [return: bb1, unwind continue]; + } + + bb1: { + return; + } +} -- cgit 1.4.1-3-g733a5 From 70df9d9a1396f95eeef3fb765af09d47d14b3a8a Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Sun, 14 Apr 2024 11:26:45 -0700 Subject: Add a mir-opt test for `byte_add` on pointers --- ...o_byte_add_fat.PreCodegen.after.panic-abort.mir | 62 ++++++++++++++++++++++ ..._byte_add_fat.PreCodegen.after.panic-unwind.mir | 62 ++++++++++++++++++++++ ..._byte_add_thin.PreCodegen.after.panic-abort.mir | 54 +++++++++++++++++++ ...byte_add_thin.PreCodegen.after.panic-unwind.mir | 54 +++++++++++++++++++ tests/mir-opt/pre-codegen/ptr_offset.rs | 16 ++++++ 5 files changed, 248 insertions(+) create mode 100644 tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir create mode 100644 tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir create mode 100644 tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir create mode 100644 tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir create mode 100644 tests/mir-opt/pre-codegen/ptr_offset.rs (limited to 'tests') diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir new file mode 100644 index 00000000000..81474306eec --- /dev/null +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir @@ -0,0 +1,62 @@ +// MIR for `demo_byte_add_fat` after PreCodegen + +fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { + debug p => _1; + debug n => _2; + let mut _0: *const [u32]; + scope 1 (inlined std::ptr::const_ptr::::byte_add) { + debug self => _1; + debug count => _2; + let mut _3: *const u8; + let mut _4: *const u8; + scope 2 (inlined std::ptr::const_ptr::::cast::) { + debug self => _1; + } + scope 3 (inlined std::ptr::const_ptr::::add) { + debug self => _3; + debug count => _2; + } + scope 4 (inlined std::ptr::const_ptr::::with_metadata_of::<[u32]>) { + debug self => _4; + debug meta => _1; + let mut _5: *const (); + let mut _7: usize; + scope 5 (inlined std::ptr::metadata::<[u32]>) { + debug ptr => _1; + let mut _6: std::ptr::metadata::PtrRepr<[u32]>; + } + scope 6 (inlined std::ptr::from_raw_parts::<[u32]>) { + debug data_pointer => _5; + debug metadata => _7; + let mut _8: std::ptr::metadata::PtrComponents<[u32]>; + let mut _9: std::ptr::metadata::PtrRepr<[u32]>; + } + } + } + + bb0: { + StorageLive(_4); + StorageLive(_3); + _3 = _1 as *const u8 (PtrToPtr); + _4 = Offset(_3, _2); + StorageDead(_3); + StorageLive(_5); + _5 = _4 as *const () (PtrToPtr); + StorageLive(_7); + StorageLive(_6); + _6 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: _1 }; + _7 = ((_6.2: std::ptr::metadata::PtrComponents<[u32]>).1: usize); + StorageDead(_6); + StorageLive(_9); + StorageLive(_8); + _8 = std::ptr::metadata::PtrComponents::<[u32]> { data_pointer: _5, metadata: _7 }; + _9 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: move _8 }; + StorageDead(_8); + _0 = (_9.0: *const [u32]); + StorageDead(_9); + StorageDead(_7); + StorageDead(_5); + StorageDead(_4); + return; + } +} diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir new file mode 100644 index 00000000000..81474306eec --- /dev/null +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir @@ -0,0 +1,62 @@ +// MIR for `demo_byte_add_fat` after PreCodegen + +fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { + debug p => _1; + debug n => _2; + let mut _0: *const [u32]; + scope 1 (inlined std::ptr::const_ptr::::byte_add) { + debug self => _1; + debug count => _2; + let mut _3: *const u8; + let mut _4: *const u8; + scope 2 (inlined std::ptr::const_ptr::::cast::) { + debug self => _1; + } + scope 3 (inlined std::ptr::const_ptr::::add) { + debug self => _3; + debug count => _2; + } + scope 4 (inlined std::ptr::const_ptr::::with_metadata_of::<[u32]>) { + debug self => _4; + debug meta => _1; + let mut _5: *const (); + let mut _7: usize; + scope 5 (inlined std::ptr::metadata::<[u32]>) { + debug ptr => _1; + let mut _6: std::ptr::metadata::PtrRepr<[u32]>; + } + scope 6 (inlined std::ptr::from_raw_parts::<[u32]>) { + debug data_pointer => _5; + debug metadata => _7; + let mut _8: std::ptr::metadata::PtrComponents<[u32]>; + let mut _9: std::ptr::metadata::PtrRepr<[u32]>; + } + } + } + + bb0: { + StorageLive(_4); + StorageLive(_3); + _3 = _1 as *const u8 (PtrToPtr); + _4 = Offset(_3, _2); + StorageDead(_3); + StorageLive(_5); + _5 = _4 as *const () (PtrToPtr); + StorageLive(_7); + StorageLive(_6); + _6 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: _1 }; + _7 = ((_6.2: std::ptr::metadata::PtrComponents<[u32]>).1: usize); + StorageDead(_6); + StorageLive(_9); + StorageLive(_8); + _8 = std::ptr::metadata::PtrComponents::<[u32]> { data_pointer: _5, metadata: _7 }; + _9 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: move _8 }; + StorageDead(_8); + _0 = (_9.0: *const [u32]); + StorageDead(_9); + StorageDead(_7); + StorageDead(_5); + StorageDead(_4); + return; + } +} diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir new file mode 100644 index 00000000000..d86f2d1106a --- /dev/null +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir @@ -0,0 +1,54 @@ +// MIR for `demo_byte_add_thin` after PreCodegen + +fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { + debug p => _1; + debug n => _2; + let mut _0: *const u32; + scope 1 (inlined std::ptr::const_ptr::::byte_add) { + debug self => _1; + debug count => _2; + let mut _3: *const u8; + let mut _4: *const u8; + scope 2 (inlined std::ptr::const_ptr::::cast::) { + debug self => _1; + } + scope 3 (inlined std::ptr::const_ptr::::add) { + debug self => _3; + debug count => _2; + } + scope 4 (inlined std::ptr::const_ptr::::with_metadata_of::) { + debug self => _4; + debug meta => _1; + let mut _5: *const (); + scope 5 (inlined std::ptr::metadata::) { + debug ptr => _1; + } + scope 6 (inlined std::ptr::from_raw_parts::) { + debug data_pointer => _5; + debug metadata => const (); + let mut _6: std::ptr::metadata::PtrComponents; + let mut _7: std::ptr::metadata::PtrRepr; + } + } + } + + bb0: { + StorageLive(_4); + StorageLive(_3); + _3 = _1 as *const u8 (PtrToPtr); + _4 = Offset(_3, _2); + StorageDead(_3); + StorageLive(_5); + _5 = _4 as *const () (PtrToPtr); + StorageLive(_7); + StorageLive(_6); + _6 = std::ptr::metadata::PtrComponents:: { data_pointer: _5, metadata: const () }; + _7 = std::ptr::metadata::PtrRepr:: { const_ptr: move _6 }; + StorageDead(_6); + _0 = (_7.0: *const u32); + StorageDead(_7); + StorageDead(_5); + StorageDead(_4); + return; + } +} diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir new file mode 100644 index 00000000000..d86f2d1106a --- /dev/null +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir @@ -0,0 +1,54 @@ +// MIR for `demo_byte_add_thin` after PreCodegen + +fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { + debug p => _1; + debug n => _2; + let mut _0: *const u32; + scope 1 (inlined std::ptr::const_ptr::::byte_add) { + debug self => _1; + debug count => _2; + let mut _3: *const u8; + let mut _4: *const u8; + scope 2 (inlined std::ptr::const_ptr::::cast::) { + debug self => _1; + } + scope 3 (inlined std::ptr::const_ptr::::add) { + debug self => _3; + debug count => _2; + } + scope 4 (inlined std::ptr::const_ptr::::with_metadata_of::) { + debug self => _4; + debug meta => _1; + let mut _5: *const (); + scope 5 (inlined std::ptr::metadata::) { + debug ptr => _1; + } + scope 6 (inlined std::ptr::from_raw_parts::) { + debug data_pointer => _5; + debug metadata => const (); + let mut _6: std::ptr::metadata::PtrComponents; + let mut _7: std::ptr::metadata::PtrRepr; + } + } + } + + bb0: { + StorageLive(_4); + StorageLive(_3); + _3 = _1 as *const u8 (PtrToPtr); + _4 = Offset(_3, _2); + StorageDead(_3); + StorageLive(_5); + _5 = _4 as *const () (PtrToPtr); + StorageLive(_7); + StorageLive(_6); + _6 = std::ptr::metadata::PtrComponents:: { data_pointer: _5, metadata: const () }; + _7 = std::ptr::metadata::PtrRepr:: { const_ptr: move _6 }; + StorageDead(_6); + _0 = (_7.0: *const u32); + StorageDead(_7); + StorageDead(_5); + StorageDead(_4); + return; + } +} diff --git a/tests/mir-opt/pre-codegen/ptr_offset.rs b/tests/mir-opt/pre-codegen/ptr_offset.rs new file mode 100644 index 00000000000..88ee00296a0 --- /dev/null +++ b/tests/mir-opt/pre-codegen/ptr_offset.rs @@ -0,0 +1,16 @@ +// skip-filecheck +//@ compile-flags: -O -C debuginfo=0 -Zmir-opt-level=2 -Zinline-mir +//@ ignore-debug: precondition checks are under cfg(debug_assertions) +// EMIT_MIR_FOR_EACH_PANIC_STRATEGY + +#![crate_type = "lib"] + +// EMIT_MIR ptr_offset.demo_byte_add_thin.PreCodegen.after.mir +pub unsafe fn demo_byte_add_thin(p: *const u32, n: usize) -> *const u32 { + p.byte_add(n) +} + +// EMIT_MIR ptr_offset.demo_byte_add_fat.PreCodegen.after.mir +pub unsafe fn demo_byte_add_fat(p: *const [u32], n: usize) -> *const [u32] { + p.byte_add(n) +} -- cgit 1.4.1-3-g733a5 From 4f4442655ee755b68fc04386f243c637a64f8320 Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Thu, 11 Apr 2024 15:33:37 -0700 Subject: Add an intrinsic that lowers to AggregateKind::RawPtr --- .../rustc_const_eval/src/transform/validate.rs | 5 +- compiler/rustc_hir_analysis/src/check/intrinsic.rs | 5 ++ .../rustc_mir_transform/src/lower_intrinsics.rs | 28 +++++++ compiler/rustc_span/src/symbol.rs | 1 + library/core/src/intrinsics.rs | 26 ++++++ ....make_pointers.LowerIntrinsics.panic-abort.diff | 95 ++++++++++++++++++++++ ...make_pointers.LowerIntrinsics.panic-unwind.diff | 95 ++++++++++++++++++++++ tests/mir-opt/lower_intrinsics.rs | 10 +++ 8 files changed, 264 insertions(+), 1 deletion(-) create mode 100644 tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff create mode 100644 tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff (limited to 'tests') diff --git a/compiler/rustc_const_eval/src/transform/validate.rs b/compiler/rustc_const_eval/src/transform/validate.rs index 527325f1d6f..bf5592c828f 100644 --- a/compiler/rustc_const_eval/src/transform/validate.rs +++ b/compiler/rustc_const_eval/src/transform/validate.rs @@ -946,7 +946,10 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> { self.fail(location, "input pointer must be thin"); } } else { - self.fail(location, "first operand to raw pointer aggregate must be a raw pointer"); + self.fail( + location, + "first operand to raw pointer aggregate must be a raw pointer", + ); } // FIXME: Check metadata more generally diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs index bd64621f077..fb4a76bf089 100644 --- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs +++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs @@ -128,6 +128,7 @@ pub fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) - | sym::variant_count | sym::is_val_statically_known | sym::ptr_mask + | sym::aggregate_raw_ptr | sym::ub_checks | sym::fadd_algebraic | sym::fsub_algebraic @@ -574,6 +575,10 @@ pub fn check_intrinsic_type( (0, 0, vec![Ty::new_imm_ptr(tcx, Ty::new_unit(tcx))], tcx.types.usize) } + // This type check is not particularly useful, but the `where` bounds + // on the definition in `core` do the heavy lifting for checking it. + sym::aggregate_raw_ptr => (3, 1, vec![param(1), param(2)], param(0)), + sym::ub_checks => (0, 1, Vec::new(), tcx.types.bool), sym::simd_eq diff --git a/compiler/rustc_mir_transform/src/lower_intrinsics.rs b/compiler/rustc_mir_transform/src/lower_intrinsics.rs index 7e8920604c1..da63fcf23d9 100644 --- a/compiler/rustc_mir_transform/src/lower_intrinsics.rs +++ b/compiler/rustc_mir_transform/src/lower_intrinsics.rs @@ -287,6 +287,34 @@ impl<'tcx> MirPass<'tcx> for LowerIntrinsics { terminator.kind = TerminatorKind::Unreachable; } } + sym::aggregate_raw_ptr => { + let Ok([data, meta]) = <[_; 2]>::try_from(std::mem::take(args)) else { + span_bug!( + terminator.source_info.span, + "Wrong number of arguments for aggregate_raw_ptr intrinsic", + ); + }; + let target = target.unwrap(); + let pointer_ty = generic_args.type_at(0); + let kind = if let ty::RawPtr(pointee_ty, mutability) = pointer_ty.kind() { + AggregateKind::RawPtr(*pointee_ty, *mutability) + } else { + span_bug!( + terminator.source_info.span, + "Return type of aggregate_raw_ptr intrinsic must be a raw pointer", + ); + }; + let fields = [data.node, meta.node]; + block.statements.push(Statement { + source_info: terminator.source_info, + kind: StatementKind::Assign(Box::new(( + *destination, + Rvalue::Aggregate(Box::new(kind), fields.into()), + ))), + }); + + terminator.kind = TerminatorKind::Goto { target }; + } _ => {} } } diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 46bae1c1e98..f5eeb3d4ff1 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -361,6 +361,7 @@ symbols! { adt_const_params, advanced_slice_patterns, adx_target_feature, + aggregate_raw_ptr, alias, align, align_offset, diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs index 9406efd7ab2..b49409a9f42 100644 --- a/library/core/src/intrinsics.rs +++ b/library/core/src/intrinsics.rs @@ -2779,6 +2779,32 @@ pub unsafe fn vtable_align(_ptr: *const ()) -> usize { unreachable!() } +/// Lowers in MIR to `Rvalue::Aggregate` with `AggregateKind::RawPtr`. +/// +/// This is used to implement functions like `slice::from_raw_parts_mut` and +/// `ptr::from_raw_parts` in a way compatible with the compiler being able to +/// change the possible layouts of pointers. +#[rustc_nounwind] +#[unstable(feature = "core_intrinsics", issue = "none")] +#[rustc_intrinsic] +#[rustc_intrinsic_must_be_overridden] +#[cfg(not(bootstrap))] +pub const fn aggregate_raw_ptr, D, M>(_data: D, _meta: M) -> P { + // No fallback because `libcore` doesn't want to know the layout + unreachable!() +} + +#[unstable(feature = "core_intrinsics", issue = "none")] +pub trait AggregateRawPtr { + type Metadata: Copy; +} +impl AggregateRawPtr<*const T> for *const P { + type Metadata =

::Metadata; +} +impl AggregateRawPtr<*mut T> for *mut P { + type Metadata =

::Metadata; +} + // Some functions are defined here because they accidentally got made // available in this module on stable. See . // (`transmute` also falls into this category, but it cannot be wrapped due to the diff --git a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff new file mode 100644 index 00000000000..02934d4c01e --- /dev/null +++ b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff @@ -0,0 +1,95 @@ +- // MIR for `make_pointers` before LowerIntrinsics ++ // MIR for `make_pointers` after LowerIntrinsics + + fn make_pointers(_1: *const u8, _2: *mut (), _3: usize) -> () { + debug a => _1; + debug b => _2; + debug n => _3; + let mut _0: (); + let _4: *const i32; + let mut _5: *const u8; + let mut _6: (); + let mut _8: *mut (); + let mut _9: (); + let mut _11: *const u8; + let mut _12: usize; + let mut _14: *mut (); + let mut _15: usize; + scope 1 { + debug _thin_const => _4; + let _7: *mut u8; + scope 2 { + debug _thin_mut => _7; + let _10: *const [u16]; + scope 3 { + debug _slice_const => _10; + let _13: *mut [u64]; + scope 4 { + debug _slice_mut => _13; + } + } + } + } + + bb0: { + StorageLive(_4); + StorageLive(_5); + _5 = _1; + StorageLive(_6); + _6 = (); +- _4 = aggregate_raw_ptr::<*const i32, *const u8, ()>(move _5, move _6) -> [return: bb1, unwind unreachable]; ++ _4 = *const i32 from (move _5, move _6); ++ goto -> bb1; + } + + bb1: { + StorageDead(_6); + StorageDead(_5); + StorageLive(_7); + StorageLive(_8); + _8 = _2; + StorageLive(_9); + _9 = (); +- _7 = aggregate_raw_ptr::<*mut u8, *mut (), ()>(move _8, move _9) -> [return: bb2, unwind unreachable]; ++ _7 = *mut u8 from (move _8, move _9); ++ goto -> bb2; + } + + bb2: { + StorageDead(_9); + StorageDead(_8); + StorageLive(_10); + StorageLive(_11); + _11 = _1; + StorageLive(_12); + _12 = _3; +- _10 = aggregate_raw_ptr::<*const [u16], *const u8, usize>(move _11, move _12) -> [return: bb3, unwind unreachable]; ++ _10 = *const [u16] from (move _11, move _12); ++ goto -> bb3; + } + + bb3: { + StorageDead(_12); + StorageDead(_11); + StorageLive(_13); + StorageLive(_14); + _14 = _2; + StorageLive(_15); + _15 = _3; +- _13 = aggregate_raw_ptr::<*mut [u64], *mut (), usize>(move _14, move _15) -> [return: bb4, unwind unreachable]; ++ _13 = *mut [u64] from (move _14, move _15); ++ goto -> bb4; + } + + bb4: { + StorageDead(_15); + StorageDead(_14); + _0 = const (); + StorageDead(_13); + StorageDead(_10); + StorageDead(_7); + StorageDead(_4); + return; + } + } + diff --git a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff new file mode 100644 index 00000000000..02934d4c01e --- /dev/null +++ b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff @@ -0,0 +1,95 @@ +- // MIR for `make_pointers` before LowerIntrinsics ++ // MIR for `make_pointers` after LowerIntrinsics + + fn make_pointers(_1: *const u8, _2: *mut (), _3: usize) -> () { + debug a => _1; + debug b => _2; + debug n => _3; + let mut _0: (); + let _4: *const i32; + let mut _5: *const u8; + let mut _6: (); + let mut _8: *mut (); + let mut _9: (); + let mut _11: *const u8; + let mut _12: usize; + let mut _14: *mut (); + let mut _15: usize; + scope 1 { + debug _thin_const => _4; + let _7: *mut u8; + scope 2 { + debug _thin_mut => _7; + let _10: *const [u16]; + scope 3 { + debug _slice_const => _10; + let _13: *mut [u64]; + scope 4 { + debug _slice_mut => _13; + } + } + } + } + + bb0: { + StorageLive(_4); + StorageLive(_5); + _5 = _1; + StorageLive(_6); + _6 = (); +- _4 = aggregate_raw_ptr::<*const i32, *const u8, ()>(move _5, move _6) -> [return: bb1, unwind unreachable]; ++ _4 = *const i32 from (move _5, move _6); ++ goto -> bb1; + } + + bb1: { + StorageDead(_6); + StorageDead(_5); + StorageLive(_7); + StorageLive(_8); + _8 = _2; + StorageLive(_9); + _9 = (); +- _7 = aggregate_raw_ptr::<*mut u8, *mut (), ()>(move _8, move _9) -> [return: bb2, unwind unreachable]; ++ _7 = *mut u8 from (move _8, move _9); ++ goto -> bb2; + } + + bb2: { + StorageDead(_9); + StorageDead(_8); + StorageLive(_10); + StorageLive(_11); + _11 = _1; + StorageLive(_12); + _12 = _3; +- _10 = aggregate_raw_ptr::<*const [u16], *const u8, usize>(move _11, move _12) -> [return: bb3, unwind unreachable]; ++ _10 = *const [u16] from (move _11, move _12); ++ goto -> bb3; + } + + bb3: { + StorageDead(_12); + StorageDead(_11); + StorageLive(_13); + StorageLive(_14); + _14 = _2; + StorageLive(_15); + _15 = _3; +- _13 = aggregate_raw_ptr::<*mut [u64], *mut (), usize>(move _14, move _15) -> [return: bb4, unwind unreachable]; ++ _13 = *mut [u64] from (move _14, move _15); ++ goto -> bb4; + } + + bb4: { + StorageDead(_15); + StorageDead(_14); + _0 = const (); + StorageDead(_13); + StorageDead(_10); + StorageDead(_7); + StorageDead(_4); + return; + } + } + diff --git a/tests/mir-opt/lower_intrinsics.rs b/tests/mir-opt/lower_intrinsics.rs index 693425c0041..12e526ab074 100644 --- a/tests/mir-opt/lower_intrinsics.rs +++ b/tests/mir-opt/lower_intrinsics.rs @@ -248,3 +248,13 @@ pub fn three_way_compare_signed(a: i16, b: i16) { pub fn three_way_compare_unsigned(a: u32, b: u32) { let _x = core::intrinsics::three_way_compare(a, b); } + +// EMIT_MIR lower_intrinsics.make_pointers.LowerIntrinsics.diff +pub fn make_pointers(a: *const u8, b: *mut (), n: usize) { + use std::intrinsics::aggregate_raw_ptr; + + let _thin_const: *const i32 = aggregate_raw_ptr(a, ()); + let _thin_mut: *mut u8 = aggregate_raw_ptr(b, ()); + let _slice_const: *const [u16] = aggregate_raw_ptr(a, n); + let _slice_mut: *mut [u64] = aggregate_raw_ptr(b, n); +} -- cgit 1.4.1-3-g733a5 From de64ff76f8abd65222f9f6db56e7652976c5339b Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Thu, 11 Apr 2024 17:01:27 -0700 Subject: Use it in the library, and `InstSimplify` it away in the easy places --- compiler/rustc_codegen_ssa/src/mir/rvalue.rs | 22 +++++++- compiler/rustc_const_eval/src/interpret/operand.rs | 11 ++++ compiler/rustc_const_eval/src/interpret/step.rs | 17 +++++- library/core/src/intrinsics.rs | 1 + library/core/src/ptr/metadata.rs | 32 ++++++++--- library/core/tests/ptr.rs | 8 +++ library/core/tests/slice.rs | 13 +++++ ...nchecked_range.PreCodegen.after.panic-abort.mir | 60 ++++++++++++++++++-- ...checked_range.PreCodegen.after.panic-unwind.mir | 60 ++++++++++++++++++-- ...deref_to_slice.PreCodegen.after.panic-abort.mir | 66 ++++++++++++++++++++-- ...eref_to_slice.PreCodegen.after.panic-unwind.mir | 66 ++++++++++++++++++++-- 11 files changed, 328 insertions(+), 28 deletions(-) (limited to 'tests') diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs index 6725a6d9e38..7823d4c249a 100644 --- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs +++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs @@ -9,7 +9,7 @@ use crate::MemFlags; use rustc_hir as hir; use rustc_middle::mir; -use rustc_middle::mir::Operand; +use rustc_middle::mir::{AggregateKind, Operand}; use rustc_middle::ty::cast::{CastTy, IntTy}; use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout}; use rustc_middle::ty::{self, adjustment::PointerCoercion, Instance, Ty, TyCtxt}; @@ -720,6 +720,24 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { OperandRef { val: OperandValue::Immediate(static_), layout } } mir::Rvalue::Use(ref operand) => self.codegen_operand(bx, operand), + mir::Rvalue::Aggregate(box mir::AggregateKind::RawPtr(..), ref fields) => { + let ty = rvalue.ty(self.mir, self.cx.tcx()); + let layout = self.cx.layout_of(self.monomorphize(ty)); + let [data, meta] = &*fields.raw else { + bug!("RawPtr fields: {fields:?}"); + }; + let data = self.codegen_operand(bx, data); + let meta = self.codegen_operand(bx, meta); + match (data.val, meta.val) { + (p @ OperandValue::Immediate(_), OperandValue::ZeroSized) => { + OperandRef { val: p, layout } + } + (OperandValue::Immediate(p), OperandValue::Immediate(m)) => { + OperandRef { val: OperandValue::Pair(p, m), layout } + } + _ => bug!("RawPtr operands {data:?} {meta:?}"), + } + } mir::Rvalue::Repeat(..) | mir::Rvalue::Aggregate(..) => { // According to `rvalue_creates_operand`, only ZST // aggregate rvalues are allowed to be operands. @@ -1032,6 +1050,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { mir::Rvalue::ThreadLocalRef(_) | mir::Rvalue::Use(..) => // (*) true, + // This always produces a `ty::RawPtr`, so will be Immediate or Pair + mir::Rvalue::Aggregate(box AggregateKind::RawPtr(..), ..) => true, mir::Rvalue::Repeat(..) | mir::Rvalue::Aggregate(..) => { let ty = rvalue.ty(self.mir, self.cx.tcx()); diff --git a/compiler/rustc_const_eval/src/interpret/operand.rs b/compiler/rustc_const_eval/src/interpret/operand.rs index 718c91b2f76..d4a6dab9ac3 100644 --- a/compiler/rustc_const_eval/src/interpret/operand.rs +++ b/compiler/rustc_const_eval/src/interpret/operand.rs @@ -603,6 +603,17 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { Ok(self.read_immediate(op)?.to_scalar()) } + pub fn read_mem_place_meta( + &self, + op: &impl Readable<'tcx, M::Provenance>, + ) -> InterpResult<'tcx, MemPlaceMeta> { + Ok(if op.layout().is_zst() { + MemPlaceMeta::None + } else { + MemPlaceMeta::Meta(self.read_scalar(op)?) + }) + } + // Pointer-sized reads are fairly common and need target layout access, so we wrap them in // convenience functions. diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs index c3f26da8a79..460cd377c8f 100644 --- a/compiler/rustc_const_eval/src/interpret/step.rs +++ b/compiler/rustc_const_eval/src/interpret/step.rs @@ -9,7 +9,7 @@ use rustc_middle::mir; use rustc_middle::ty::layout::LayoutOf; use rustc_target::abi::{FieldIdx, FIRST_VARIANT}; -use super::{ImmTy, InterpCx, InterpResult, Machine, PlaceTy, Projectable, Scalar}; +use super::{ImmTy, Immediate, InterpCx, InterpResult, Machine, PlaceTy, Projectable, Scalar}; use crate::util; impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { @@ -303,6 +303,21 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { let variant_dest = self.project_downcast(dest, variant_index)?; (variant_index, variant_dest, active_field_index) } + mir::AggregateKind::RawPtr(..) => { + // Trying to `project_field` into pointers tends not to work, + // so build the `Immediate` from the parts directly. + let [data, meta] = &operands.raw else { + bug!("{kind:?} should have 2 operands, had {operands:?}"); + }; + let data = self.eval_operand(data, None)?; + let data = self.read_pointer(&data)?; + let meta = self.eval_operand(meta, None)?; + let meta = self.read_mem_place_meta(&meta)?; + let ptr_imm = Immediate::new_pointer_with_meta(data, meta, self); + let ptr = ImmTy::from_immediate(ptr_imm, dest.layout); + self.copy_op(&ptr, dest)?; + return Ok(()); + } _ => (FIRST_VARIANT, dest.clone(), None), }; if active_field_index.is_some() { diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs index b49409a9f42..751f2210d0c 100644 --- a/library/core/src/intrinsics.rs +++ b/library/core/src/intrinsics.rs @@ -2786,6 +2786,7 @@ pub unsafe fn vtable_align(_ptr: *const ()) -> usize { /// change the possible layouts of pointers. #[rustc_nounwind] #[unstable(feature = "core_intrinsics", issue = "none")] +#[rustc_const_unstable(feature = "ptr_metadata", issue = "81513")] #[rustc_intrinsic] #[rustc_intrinsic_must_be_overridden] #[cfg(not(bootstrap))] diff --git a/library/core/src/ptr/metadata.rs b/library/core/src/ptr/metadata.rs index 25a06f121cd..1226c8e2419 100644 --- a/library/core/src/ptr/metadata.rs +++ b/library/core/src/ptr/metadata.rs @@ -2,6 +2,8 @@ use crate::fmt; use crate::hash::{Hash, Hasher}; +#[cfg(not(bootstrap))] +use crate::intrinsics::aggregate_raw_ptr; use crate::marker::Freeze; /// Provides the pointer metadata type of any pointed-to type. @@ -113,10 +115,17 @@ pub const fn from_raw_parts( data_pointer: *const (), metadata: ::Metadata, ) -> *const T { - // SAFETY: Accessing the value from the `PtrRepr` union is safe since *const T - // and PtrComponents have the same memory layouts. Only std can make this - // guarantee. - unsafe { PtrRepr { components: PtrComponents { data_pointer, metadata } }.const_ptr } + #[cfg(bootstrap)] + { + // SAFETY: Accessing the value from the `PtrRepr` union is safe since *const T + // and PtrComponents have the same memory layouts. Only std can make this + // guarantee. + unsafe { PtrRepr { components: PtrComponents { data_pointer, metadata } }.const_ptr } + } + #[cfg(not(bootstrap))] + { + aggregate_raw_ptr(data_pointer, metadata) + } } /// Performs the same functionality as [`from_raw_parts`], except that a @@ -130,10 +139,17 @@ pub const fn from_raw_parts_mut( data_pointer: *mut (), metadata: ::Metadata, ) -> *mut T { - // SAFETY: Accessing the value from the `PtrRepr` union is safe since *const T - // and PtrComponents have the same memory layouts. Only std can make this - // guarantee. - unsafe { PtrRepr { components: PtrComponents { data_pointer, metadata } }.mut_ptr } + #[cfg(bootstrap)] + { + // SAFETY: Accessing the value from the `PtrRepr` union is safe since *const T + // and PtrComponents have the same memory layouts. Only std can make this + // guarantee. + unsafe { PtrRepr { components: PtrComponents { data_pointer, metadata } }.mut_ptr } + } + #[cfg(not(bootstrap))] + { + aggregate_raw_ptr(data_pointer, metadata) + } } #[repr(C)] diff --git a/library/core/tests/ptr.rs b/library/core/tests/ptr.rs index 2c82eda9a58..7b55c2bf8a8 100644 --- a/library/core/tests/ptr.rs +++ b/library/core/tests/ptr.rs @@ -1163,3 +1163,11 @@ fn test_null_array_as_slice() { assert!(ptr.is_null()); assert_eq!(ptr.len(), 4); } + +#[test] +fn test_ptr_from_raw_parts_in_const() { + const EMPTY_SLICE_PTR: *const [i32] = + std::ptr::slice_from_raw_parts(std::ptr::without_provenance(123), 456); + assert_eq!(EMPTY_SLICE_PTR.addr(), 123); + assert_eq!(EMPTY_SLICE_PTR.len(), 456); +} diff --git a/library/core/tests/slice.rs b/library/core/tests/slice.rs index c5743eda3e8..ffe8ffcc7f2 100644 --- a/library/core/tests/slice.rs +++ b/library/core/tests/slice.rs @@ -2678,3 +2678,16 @@ fn test_get_many_mut_duplicate() { let mut v = vec![1, 2, 3, 4, 5]; assert!(v.get_many_mut([1, 3, 3, 4]).is_err()); } + +#[test] +fn test_slice_from_raw_parts_in_const() { + static FANCY: i32 = 4; + static FANCY_SLICE: &[i32] = unsafe { std::slice::from_raw_parts(&FANCY, 1) }; + assert_eq!(FANCY_SLICE.as_ptr(), std::ptr::addr_of!(FANCY)); + assert_eq!(FANCY_SLICE.len(), 1); + + const EMPTY_SLICE: &[i32] = + unsafe { std::slice::from_raw_parts(std::ptr::without_provenance(123456), 0) }; + assert_eq!(EMPTY_SLICE.as_ptr().addr(), 123456); + assert_eq!(EMPTY_SLICE.len(), 0); +} diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir index 79c6a05b48d..8446324c663 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir @@ -4,16 +4,66 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - debug slice => _1; debug index => _2; let mut _0: *const [u32]; + let mut _3: usize; + let mut _4: usize; scope 1 (inlined std::ptr::const_ptr::::get_unchecked::>) { debug self => _1; - debug index => _2; + debug ((index: std::ops::Range).0: usize) => _3; + debug ((index: std::ops::Range).1: usize) => _4; + scope 2 (inlined as SliceIndex<[u32]>>::get_unchecked) { + debug ((self: std::ops::Range).0: usize) => _3; + debug ((self: std::ops::Range).1: usize) => _4; + debug slice => _1; + let _5: usize; + let mut _6: *const u32; + let mut _7: *const u32; + scope 3 { + debug new_len => _5; + scope 6 (inlined std::ptr::const_ptr::::as_ptr) { + debug self => _1; + } + scope 7 (inlined std::ptr::const_ptr::::add) { + debug self => _6; + debug count => _3; + } + scope 8 (inlined slice_from_raw_parts::) { + debug data => _7; + debug len => _5; + let mut _8: *const (); + scope 9 (inlined std::ptr::const_ptr::::cast::<()>) { + debug self => _7; + } + scope 10 (inlined std::ptr::from_raw_parts::<[u32]>) { + debug data_pointer => _8; + debug metadata => _5; + } + } + } + scope 4 (inlined std::ptr::const_ptr::::len) { + debug self => _1; + scope 5 (inlined std::ptr::metadata::<[u32]>) { + debug ptr => _1; + } + } + } } bb0: { - _0 = as SliceIndex<[u32]>>::get_unchecked(move _2, move _1) -> [return: bb1, unwind unreachable]; - } - - bb1: { + _3 = move (_2.0: usize); + _4 = move (_2.1: usize); + StorageLive(_5); + _5 = SubUnchecked(_4, _3); + StorageLive(_7); + StorageLive(_6); + _6 = _1 as *const u32 (PtrToPtr); + _7 = Offset(_6, _3); + StorageDead(_6); + StorageLive(_8); + _8 = _7 as *const () (PtrToPtr); + _0 = *const [u32] from (_8, _5); + StorageDead(_8); + StorageDead(_7); + StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir index 5231f858d04..8446324c663 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir @@ -4,16 +4,66 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - debug slice => _1; debug index => _2; let mut _0: *const [u32]; + let mut _3: usize; + let mut _4: usize; scope 1 (inlined std::ptr::const_ptr::::get_unchecked::>) { debug self => _1; - debug index => _2; + debug ((index: std::ops::Range).0: usize) => _3; + debug ((index: std::ops::Range).1: usize) => _4; + scope 2 (inlined as SliceIndex<[u32]>>::get_unchecked) { + debug ((self: std::ops::Range).0: usize) => _3; + debug ((self: std::ops::Range).1: usize) => _4; + debug slice => _1; + let _5: usize; + let mut _6: *const u32; + let mut _7: *const u32; + scope 3 { + debug new_len => _5; + scope 6 (inlined std::ptr::const_ptr::::as_ptr) { + debug self => _1; + } + scope 7 (inlined std::ptr::const_ptr::::add) { + debug self => _6; + debug count => _3; + } + scope 8 (inlined slice_from_raw_parts::) { + debug data => _7; + debug len => _5; + let mut _8: *const (); + scope 9 (inlined std::ptr::const_ptr::::cast::<()>) { + debug self => _7; + } + scope 10 (inlined std::ptr::from_raw_parts::<[u32]>) { + debug data_pointer => _8; + debug metadata => _5; + } + } + } + scope 4 (inlined std::ptr::const_ptr::::len) { + debug self => _1; + scope 5 (inlined std::ptr::metadata::<[u32]>) { + debug ptr => _1; + } + } + } } bb0: { - _0 = as SliceIndex<[u32]>>::get_unchecked(move _2, move _1) -> [return: bb1, unwind continue]; - } - - bb1: { + _3 = move (_2.0: usize); + _4 = move (_2.1: usize); + StorageLive(_5); + _5 = SubUnchecked(_4, _3); + StorageLive(_7); + StorageLive(_6); + _6 = _1 as *const u32 (PtrToPtr); + _7 = Offset(_6, _3); + StorageDead(_6); + StorageLive(_8); + _8 = _7 as *const () (PtrToPtr); + _0 = *const [u32] from (_8, _5); + StorageDead(_8); + StorageDead(_7); + StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir index df8d5c3836f..18728d543ad 100644 --- a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir @@ -3,12 +3,70 @@ fn vec_deref_to_slice(_1: &Vec) -> &[u8] { debug v => _1; let mut _0: &[u8]; - - bb0: { - _0 = as Deref>::deref(move _1) -> [return: bb1, unwind unreachable]; + scope 1 (inlined as Deref>::deref) { + debug self => _1; + let mut _4: *const u8; + let mut _5: usize; + scope 2 (inlined Vec::::as_ptr) { + debug self => _1; + let mut _2: &alloc::raw_vec::RawVec; + scope 3 (inlined alloc::raw_vec::RawVec::::ptr) { + debug self => _2; + let mut _3: std::ptr::NonNull; + scope 4 (inlined Unique::::as_ptr) { + debug ((self: Unique).0: std::ptr::NonNull) => _3; + debug ((self: Unique).1: std::marker::PhantomData) => const PhantomData::; + scope 5 (inlined NonNull::::as_ptr) { + debug self => _3; + } + } + } + } + scope 6 (inlined std::slice::from_raw_parts::<'_, u8>) { + debug data => _4; + debug len => _5; + let _7: *const [u8]; + scope 7 (inlined core::ub_checks::check_language_ub) { + scope 8 (inlined core::ub_checks::check_language_ub::runtime) { + } + } + scope 9 (inlined std::mem::size_of::) { + } + scope 10 (inlined align_of::) { + } + scope 11 (inlined slice_from_raw_parts::) { + debug data => _4; + debug len => _5; + let mut _6: *const (); + scope 12 (inlined std::ptr::const_ptr::::cast::<()>) { + debug self => _4; + } + scope 13 (inlined std::ptr::from_raw_parts::<[u8]>) { + debug data_pointer => _6; + debug metadata => _5; + } + } + } } - bb1: { + bb0: { + StorageLive(_4); + StorageLive(_2); + _2 = &((*_1).0: alloc::raw_vec::RawVec); + StorageLive(_3); + _3 = ((((*_1).0: alloc::raw_vec::RawVec).0: std::ptr::Unique).0: std::ptr::NonNull); + _4 = (_3.0: *const u8); + StorageDead(_3); + StorageDead(_2); + StorageLive(_5); + _5 = ((*_1).1: usize); + StorageLive(_6); + _6 = _4 as *const () (PtrToPtr); + _7 = *const [u8] from (_6, _5); + StorageDead(_6); + StorageDead(_5); + StorageDead(_4); + _0 = &(*_7); return; } } diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir index d26afef4653..18728d543ad 100644 --- a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir @@ -3,12 +3,70 @@ fn vec_deref_to_slice(_1: &Vec) -> &[u8] { debug v => _1; let mut _0: &[u8]; - - bb0: { - _0 = as Deref>::deref(move _1) -> [return: bb1, unwind continue]; + scope 1 (inlined as Deref>::deref) { + debug self => _1; + let mut _4: *const u8; + let mut _5: usize; + scope 2 (inlined Vec::::as_ptr) { + debug self => _1; + let mut _2: &alloc::raw_vec::RawVec; + scope 3 (inlined alloc::raw_vec::RawVec::::ptr) { + debug self => _2; + let mut _3: std::ptr::NonNull; + scope 4 (inlined Unique::::as_ptr) { + debug ((self: Unique).0: std::ptr::NonNull) => _3; + debug ((self: Unique).1: std::marker::PhantomData) => const PhantomData::; + scope 5 (inlined NonNull::::as_ptr) { + debug self => _3; + } + } + } + } + scope 6 (inlined std::slice::from_raw_parts::<'_, u8>) { + debug data => _4; + debug len => _5; + let _7: *const [u8]; + scope 7 (inlined core::ub_checks::check_language_ub) { + scope 8 (inlined core::ub_checks::check_language_ub::runtime) { + } + } + scope 9 (inlined std::mem::size_of::) { + } + scope 10 (inlined align_of::) { + } + scope 11 (inlined slice_from_raw_parts::) { + debug data => _4; + debug len => _5; + let mut _6: *const (); + scope 12 (inlined std::ptr::const_ptr::::cast::<()>) { + debug self => _4; + } + scope 13 (inlined std::ptr::from_raw_parts::<[u8]>) { + debug data_pointer => _6; + debug metadata => _5; + } + } + } } - bb1: { + bb0: { + StorageLive(_4); + StorageLive(_2); + _2 = &((*_1).0: alloc::raw_vec::RawVec); + StorageLive(_3); + _3 = ((((*_1).0: alloc::raw_vec::RawVec).0: std::ptr::Unique).0: std::ptr::NonNull); + _4 = (_3.0: *const u8); + StorageDead(_3); + StorageDead(_2); + StorageLive(_5); + _5 = ((*_1).1: usize); + StorageLive(_6); + _6 = _4 as *const () (PtrToPtr); + _7 = *const [u8] from (_6, _5); + StorageDead(_6); + StorageDead(_5); + StorageDead(_4); + _0 = &(*_7); return; } } -- cgit 1.4.1-3-g733a5 From 9520cebfc50947f04280a6dbf288dfb5475c1637 Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Sun, 14 Apr 2024 11:12:32 -0700 Subject: InstSimplify `from_raw_parts(p, ())` → `p as _` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- compiler/rustc_mir_transform/src/instsimplify.rs | 36 +++++++++++++++++++++- tests/mir-opt/instsimplify/casts.rs | 9 ++++++ ...o_byte_add_fat.PreCodegen.after.panic-abort.mir | 10 +----- ..._byte_add_fat.PreCodegen.after.panic-unwind.mir | 10 +----- ..._byte_add_thin.PreCodegen.after.panic-abort.mir | 12 +------- ...byte_add_thin.PreCodegen.after.panic-unwind.mir | 12 +------- 6 files changed, 48 insertions(+), 41 deletions(-) (limited to 'tests') diff --git a/compiler/rustc_mir_transform/src/instsimplify.rs b/compiler/rustc_mir_transform/src/instsimplify.rs index ff786d44d6a..bae959963b5 100644 --- a/compiler/rustc_mir_transform/src/instsimplify.rs +++ b/compiler/rustc_mir_transform/src/instsimplify.rs @@ -36,6 +36,7 @@ impl<'tcx> MirPass<'tcx> for InstSimplify { ctx.simplify_bool_cmp(&statement.source_info, rvalue); ctx.simplify_ref_deref(&statement.source_info, rvalue); ctx.simplify_len(&statement.source_info, rvalue); + ctx.simplify_ptr_aggregate(&statement.source_info, rvalue); ctx.simplify_cast(rvalue); } _ => {} @@ -58,8 +59,17 @@ struct InstSimplifyContext<'tcx, 'a> { impl<'tcx> InstSimplifyContext<'tcx, '_> { fn should_simplify(&self, source_info: &SourceInfo, rvalue: &Rvalue<'tcx>) -> bool { + self.should_simplify_custom(source_info, "Rvalue", rvalue) + } + + fn should_simplify_custom( + &self, + source_info: &SourceInfo, + label: &str, + value: impl std::fmt::Debug, + ) -> bool { self.tcx.consider_optimizing(|| { - format!("InstSimplify - Rvalue: {rvalue:?} SourceInfo: {source_info:?}") + format!("InstSimplify - {label}: {value:?} SourceInfo: {source_info:?}") }) } @@ -147,6 +157,30 @@ impl<'tcx> InstSimplifyContext<'tcx, '_> { } } + /// Transform "Aggregate(RawPtr, \[p, ()\])" ==> "Cast(PtrToPtr, p)". + fn simplify_ptr_aggregate(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) { + if let Rvalue::Aggregate(box AggregateKind::RawPtr(pointee_ty, mutability), fields) = rvalue + { + let meta_ty = fields.raw[1].ty(self.local_decls, self.tcx); + if meta_ty.is_unit() { + // The mutable borrows we're holding prevent printing `rvalue` here + if !self.should_simplify_custom( + source_info, + "Aggregate::RawPtr", + (&pointee_ty, *mutability, &fields), + ) { + return; + } + + let mut fields = std::mem::take(fields); + let _meta = fields.pop().unwrap(); + let data = fields.pop().unwrap(); + let ptr_ty = Ty::new_ptr(self.tcx, *pointee_ty, *mutability); + *rvalue = Rvalue::Cast(CastKind::PtrToPtr, data, ptr_ty); + } + } + } + fn simplify_ub_check(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) { if let Rvalue::NullaryOp(NullOp::UbChecks, _) = *rvalue { let const_ = Const::from_bool(self.tcx, self.tcx.sess.ub_checks()); diff --git a/tests/mir-opt/instsimplify/casts.rs b/tests/mir-opt/instsimplify/casts.rs index b3bc34af5b7..a7786fa570f 100644 --- a/tests/mir-opt/instsimplify/casts.rs +++ b/tests/mir-opt/instsimplify/casts.rs @@ -1,6 +1,7 @@ //@ test-mir-pass: InstSimplify //@ compile-flags: -Zinline-mir #![crate_type = "lib"] +#![feature(core_intrinsics)] #[inline(always)] fn generic_cast(x: *const T) -> *const U { @@ -23,3 +24,11 @@ pub fn roundtrip(x: *const u8) -> *const u8 { // CHECK: _2 = move _3 as *const u8 (PointerCoercion(MutToConstPointer)); x as *mut u8 as *const u8 } + +// EMIT_MIR casts.roundtrip.InstSimplify.diff +pub fn cast_thin_via_aggregate(x: *const u8) -> *const () { + // CHECK-LABEL: fn cast_thin_via_aggregate( + // CHECK: _2 = _1; + // CHECK: _0 = move _2 as *const () (PtrToPtr); + std::intrinsics::aggregate_raw_ptr(x, ()) +} diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir index 81474306eec..37f50d25fc8 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir @@ -28,8 +28,6 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { scope 6 (inlined std::ptr::from_raw_parts::<[u32]>) { debug data_pointer => _5; debug metadata => _7; - let mut _8: std::ptr::metadata::PtrComponents<[u32]>; - let mut _9: std::ptr::metadata::PtrRepr<[u32]>; } } } @@ -47,13 +45,7 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { _6 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: _1 }; _7 = ((_6.2: std::ptr::metadata::PtrComponents<[u32]>).1: usize); StorageDead(_6); - StorageLive(_9); - StorageLive(_8); - _8 = std::ptr::metadata::PtrComponents::<[u32]> { data_pointer: _5, metadata: _7 }; - _9 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: move _8 }; - StorageDead(_8); - _0 = (_9.0: *const [u32]); - StorageDead(_9); + _0 = *const [u32] from (_5, _7); StorageDead(_7); StorageDead(_5); StorageDead(_4); diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir index 81474306eec..37f50d25fc8 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir @@ -28,8 +28,6 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { scope 6 (inlined std::ptr::from_raw_parts::<[u32]>) { debug data_pointer => _5; debug metadata => _7; - let mut _8: std::ptr::metadata::PtrComponents<[u32]>; - let mut _9: std::ptr::metadata::PtrRepr<[u32]>; } } } @@ -47,13 +45,7 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { _6 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: _1 }; _7 = ((_6.2: std::ptr::metadata::PtrComponents<[u32]>).1: usize); StorageDead(_6); - StorageLive(_9); - StorageLive(_8); - _8 = std::ptr::metadata::PtrComponents::<[u32]> { data_pointer: _5, metadata: _7 }; - _9 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: move _8 }; - StorageDead(_8); - _0 = (_9.0: *const [u32]); - StorageDead(_9); + _0 = *const [u32] from (_5, _7); StorageDead(_7); StorageDead(_5); StorageDead(_4); diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir index d86f2d1106a..9551f30c7e9 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir @@ -26,29 +26,19 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { scope 6 (inlined std::ptr::from_raw_parts::) { debug data_pointer => _5; debug metadata => const (); - let mut _6: std::ptr::metadata::PtrComponents; - let mut _7: std::ptr::metadata::PtrRepr; } } } bb0: { - StorageLive(_4); StorageLive(_3); _3 = _1 as *const u8 (PtrToPtr); _4 = Offset(_3, _2); StorageDead(_3); StorageLive(_5); _5 = _4 as *const () (PtrToPtr); - StorageLive(_7); - StorageLive(_6); - _6 = std::ptr::metadata::PtrComponents:: { data_pointer: _5, metadata: const () }; - _7 = std::ptr::metadata::PtrRepr:: { const_ptr: move _6 }; - StorageDead(_6); - _0 = (_7.0: *const u32); - StorageDead(_7); + _0 = _4 as *const u32 (PtrToPtr); StorageDead(_5); - StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir index d86f2d1106a..9551f30c7e9 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir @@ -26,29 +26,19 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { scope 6 (inlined std::ptr::from_raw_parts::) { debug data_pointer => _5; debug metadata => const (); - let mut _6: std::ptr::metadata::PtrComponents; - let mut _7: std::ptr::metadata::PtrRepr; } } } bb0: { - StorageLive(_4); StorageLive(_3); _3 = _1 as *const u8 (PtrToPtr); _4 = Offset(_3, _2); StorageDead(_3); StorageLive(_5); _5 = _4 as *const () (PtrToPtr); - StorageLive(_7); - StorageLive(_6); - _6 = std::ptr::metadata::PtrComponents:: { data_pointer: _5, metadata: const () }; - _7 = std::ptr::metadata::PtrRepr:: { const_ptr: move _6 }; - StorageDead(_6); - _0 = (_7.0: *const u32); - StorageDead(_7); + _0 = _4 as *const u32 (PtrToPtr); StorageDead(_5); - StorageDead(_4); return; } } -- cgit 1.4.1-3-g733a5 From 5e785b1420d8d26f360a33919700868c877cbbbc Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Sun, 21 Apr 2024 11:24:54 -0700 Subject: Update tests after 123949 --- ...t.demo_byte_add_fat.PreCodegen.after.panic-abort.mir | 10 ---------- ....demo_byte_add_fat.PreCodegen.after.panic-unwind.mir | 10 ---------- ....demo_byte_add_thin.PreCodegen.after.panic-abort.mir | 14 -------------- ...demo_byte_add_thin.PreCodegen.after.panic-unwind.mir | 14 -------------- ...get_unchecked_range.PreCodegen.after.panic-abort.mir | 17 ----------------- ...et_unchecked_range.PreCodegen.after.panic-unwind.mir | 17 ----------------- 6 files changed, 82 deletions(-) (limited to 'tests') diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir index 37f50d25fc8..db0c84bd560 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir @@ -5,29 +5,19 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { debug n => _2; let mut _0: *const [u32]; scope 1 (inlined std::ptr::const_ptr::::byte_add) { - debug self => _1; - debug count => _2; let mut _3: *const u8; let mut _4: *const u8; scope 2 (inlined std::ptr::const_ptr::::cast::) { - debug self => _1; } scope 3 (inlined std::ptr::const_ptr::::add) { - debug self => _3; - debug count => _2; } scope 4 (inlined std::ptr::const_ptr::::with_metadata_of::<[u32]>) { - debug self => _4; - debug meta => _1; let mut _5: *const (); let mut _7: usize; scope 5 (inlined std::ptr::metadata::<[u32]>) { - debug ptr => _1; let mut _6: std::ptr::metadata::PtrRepr<[u32]>; } scope 6 (inlined std::ptr::from_raw_parts::<[u32]>) { - debug data_pointer => _5; - debug metadata => _7; } } } diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir index 37f50d25fc8..db0c84bd560 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir @@ -5,29 +5,19 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { debug n => _2; let mut _0: *const [u32]; scope 1 (inlined std::ptr::const_ptr::::byte_add) { - debug self => _1; - debug count => _2; let mut _3: *const u8; let mut _4: *const u8; scope 2 (inlined std::ptr::const_ptr::::cast::) { - debug self => _1; } scope 3 (inlined std::ptr::const_ptr::::add) { - debug self => _3; - debug count => _2; } scope 4 (inlined std::ptr::const_ptr::::with_metadata_of::<[u32]>) { - debug self => _4; - debug meta => _1; let mut _5: *const (); let mut _7: usize; scope 5 (inlined std::ptr::metadata::<[u32]>) { - debug ptr => _1; let mut _6: std::ptr::metadata::PtrRepr<[u32]>; } scope 6 (inlined std::ptr::from_raw_parts::<[u32]>) { - debug data_pointer => _5; - debug metadata => _7; } } } diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir index 9551f30c7e9..766bd29ef41 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir @@ -5,27 +5,16 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { debug n => _2; let mut _0: *const u32; scope 1 (inlined std::ptr::const_ptr::::byte_add) { - debug self => _1; - debug count => _2; let mut _3: *const u8; let mut _4: *const u8; scope 2 (inlined std::ptr::const_ptr::::cast::) { - debug self => _1; } scope 3 (inlined std::ptr::const_ptr::::add) { - debug self => _3; - debug count => _2; } scope 4 (inlined std::ptr::const_ptr::::with_metadata_of::) { - debug self => _4; - debug meta => _1; - let mut _5: *const (); scope 5 (inlined std::ptr::metadata::) { - debug ptr => _1; } scope 6 (inlined std::ptr::from_raw_parts::) { - debug data_pointer => _5; - debug metadata => const (); } } } @@ -35,10 +24,7 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { _3 = _1 as *const u8 (PtrToPtr); _4 = Offset(_3, _2); StorageDead(_3); - StorageLive(_5); - _5 = _4 as *const () (PtrToPtr); _0 = _4 as *const u32 (PtrToPtr); - StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir index 9551f30c7e9..766bd29ef41 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir @@ -5,27 +5,16 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { debug n => _2; let mut _0: *const u32; scope 1 (inlined std::ptr::const_ptr::::byte_add) { - debug self => _1; - debug count => _2; let mut _3: *const u8; let mut _4: *const u8; scope 2 (inlined std::ptr::const_ptr::::cast::) { - debug self => _1; } scope 3 (inlined std::ptr::const_ptr::::add) { - debug self => _3; - debug count => _2; } scope 4 (inlined std::ptr::const_ptr::::with_metadata_of::) { - debug self => _4; - debug meta => _1; - let mut _5: *const (); scope 5 (inlined std::ptr::metadata::) { - debug ptr => _1; } scope 6 (inlined std::ptr::from_raw_parts::) { - debug data_pointer => _5; - debug metadata => const (); } } } @@ -35,10 +24,7 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { _3 = _1 as *const u8 (PtrToPtr); _4 = Offset(_3, _2); StorageDead(_3); - StorageLive(_5); - _5 = _4 as *const () (PtrToPtr); _0 = _4 as *const u32 (PtrToPtr); - StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir index 8446324c663..018ff6c357d 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir @@ -7,42 +7,25 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - let mut _3: usize; let mut _4: usize; scope 1 (inlined std::ptr::const_ptr::::get_unchecked::>) { - debug self => _1; - debug ((index: std::ops::Range).0: usize) => _3; - debug ((index: std::ops::Range).1: usize) => _4; scope 2 (inlined as SliceIndex<[u32]>>::get_unchecked) { - debug ((self: std::ops::Range).0: usize) => _3; - debug ((self: std::ops::Range).1: usize) => _4; - debug slice => _1; let _5: usize; let mut _6: *const u32; let mut _7: *const u32; scope 3 { - debug new_len => _5; scope 6 (inlined std::ptr::const_ptr::::as_ptr) { - debug self => _1; } scope 7 (inlined std::ptr::const_ptr::::add) { - debug self => _6; - debug count => _3; } scope 8 (inlined slice_from_raw_parts::) { - debug data => _7; - debug len => _5; let mut _8: *const (); scope 9 (inlined std::ptr::const_ptr::::cast::<()>) { - debug self => _7; } scope 10 (inlined std::ptr::from_raw_parts::<[u32]>) { - debug data_pointer => _8; - debug metadata => _5; } } } scope 4 (inlined std::ptr::const_ptr::::len) { - debug self => _1; scope 5 (inlined std::ptr::metadata::<[u32]>) { - debug ptr => _1; } } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir index 8446324c663..018ff6c357d 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir @@ -7,42 +7,25 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - let mut _3: usize; let mut _4: usize; scope 1 (inlined std::ptr::const_ptr::::get_unchecked::>) { - debug self => _1; - debug ((index: std::ops::Range).0: usize) => _3; - debug ((index: std::ops::Range).1: usize) => _4; scope 2 (inlined as SliceIndex<[u32]>>::get_unchecked) { - debug ((self: std::ops::Range).0: usize) => _3; - debug ((self: std::ops::Range).1: usize) => _4; - debug slice => _1; let _5: usize; let mut _6: *const u32; let mut _7: *const u32; scope 3 { - debug new_len => _5; scope 6 (inlined std::ptr::const_ptr::::as_ptr) { - debug self => _1; } scope 7 (inlined std::ptr::const_ptr::::add) { - debug self => _6; - debug count => _3; } scope 8 (inlined slice_from_raw_parts::) { - debug data => _7; - debug len => _5; let mut _8: *const (); scope 9 (inlined std::ptr::const_ptr::::cast::<()>) { - debug self => _7; } scope 10 (inlined std::ptr::from_raw_parts::<[u32]>) { - debug data_pointer => _8; - debug metadata => _5; } } } scope 4 (inlined std::ptr::const_ptr::::len) { - debug self => _1; scope 5 (inlined std::ptr::metadata::<[u32]>) { - debug ptr => _1; } } } -- cgit 1.4.1-3-g733a5 From 3aaa3941fd62fb4aeea559eafe8a6aa6472eb87d Mon Sep 17 00:00:00 2001 From: Caio Date: Sun, 21 Apr 2024 15:43:43 -0300 Subject: Move some tests --- src/tools/tidy/src/issues.txt | 68 +++++++++++----------- src/tools/tidy/src/ui_tests.rs | 2 +- tests/ui/associated-types/issue-19129-1.rs | 16 +++++ tests/ui/associated-types/issue-19129-2.rs | 11 ++++ tests/ui/associated-types/issue-20763-1.rs | 29 +++++++++ tests/ui/associated-types/issue-20763-2.rs | 24 ++++++++ tests/ui/binding/issue-40402-1.rs | 10 ++++ tests/ui/binding/issue-40402-1.stderr | 18 ++++++ tests/ui/binding/issue-40402-2.rs | 6 ++ tests/ui/binding/issue-40402-2.stderr | 18 ++++++ tests/ui/closures/issue-22864-1.rs | 7 +++ tests/ui/closures/issue-22864-2.rs | 7 +++ tests/ui/closures/issue-5239-1.rs | 6 ++ tests/ui/closures/issue-5239-1.stderr | 11 ++++ tests/ui/closures/issue-5239-2.rs | 9 +++ tests/ui/coercion/issue-32122-1.fixed | 17 ++++++ tests/ui/coercion/issue-32122-1.rs | 17 ++++++ tests/ui/coercion/issue-32122-1.stderr | 18 ++++++ tests/ui/coercion/issue-32122-2.fixed | 28 +++++++++ tests/ui/coercion/issue-32122-2.rs | 28 +++++++++ tests/ui/coercion/issue-32122-2.stderr | 18 ++++++ tests/ui/consts/issue-19244-1.rs | 6 ++ tests/ui/consts/issue-19244-1.stderr | 9 +++ tests/ui/consts/issue-19244-2.rs | 7 +++ tests/ui/consts/issue-19244-2.stderr | 11 ++++ tests/ui/deref-patterns/issue-71676-1.fixed | 53 +++++++++++++++++ tests/ui/deref-patterns/issue-71676-1.rs | 53 +++++++++++++++++ tests/ui/deref-patterns/issue-71676-1.stderr | 63 ++++++++++++++++++++ tests/ui/deref-patterns/issue-71676-2.rs | 42 +++++++++++++ tests/ui/deref-patterns/issue-71676-2.stderr | 18 ++++++ tests/ui/enum/auxiliary/issue-19340-1.rs | 3 + tests/ui/enum/issue-19340-1.rs | 17 ++++++ tests/ui/enum/issue-19340-2.rs | 24 ++++++++ tests/ui/enum/issue-23304-1.rs | 25 ++++++++ tests/ui/enum/issue-23304-2.rs | 13 +++++ tests/ui/expr/issue-22933-1.rs | 23 ++++++++ tests/ui/expr/issue-22933-2.rs | 8 +++ tests/ui/expr/issue-22933-2.stderr | 15 +++++ tests/ui/issues/auxiliary/issue-19340-1.rs | 3 - tests/ui/issues/issue-11692-1.rs | 3 - tests/ui/issues/issue-11692-1.stderr | 8 --- tests/ui/issues/issue-11692-2.rs | 3 - tests/ui/issues/issue-11692-2.stderr | 10 ---- tests/ui/issues/issue-12187-1.rs | 8 --- tests/ui/issues/issue-12187-1.stderr | 14 ----- tests/ui/issues/issue-12187-2.rs | 8 --- tests/ui/issues/issue-12187-2.stderr | 14 ----- tests/ui/issues/issue-19129-1.rs | 16 ----- tests/ui/issues/issue-19129-2.rs | 11 ---- tests/ui/issues/issue-19244-1.rs | 6 -- tests/ui/issues/issue-19244-1.stderr | 9 --- tests/ui/issues/issue-19244-2.rs | 7 --- tests/ui/issues/issue-19244-2.stderr | 11 ---- tests/ui/issues/issue-19340-1.rs | 17 ------ tests/ui/issues/issue-19340-2.rs | 24 -------- tests/ui/issues/issue-20763-1.rs | 29 --------- tests/ui/issues/issue-20763-2.rs | 24 -------- tests/ui/issues/issue-22864-1.rs | 7 --- tests/ui/issues/issue-22864-2.rs | 7 --- tests/ui/issues/issue-22933-1.rs | 23 -------- tests/ui/issues/issue-22933-2.rs | 8 --- tests/ui/issues/issue-22933-2.stderr | 15 ----- tests/ui/issues/issue-23122-1.rs | 14 ----- tests/ui/issues/issue-23122-1.stderr | 9 --- tests/ui/issues/issue-23122-2.rs | 15 ----- tests/ui/issues/issue-23122-2.stderr | 18 ------ tests/ui/issues/issue-23304-1.rs | 25 -------- tests/ui/issues/issue-23304-2.rs | 13 ----- .../issue-32122-1.fixed | 17 ------ .../issue-32122-1.rs | 17 ------ .../issue-32122-1.stderr | 18 ------ .../issue-32122-2.fixed | 28 --------- .../issue-32122-2.rs | 28 --------- .../issue-32122-2.stderr | 18 ------ tests/ui/issues/issue-3214.rs | 11 ---- tests/ui/issues/issue-3214.stderr | 28 --------- .../issues/issue-40402-ref-hints/issue-40402-1.rs | 10 ---- .../issue-40402-ref-hints/issue-40402-1.stderr | 18 ------ .../issues/issue-40402-ref-hints/issue-40402-2.rs | 6 -- .../issue-40402-ref-hints/issue-40402-2.stderr | 18 ------ tests/ui/issues/issue-5239-1.rs | 6 -- tests/ui/issues/issue-5239-1.stderr | 11 ---- tests/ui/issues/issue-5239-2.rs | 9 --- tests/ui/issues/issue-57362-1.rs | 23 -------- tests/ui/issues/issue-57362-1.stderr | 16 ----- tests/ui/issues/issue-57362-2.rs | 25 -------- tests/ui/issues/issue-57362-2.stderr | 18 ------ .../issue-71676-suggest-deref/issue-71676-1.fixed | 53 ----------------- .../issue-71676-suggest-deref/issue-71676-1.rs | 53 ----------------- .../issue-71676-suggest-deref/issue-71676-1.stderr | 63 -------------------- .../issue-71676-suggest-deref/issue-71676-2.rs | 42 ------------- .../issue-71676-suggest-deref/issue-71676-2.stderr | 18 ------ tests/ui/issues/issue-7607-1.rs | 9 --- tests/ui/issues/issue-7607-1.stderr | 12 ---- tests/ui/issues/issue-7607-2.rs | 16 ----- tests/ui/macros/issue-11692-1.rs | 3 + tests/ui/macros/issue-11692-1.stderr | 8 +++ tests/ui/macros/issue-11692-2.rs | 3 + tests/ui/macros/issue-11692-2.stderr | 10 ++++ tests/ui/nll/issue-57362-1.rs | 23 ++++++++ tests/ui/nll/issue-57362-1.stderr | 16 +++++ tests/ui/nll/issue-57362-2.rs | 25 ++++++++ tests/ui/nll/issue-57362-2.stderr | 18 ++++++ tests/ui/parser/issue-12187-1.rs | 8 +++ tests/ui/parser/issue-12187-1.stderr | 14 +++++ tests/ui/parser/issue-12187-2.rs | 8 +++ tests/ui/parser/issue-12187-2.stderr | 14 +++++ tests/ui/recursion/issue-23122-1.rs | 14 +++++ tests/ui/recursion/issue-23122-1.stderr | 9 +++ tests/ui/recursion/issue-23122-2.rs | 15 +++++ tests/ui/recursion/issue-23122-2.stderr | 18 ++++++ tests/ui/resolve/issue-3214.rs | 11 ++++ tests/ui/resolve/issue-3214.stderr | 28 +++++++++ tests/ui/type/issue-7607-1.rs | 9 +++ tests/ui/type/issue-7607-1.stderr | 12 ++++ tests/ui/type/issue-7607-2.rs | 16 +++++ 116 files changed, 1005 insertions(+), 1005 deletions(-) create mode 100644 tests/ui/associated-types/issue-19129-1.rs create mode 100644 tests/ui/associated-types/issue-19129-2.rs create mode 100644 tests/ui/associated-types/issue-20763-1.rs create mode 100644 tests/ui/associated-types/issue-20763-2.rs create mode 100644 tests/ui/binding/issue-40402-1.rs create mode 100644 tests/ui/binding/issue-40402-1.stderr create mode 100644 tests/ui/binding/issue-40402-2.rs create mode 100644 tests/ui/binding/issue-40402-2.stderr create mode 100644 tests/ui/closures/issue-22864-1.rs create mode 100644 tests/ui/closures/issue-22864-2.rs create mode 100644 tests/ui/closures/issue-5239-1.rs create mode 100644 tests/ui/closures/issue-5239-1.stderr create mode 100644 tests/ui/closures/issue-5239-2.rs create mode 100644 tests/ui/coercion/issue-32122-1.fixed create mode 100644 tests/ui/coercion/issue-32122-1.rs create mode 100644 tests/ui/coercion/issue-32122-1.stderr create mode 100644 tests/ui/coercion/issue-32122-2.fixed create mode 100644 tests/ui/coercion/issue-32122-2.rs create mode 100644 tests/ui/coercion/issue-32122-2.stderr create mode 100644 tests/ui/consts/issue-19244-1.rs create mode 100644 tests/ui/consts/issue-19244-1.stderr create mode 100644 tests/ui/consts/issue-19244-2.rs create mode 100644 tests/ui/consts/issue-19244-2.stderr create mode 100644 tests/ui/deref-patterns/issue-71676-1.fixed create mode 100644 tests/ui/deref-patterns/issue-71676-1.rs create mode 100644 tests/ui/deref-patterns/issue-71676-1.stderr create mode 100644 tests/ui/deref-patterns/issue-71676-2.rs create mode 100644 tests/ui/deref-patterns/issue-71676-2.stderr create mode 100644 tests/ui/enum/auxiliary/issue-19340-1.rs create mode 100644 tests/ui/enum/issue-19340-1.rs create mode 100644 tests/ui/enum/issue-19340-2.rs create mode 100644 tests/ui/enum/issue-23304-1.rs create mode 100644 tests/ui/enum/issue-23304-2.rs create mode 100644 tests/ui/expr/issue-22933-1.rs create mode 100644 tests/ui/expr/issue-22933-2.rs create mode 100644 tests/ui/expr/issue-22933-2.stderr delete mode 100644 tests/ui/issues/auxiliary/issue-19340-1.rs delete mode 100644 tests/ui/issues/issue-11692-1.rs delete mode 100644 tests/ui/issues/issue-11692-1.stderr delete mode 100644 tests/ui/issues/issue-11692-2.rs delete mode 100644 tests/ui/issues/issue-11692-2.stderr delete mode 100644 tests/ui/issues/issue-12187-1.rs delete mode 100644 tests/ui/issues/issue-12187-1.stderr delete mode 100644 tests/ui/issues/issue-12187-2.rs delete mode 100644 tests/ui/issues/issue-12187-2.stderr delete mode 100644 tests/ui/issues/issue-19129-1.rs delete mode 100644 tests/ui/issues/issue-19129-2.rs delete mode 100644 tests/ui/issues/issue-19244-1.rs delete mode 100644 tests/ui/issues/issue-19244-1.stderr delete mode 100644 tests/ui/issues/issue-19244-2.rs delete mode 100644 tests/ui/issues/issue-19244-2.stderr delete mode 100644 tests/ui/issues/issue-19340-1.rs delete mode 100644 tests/ui/issues/issue-19340-2.rs delete mode 100644 tests/ui/issues/issue-20763-1.rs delete mode 100644 tests/ui/issues/issue-20763-2.rs delete mode 100644 tests/ui/issues/issue-22864-1.rs delete mode 100644 tests/ui/issues/issue-22864-2.rs delete mode 100644 tests/ui/issues/issue-22933-1.rs delete mode 100644 tests/ui/issues/issue-22933-2.rs delete mode 100644 tests/ui/issues/issue-22933-2.stderr delete mode 100644 tests/ui/issues/issue-23122-1.rs delete mode 100644 tests/ui/issues/issue-23122-1.stderr delete mode 100644 tests/ui/issues/issue-23122-2.rs delete mode 100644 tests/ui/issues/issue-23122-2.stderr delete mode 100644 tests/ui/issues/issue-23304-1.rs delete mode 100644 tests/ui/issues/issue-23304-2.rs delete mode 100644 tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.fixed delete mode 100644 tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.rs delete mode 100644 tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.stderr delete mode 100644 tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.fixed delete mode 100644 tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.rs delete mode 100644 tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.stderr delete mode 100644 tests/ui/issues/issue-3214.rs delete mode 100644 tests/ui/issues/issue-3214.stderr delete mode 100644 tests/ui/issues/issue-40402-ref-hints/issue-40402-1.rs delete mode 100644 tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr delete mode 100644 tests/ui/issues/issue-40402-ref-hints/issue-40402-2.rs delete mode 100644 tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr delete mode 100644 tests/ui/issues/issue-5239-1.rs delete mode 100644 tests/ui/issues/issue-5239-1.stderr delete mode 100644 tests/ui/issues/issue-5239-2.rs delete mode 100644 tests/ui/issues/issue-57362-1.rs delete mode 100644 tests/ui/issues/issue-57362-1.stderr delete mode 100644 tests/ui/issues/issue-57362-2.rs delete mode 100644 tests/ui/issues/issue-57362-2.stderr delete mode 100644 tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.fixed delete mode 100644 tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.rs delete mode 100644 tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.stderr delete mode 100644 tests/ui/issues/issue-71676-suggest-deref/issue-71676-2.rs delete mode 100644 tests/ui/issues/issue-71676-suggest-deref/issue-71676-2.stderr delete mode 100644 tests/ui/issues/issue-7607-1.rs delete mode 100644 tests/ui/issues/issue-7607-1.stderr delete mode 100644 tests/ui/issues/issue-7607-2.rs create mode 100644 tests/ui/macros/issue-11692-1.rs create mode 100644 tests/ui/macros/issue-11692-1.stderr create mode 100644 tests/ui/macros/issue-11692-2.rs create mode 100644 tests/ui/macros/issue-11692-2.stderr create mode 100644 tests/ui/nll/issue-57362-1.rs create mode 100644 tests/ui/nll/issue-57362-1.stderr create mode 100644 tests/ui/nll/issue-57362-2.rs create mode 100644 tests/ui/nll/issue-57362-2.stderr create mode 100644 tests/ui/parser/issue-12187-1.rs create mode 100644 tests/ui/parser/issue-12187-1.stderr create mode 100644 tests/ui/parser/issue-12187-2.rs create mode 100644 tests/ui/parser/issue-12187-2.stderr create mode 100644 tests/ui/recursion/issue-23122-1.rs create mode 100644 tests/ui/recursion/issue-23122-1.stderr create mode 100644 tests/ui/recursion/issue-23122-2.rs create mode 100644 tests/ui/recursion/issue-23122-2.stderr create mode 100644 tests/ui/resolve/issue-3214.rs create mode 100644 tests/ui/resolve/issue-3214.stderr create mode 100644 tests/ui/type/issue-7607-1.rs create mode 100644 tests/ui/type/issue-7607-1.stderr create mode 100644 tests/ui/type/issue-7607-2.rs (limited to 'tests') diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt index 211dc347b0f..dff15265fae 100644 --- a/src/tools/tidy/src/issues.txt +++ b/src/tools/tidy/src/issues.txt @@ -74,8 +74,12 @@ ui/associated-type-bounds/issue-99828.rs ui/associated-type-bounds/return-type-notation/issue-120208-higher-ranked-const.rs ui/associated-types/issue-18655.rs ui/associated-types/issue-19081.rs +ui/associated-types/issue-19129-1.rs +ui/associated-types/issue-19129-2.rs ui/associated-types/issue-19883.rs ui/associated-types/issue-20005.rs +ui/associated-types/issue-20763-1.rs +ui/associated-types/issue-20763-2.rs ui/associated-types/issue-20825-2.rs ui/associated-types/issue-20825.rs ui/associated-types/issue-21363.rs @@ -281,6 +285,8 @@ ui/auxiliary/issue-18502.rs ui/auxiliary/issue-24106.rs ui/auxiliary/issue-76387.rs ui/bench/issue-32062.rs +ui/binding/issue-40402-1.rs +ui/binding/issue-40402-2.rs ui/binding/issue-53114-borrow-checks.rs ui/binding/issue-53114-safety-checks.rs ui/binop/issue-25916.rs @@ -431,12 +437,16 @@ ui/closures/issue-111932.rs ui/closures/issue-113087.rs ui/closures/issue-11873.rs ui/closures/issue-1460.rs +ui/closures/issue-22864-1.rs +ui/closures/issue-22864-2.rs ui/closures/issue-23012-supertrait-signature-inference.rs ui/closures/issue-25439.rs ui/closures/issue-41366.rs ui/closures/issue-42463.rs ui/closures/issue-46742.rs ui/closures/issue-48109.rs +ui/closures/issue-5239-1.rs +ui/closures/issue-5239-2.rs ui/closures/issue-52437.rs ui/closures/issue-67123.rs ui/closures/issue-6801.rs @@ -482,6 +492,8 @@ ui/coercion/issue-101066.rs ui/coercion/issue-14589.rs ui/coercion/issue-26905-rpass.rs ui/coercion/issue-26905.rs +ui/coercion/issue-32122-1.rs +ui/coercion/issue-32122-2.rs ui/coercion/issue-36007.rs ui/coercion/issue-37655.rs ui/coercion/issue-3794.rs @@ -721,6 +733,8 @@ ui/consts/issue-17718-references.rs ui/consts/issue-17718.rs ui/consts/issue-17756.rs ui/consts/issue-18294.rs +ui/consts/issue-19244-1.rs +ui/consts/issue-19244-2.rs ui/consts/issue-19244.rs ui/consts/issue-21562.rs ui/consts/issue-21721.rs @@ -845,6 +859,8 @@ ui/cycle-trait/issue-12511.rs ui/debuginfo/issue-105386-debuginfo-ub.rs ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.rs ui/deprecation/issue-84637-deprecated-associated-function.rs +ui/deref-patterns/issue-71676-1.rs +ui/deref-patterns/issue-71676-2.rs ui/derived-errors/issue-30580.rs ui/derived-errors/issue-31997-1.rs ui/derived-errors/issue-31997.rs @@ -952,7 +968,12 @@ ui/enum-discriminant/issue-70453-polymorphic-ctfe.rs ui/enum-discriminant/issue-70509-partial_eq.rs ui/enum-discriminant/issue-72554.rs ui/enum-discriminant/issue-90038.rs +ui/enum/auxiliary/issue-19340-1.rs ui/enum/issue-1821.rs +ui/enum/issue-19340-1.rs +ui/enum/issue-19340-2.rs +ui/enum/issue-23304-1.rs +ui/enum/issue-23304-2.rs ui/enum/issue-42747.rs ui/enum/issue-67945-1.rs ui/enum/issue-67945-2.rs @@ -965,6 +986,8 @@ ui/errors/issue-104621-extern-not-file.rs ui/errors/issue-89280-emitter-overflow-splice-lines.rs ui/errors/issue-99572-impl-trait-on-pointer.rs ui/expr/if/issue-4201.rs +ui/expr/issue-22933-1.rs +ui/expr/issue-22933-2.rs ui/extern/auxiliary/issue-80074-macro-2.rs ui/extern/auxiliary/issue-80074-macro.rs ui/extern/issue-10025.rs @@ -1400,7 +1423,6 @@ ui/issues/auxiliary/issue-18711.rs ui/issues/auxiliary/issue-18913-1.rs ui/issues/auxiliary/issue-18913-2.rs ui/issues/auxiliary/issue-19293.rs -ui/issues/auxiliary/issue-19340-1.rs ui/issues/auxiliary/issue-20389.rs ui/issues/auxiliary/issue-21202.rs ui/issues/auxiliary/issue-2170-lib.rs @@ -1492,8 +1514,6 @@ ui/issues/issue-11592.rs ui/issues/issue-11677.rs ui/issues/issue-11680.rs ui/issues/issue-11681.rs -ui/issues/issue-11692-1.rs -ui/issues/issue-11692-2.rs ui/issues/issue-11709.rs ui/issues/issue-11740.rs ui/issues/issue-11771.rs @@ -1504,8 +1524,6 @@ ui/issues/issue-11958.rs ui/issues/issue-12033.rs ui/issues/issue-12041.rs ui/issues/issue-12127.rs -ui/issues/issue-12187-1.rs -ui/issues/issue-12187-2.rs ui/issues/issue-12285.rs ui/issues/issue-12567.rs ui/issues/issue-12612.rs @@ -1713,14 +1731,8 @@ ui/issues/issue-19097.rs ui/issues/issue-19098.rs ui/issues/issue-19100.rs ui/issues/issue-19127.rs -ui/issues/issue-19129-1.rs -ui/issues/issue-19129-2.rs ui/issues/issue-19135.rs -ui/issues/issue-19244-1.rs -ui/issues/issue-19244-2.rs ui/issues/issue-19293.rs -ui/issues/issue-19340-1.rs -ui/issues/issue-19340-2.rs ui/issues/issue-19367.rs ui/issues/issue-19380.rs ui/issues/issue-19398.rs @@ -1761,8 +1773,6 @@ ui/issues/issue-20644.rs ui/issues/issue-20676.rs ui/issues/issue-20714.rs ui/issues/issue-2074.rs -ui/issues/issue-20763-1.rs -ui/issues/issue-20763-2.rs ui/issues/issue-20772.rs ui/issues/issue-20797.rs ui/issues/issue-20803.rs @@ -1835,15 +1845,11 @@ ui/issues/issue-22789.rs ui/issues/issue-2281-part1.rs ui/issues/issue-22814.rs ui/issues/issue-2284.rs -ui/issues/issue-22864-1.rs -ui/issues/issue-22864-2.rs ui/issues/issue-22872.rs ui/issues/issue-22874.rs ui/issues/issue-2288.rs ui/issues/issue-22886.rs ui/issues/issue-22894.rs -ui/issues/issue-22933-1.rs -ui/issues/issue-22933-2.rs ui/issues/issue-22992-2.rs ui/issues/issue-22992.rs ui/issues/issue-23024.rs @@ -1854,8 +1860,6 @@ ui/issues/issue-23073.rs ui/issues/issue-2311-2.rs ui/issues/issue-2311.rs ui/issues/issue-2312.rs -ui/issues/issue-23122-1.rs -ui/issues/issue-23122-2.rs ui/issues/issue-2316-c.rs ui/issues/issue-23173.rs ui/issues/issue-23189.rs @@ -1863,8 +1867,6 @@ ui/issues/issue-23217.rs ui/issues/issue-23253.rs ui/issues/issue-23261.rs ui/issues/issue-23281.rs -ui/issues/issue-23304-1.rs -ui/issues/issue-23304-2.rs ui/issues/issue-23311.rs ui/issues/issue-23336.rs ui/issues/issue-23354-2.rs @@ -2092,9 +2094,6 @@ ui/issues/issue-31910.rs ui/issues/issue-32004.rs ui/issues/issue-32008.rs ui/issues/issue-32086.rs -ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.rs -ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.rs -ui/issues/issue-3214.rs ui/issues/issue-3220.rs ui/issues/issue-32292.rs ui/issues/issue-32324.rs @@ -2243,8 +2242,6 @@ ui/issues/issue-4025.rs ui/issues/issue-40288-2.rs ui/issues/issue-40288.rs ui/issues/issue-40350.rs -ui/issues/issue-40402-ref-hints/issue-40402-1.rs -ui/issues/issue-40402-ref-hints/issue-40402-2.rs ui/issues/issue-40408.rs ui/issues/issue-40610.rs ui/issues/issue-40749.rs @@ -2438,8 +2435,6 @@ ui/issues/issue-51947.rs ui/issues/issue-52049.rs ui/issues/issue-52126-assign-op-invariance.rs ui/issues/issue-52262.rs -ui/issues/issue-5239-1.rs -ui/issues/issue-5239-2.rs ui/issues/issue-52489.rs ui/issues/issue-52533.rs ui/issues/issue-52717.rs @@ -2491,8 +2486,6 @@ ui/issues/issue-57162.rs ui/issues/issue-5718.rs ui/issues/issue-57198-pass.rs ui/issues/issue-57271.rs -ui/issues/issue-57362-1.rs -ui/issues/issue-57362-2.rs ui/issues/issue-57399-self-return-impl-trait.rs ui/issues/issue-5741.rs ui/issues/issue-5754.rs @@ -2578,8 +2571,6 @@ ui/issues/issue-70724-add_type_neq_err_label-unwrap.rs ui/issues/issue-70746.rs ui/issues/issue-7092.rs ui/issues/issue-71406.rs -ui/issues/issue-71676-suggest-deref/issue-71676-1.rs -ui/issues/issue-71676-suggest-deref/issue-71676-2.rs ui/issues/issue-7178.rs ui/issues/issue-72002.rs ui/issues/issue-72076.rs @@ -2600,8 +2591,6 @@ ui/issues/issue-7563.rs ui/issues/issue-75704.rs ui/issues/issue-7575.rs ui/issues/issue-76042.rs -ui/issues/issue-7607-1.rs -ui/issues/issue-7607-2.rs ui/issues/issue-76077-inaccesible-private-fields/issue-76077-1.rs ui/issues/issue-76077-inaccesible-private-fields/issue-76077.rs ui/issues/issue-76191.rs @@ -2851,6 +2840,8 @@ ui/macros/issue-109237.rs ui/macros/issue-111749.rs ui/macros/issue-112342-1.rs ui/macros/issue-112342-2.rs +ui/macros/issue-11692-1.rs +ui/macros/issue-11692-2.rs ui/macros/issue-118048.rs ui/macros/issue-118786.rs ui/macros/issue-16098.rs @@ -3162,6 +3153,8 @@ ui/nll/issue-57265-return-type-wf-check.rs ui/nll/issue-57280-1-flipped.rs ui/nll/issue-57280-1.rs ui/nll/issue-57280.rs +ui/nll/issue-57362-1.rs +ui/nll/issue-57362-2.rs ui/nll/issue-57642-higher-ranked-subtype.rs ui/nll/issue-57843.rs ui/nll/issue-57960.rs @@ -3218,6 +3211,8 @@ ui/packed/issue-27060.rs ui/packed/issue-46152.rs ui/panics/issue-47429-short-backtraces.rs ui/parser/issue-116781.rs +ui/parser/issue-12187-1.rs +ui/parser/issue-12187-2.rs ui/parser/issues/auxiliary/issue-21146-inc.rs ui/parser/issues/auxiliary/issue-89971-outer-attr-following-inner-attr-ice.rs ui/parser/issues/auxiliary/issue-94340-inc.rs @@ -3613,6 +3608,8 @@ ui/reachable/issue-11225-1.rs ui/reachable/issue-11225-2.rs ui/reachable/issue-11225-3.rs ui/reachable/issue-948.rs +ui/recursion/issue-23122-1.rs +ui/recursion/issue-23122-2.rs ui/recursion/issue-23302-1.rs ui/recursion/issue-23302-2.rs ui/recursion/issue-23302-3.rs @@ -3692,6 +3689,7 @@ ui/resolve/issue-30535.rs ui/resolve/issue-3099-a.rs ui/resolve/issue-3099-b.rs ui/resolve/issue-31845.rs +ui/resolve/issue-3214.rs ui/resolve/issue-33876.rs ui/resolve/issue-35675.rs ui/resolve/issue-3907-2.rs @@ -4203,6 +4201,8 @@ ui/type/issue-102598.rs ui/type/issue-103271.rs ui/type/issue-58355.rs ui/type/issue-67690-type-alias-bound-diagnostic-crash.rs +ui/type/issue-7607-1.rs +ui/type/issue-7607-2.rs ui/type/issue-91268.rs ui/type/issue-94187-verbose-type-name.rs ui/type/type-check/issue-116967-cannot-coerce-returned-result.rs diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs index 7136bc4d8f2..f9985a75703 100644 --- a/src/tools/tidy/src/ui_tests.rs +++ b/src/tools/tidy/src/ui_tests.rs @@ -17,7 +17,7 @@ use std::path::{Path, PathBuf}; const ENTRY_LIMIT: usize = 900; // FIXME: The following limits should be reduced eventually. -const ISSUES_ENTRY_LIMIT: usize = 1720; +const ISSUES_ENTRY_LIMIT: usize = 1676; const ROOT_ENTRY_LIMIT: usize = 859; const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[ diff --git a/tests/ui/associated-types/issue-19129-1.rs b/tests/ui/associated-types/issue-19129-1.rs new file mode 100644 index 00000000000..65340b413e9 --- /dev/null +++ b/tests/ui/associated-types/issue-19129-1.rs @@ -0,0 +1,16 @@ +//@ check-pass +//@ pretty-expanded FIXME #23616 + +trait Trait { + type Output; + + fn method() -> >::Output; +} + +impl Trait for () { + type Output = (); + + fn method() {} +} + +fn main() {} diff --git a/tests/ui/associated-types/issue-19129-2.rs b/tests/ui/associated-types/issue-19129-2.rs new file mode 100644 index 00000000000..6562c54b0b7 --- /dev/null +++ b/tests/ui/associated-types/issue-19129-2.rs @@ -0,0 +1,11 @@ +//@ check-pass +#![allow(unused_variables)] +//@ pretty-expanded FIXME #23616 + +trait Trait { + type Output; + + fn method(&self, i: Input) -> bool { false } +} + +fn main() {} diff --git a/tests/ui/associated-types/issue-20763-1.rs b/tests/ui/associated-types/issue-20763-1.rs new file mode 100644 index 00000000000..ea2e696767d --- /dev/null +++ b/tests/ui/associated-types/issue-20763-1.rs @@ -0,0 +1,29 @@ +//@ check-pass +#![allow(dead_code)] +//@ pretty-expanded FIXME #23616 + +trait T0 { + type O; + fn dummy(&self) { } +} + +struct S(A); +impl T0 for S { type O = A; } + +trait T1: T0 { + // this looks okay but as we see below, `f` is unusable + fn m0::O) -> bool>(self, f: F) -> bool; +} + +// complains about the bounds on F here not being required by the trait +impl T1 for S { + fn m0 bool>(self, f: F) -> bool { f(self.0) } +} + +// // complains about mismatched types: as T0>::O vs. A +// impl T1 for S +// { +// fn m0::O) -> bool>(self, f: F) -> bool { f(self.0) } +// } + +fn main() { } diff --git a/tests/ui/associated-types/issue-20763-2.rs b/tests/ui/associated-types/issue-20763-2.rs new file mode 100644 index 00000000000..149bfcb8c99 --- /dev/null +++ b/tests/ui/associated-types/issue-20763-2.rs @@ -0,0 +1,24 @@ +//@ check-pass +#![allow(dead_code)] +//@ pretty-expanded FIXME #23616 + +trait T0 { + type O; + fn dummy(&self) { } +} + +struct S(A); +impl T0 for S { type O = A; } + +trait T1: T0 { + // this looks okay but as we see below, `f` is unusable + fn m0::O) -> bool>(self, f: F) -> bool; +} + +// complains about mismatched types: as T0>::O vs. A +impl T1 for S +{ + fn m0::O) -> bool>(self, f: F) -> bool { f(self.0) } +} + +fn main() { } diff --git a/tests/ui/binding/issue-40402-1.rs b/tests/ui/binding/issue-40402-1.rs new file mode 100644 index 00000000000..254956ae306 --- /dev/null +++ b/tests/ui/binding/issue-40402-1.rs @@ -0,0 +1,10 @@ +// Check that we do not suggest `ref f` here in the `main()` function. +struct Foo { + pub v: Vec, +} + +fn main() { + let mut f = Foo { v: Vec::new() }; + f.v.push("hello".to_string()); + let e = f.v[0]; //~ ERROR cannot move out of index +} diff --git a/tests/ui/binding/issue-40402-1.stderr b/tests/ui/binding/issue-40402-1.stderr new file mode 100644 index 00000000000..d27b6e6324f --- /dev/null +++ b/tests/ui/binding/issue-40402-1.stderr @@ -0,0 +1,18 @@ +error[E0507]: cannot move out of index of `Vec` + --> $DIR/issue-40402-1.rs:9:13 + | +LL | let e = f.v[0]; + | ^^^^^^ move occurs because value has type `String`, which does not implement the `Copy` trait + | +help: consider borrowing here + | +LL | let e = &f.v[0]; + | + +help: consider cloning the value if the performance cost is acceptable + | +LL | let e = f.v[0].clone(); + | ++++++++ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0507`. diff --git a/tests/ui/binding/issue-40402-2.rs b/tests/ui/binding/issue-40402-2.rs new file mode 100644 index 00000000000..1fb6e31e964 --- /dev/null +++ b/tests/ui/binding/issue-40402-2.rs @@ -0,0 +1,6 @@ +// Check that we do suggest `(ref a, ref b)` here, since `a` and `b` +// are nested within a pattern +fn main() { + let x = vec![(String::new(), String::new())]; + let (a, b) = x[0]; //~ ERROR cannot move out of index +} diff --git a/tests/ui/binding/issue-40402-2.stderr b/tests/ui/binding/issue-40402-2.stderr new file mode 100644 index 00000000000..987558903ee --- /dev/null +++ b/tests/ui/binding/issue-40402-2.stderr @@ -0,0 +1,18 @@ +error[E0507]: cannot move out of index of `Vec<(String, String)>` + --> $DIR/issue-40402-2.rs:5:18 + | +LL | let (a, b) = x[0]; + | - - ^^^^ + | | | + | | ...and here + | data moved here + | + = note: move occurs because these variables have types that don't implement the `Copy` trait +help: consider borrowing here + | +LL | let (a, b) = &x[0]; + | + + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0507`. diff --git a/tests/ui/closures/issue-22864-1.rs b/tests/ui/closures/issue-22864-1.rs new file mode 100644 index 00000000000..3d88a2a50b4 --- /dev/null +++ b/tests/ui/closures/issue-22864-1.rs @@ -0,0 +1,7 @@ +//@ run-pass +pub fn main() { + struct Fun(F); + let f = Fun(|x| 3*x); + let Fun(g) = f; + println!("{:?}",g(4)); +} diff --git a/tests/ui/closures/issue-22864-2.rs b/tests/ui/closures/issue-22864-2.rs new file mode 100644 index 00000000000..d98dbeda46b --- /dev/null +++ b/tests/ui/closures/issue-22864-2.rs @@ -0,0 +1,7 @@ +//@ run-pass +//@ needs-threads + +pub fn main() { + let f = || || 0; + std::thread::spawn(f()); +} diff --git a/tests/ui/closures/issue-5239-1.rs b/tests/ui/closures/issue-5239-1.rs new file mode 100644 index 00000000000..708ae34c6c6 --- /dev/null +++ b/tests/ui/closures/issue-5239-1.rs @@ -0,0 +1,6 @@ +// Regression test for issue #5239 + +fn main() { + let x = |ref x: isize| { x += 1; }; + //~^ ERROR E0368 +} diff --git a/tests/ui/closures/issue-5239-1.stderr b/tests/ui/closures/issue-5239-1.stderr new file mode 100644 index 00000000000..63c2dbfc55c --- /dev/null +++ b/tests/ui/closures/issue-5239-1.stderr @@ -0,0 +1,11 @@ +error[E0368]: binary assignment operation `+=` cannot be applied to type `&isize` + --> $DIR/issue-5239-1.rs:4:30 + | +LL | let x = |ref x: isize| { x += 1; }; + | -^^^^^ + | | + | cannot use `+=` on type `&isize` + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0368`. diff --git a/tests/ui/closures/issue-5239-2.rs b/tests/ui/closures/issue-5239-2.rs new file mode 100644 index 00000000000..8239b06404a --- /dev/null +++ b/tests/ui/closures/issue-5239-2.rs @@ -0,0 +1,9 @@ +//@ run-pass +// Regression test for issue #5239 + + +pub fn main() { + let _f = |ref x: isize| { *x }; + let foo = 10; + assert_eq!(_f(foo), 10); +} diff --git a/tests/ui/coercion/issue-32122-1.fixed b/tests/ui/coercion/issue-32122-1.fixed new file mode 100644 index 00000000000..abcef9fcbd9 --- /dev/null +++ b/tests/ui/coercion/issue-32122-1.fixed @@ -0,0 +1,17 @@ +//@ run-rustfix +use std::ops::Deref; + +struct Foo(u8); + +impl Deref for Foo { + type Target = u8; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +fn main() { + let a = Foo(0); + // Should suggest `&*` when coercing &ty to *const ty + let _: *const u8 = &*a; //~ ERROR mismatched types +} diff --git a/tests/ui/coercion/issue-32122-1.rs b/tests/ui/coercion/issue-32122-1.rs new file mode 100644 index 00000000000..920ec348419 --- /dev/null +++ b/tests/ui/coercion/issue-32122-1.rs @@ -0,0 +1,17 @@ +//@ run-rustfix +use std::ops::Deref; + +struct Foo(u8); + +impl Deref for Foo { + type Target = u8; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +fn main() { + let a = Foo(0); + // Should suggest `&*` when coercing &ty to *const ty + let _: *const u8 = &a; //~ ERROR mismatched types +} diff --git a/tests/ui/coercion/issue-32122-1.stderr b/tests/ui/coercion/issue-32122-1.stderr new file mode 100644 index 00000000000..ae5dffe1fad --- /dev/null +++ b/tests/ui/coercion/issue-32122-1.stderr @@ -0,0 +1,18 @@ +error[E0308]: mismatched types + --> $DIR/issue-32122-1.rs:16:24 + | +LL | let _: *const u8 = &a; + | --------- ^^ expected `*const u8`, found `&Foo` + | | + | expected due to this + | + = note: expected raw pointer `*const u8` + found reference `&Foo` +help: consider dereferencing + | +LL | let _: *const u8 = &*a; + | + + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/coercion/issue-32122-2.fixed b/tests/ui/coercion/issue-32122-2.fixed new file mode 100644 index 00000000000..db406a4c3ac --- /dev/null +++ b/tests/ui/coercion/issue-32122-2.fixed @@ -0,0 +1,28 @@ +//@ run-rustfix +use std::ops::Deref; +struct Bar(u8); +struct Foo(Bar); +struct Emm(Foo); +impl Deref for Bar{ + type Target = u8; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Foo { + type Target = Bar; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Emm { + type Target = Foo; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +fn main() { + let a = Emm(Foo(Bar(0))); + // Should suggest `&***` even when deref is pretty deep + let _: *const u8 = &***a; //~ ERROR mismatched types +} diff --git a/tests/ui/coercion/issue-32122-2.rs b/tests/ui/coercion/issue-32122-2.rs new file mode 100644 index 00000000000..74242931b4e --- /dev/null +++ b/tests/ui/coercion/issue-32122-2.rs @@ -0,0 +1,28 @@ +//@ run-rustfix +use std::ops::Deref; +struct Bar(u8); +struct Foo(Bar); +struct Emm(Foo); +impl Deref for Bar{ + type Target = u8; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Foo { + type Target = Bar; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Emm { + type Target = Foo; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +fn main() { + let a = Emm(Foo(Bar(0))); + // Should suggest `&***` even when deref is pretty deep + let _: *const u8 = &a; //~ ERROR mismatched types +} diff --git a/tests/ui/coercion/issue-32122-2.stderr b/tests/ui/coercion/issue-32122-2.stderr new file mode 100644 index 00000000000..eb4327bef62 --- /dev/null +++ b/tests/ui/coercion/issue-32122-2.stderr @@ -0,0 +1,18 @@ +error[E0308]: mismatched types + --> $DIR/issue-32122-2.rs:27:24 + | +LL | let _: *const u8 = &a; + | --------- ^^ expected `*const u8`, found `&Emm` + | | + | expected due to this + | + = note: expected raw pointer `*const u8` + found reference `&Emm` +help: consider dereferencing + | +LL | let _: *const u8 = &***a; + | +++ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/consts/issue-19244-1.rs b/tests/ui/consts/issue-19244-1.rs new file mode 100644 index 00000000000..77fab7cfa32 --- /dev/null +++ b/tests/ui/consts/issue-19244-1.rs @@ -0,0 +1,6 @@ +const TUP: (usize,) = (42,); + +fn main() { + let a: [isize; TUP.1]; + //~^ ERROR no field `1` on type `(usize,)` +} diff --git a/tests/ui/consts/issue-19244-1.stderr b/tests/ui/consts/issue-19244-1.stderr new file mode 100644 index 00000000000..9c1336402e6 --- /dev/null +++ b/tests/ui/consts/issue-19244-1.stderr @@ -0,0 +1,9 @@ +error[E0609]: no field `1` on type `(usize,)` + --> $DIR/issue-19244-1.rs:4:24 + | +LL | let a: [isize; TUP.1]; + | ^ unknown field + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0609`. diff --git a/tests/ui/consts/issue-19244-2.rs b/tests/ui/consts/issue-19244-2.rs new file mode 100644 index 00000000000..c9a68b05c5b --- /dev/null +++ b/tests/ui/consts/issue-19244-2.rs @@ -0,0 +1,7 @@ +struct MyStruct { field: usize } +const STRUCT: MyStruct = MyStruct { field: 42 }; + +fn main() { + let a: [isize; STRUCT.nonexistent_field]; + //~^ no field `nonexistent_field` on type `MyStruct` +} diff --git a/tests/ui/consts/issue-19244-2.stderr b/tests/ui/consts/issue-19244-2.stderr new file mode 100644 index 00000000000..533861b1114 --- /dev/null +++ b/tests/ui/consts/issue-19244-2.stderr @@ -0,0 +1,11 @@ +error[E0609]: no field `nonexistent_field` on type `MyStruct` + --> $DIR/issue-19244-2.rs:5:27 + | +LL | let a: [isize; STRUCT.nonexistent_field]; + | ^^^^^^^^^^^^^^^^^ unknown field + | + = note: available field is: `field` + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0609`. diff --git a/tests/ui/deref-patterns/issue-71676-1.fixed b/tests/ui/deref-patterns/issue-71676-1.fixed new file mode 100644 index 00000000000..8b473de4ac2 --- /dev/null +++ b/tests/ui/deref-patterns/issue-71676-1.fixed @@ -0,0 +1,53 @@ +//@ run-rustfix +use std::ops::Deref; +use std::ops::DerefMut; +struct Bar(u8); +struct Foo(Bar); +struct Emm(Foo); +impl Deref for Bar{ + type Target = u8; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Foo { + type Target = Bar; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Emm { + type Target = Foo; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl DerefMut for Bar{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +impl DerefMut for Foo { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +impl DerefMut for Emm { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +fn main() { + // Suggest dereference with arbitrary mutability + let a = Emm(Foo(Bar(0))); + let _: *const u8 = &***a; //~ ERROR mismatched types + + let mut a = Emm(Foo(Bar(0))); + let _: *mut u8 = &mut ***a; //~ ERROR mismatched types + + let a = Emm(Foo(Bar(0))); + let _: *const u8 = &***a; //~ ERROR mismatched types + + let mut a = Emm(Foo(Bar(0))); + let _: *mut u8 = &mut ***a; //~ ERROR mismatched types +} diff --git a/tests/ui/deref-patterns/issue-71676-1.rs b/tests/ui/deref-patterns/issue-71676-1.rs new file mode 100644 index 00000000000..38d23fb8428 --- /dev/null +++ b/tests/ui/deref-patterns/issue-71676-1.rs @@ -0,0 +1,53 @@ +//@ run-rustfix +use std::ops::Deref; +use std::ops::DerefMut; +struct Bar(u8); +struct Foo(Bar); +struct Emm(Foo); +impl Deref for Bar{ + type Target = u8; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Foo { + type Target = Bar; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Emm { + type Target = Foo; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl DerefMut for Bar{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +impl DerefMut for Foo { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +impl DerefMut for Emm { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +fn main() { + // Suggest dereference with arbitrary mutability + let a = Emm(Foo(Bar(0))); + let _: *const u8 = &a; //~ ERROR mismatched types + + let mut a = Emm(Foo(Bar(0))); + let _: *mut u8 = &a; //~ ERROR mismatched types + + let a = Emm(Foo(Bar(0))); + let _: *const u8 = &mut a; //~ ERROR mismatched types + + let mut a = Emm(Foo(Bar(0))); + let _: *mut u8 = &mut a; //~ ERROR mismatched types +} diff --git a/tests/ui/deref-patterns/issue-71676-1.stderr b/tests/ui/deref-patterns/issue-71676-1.stderr new file mode 100644 index 00000000000..164641ff775 --- /dev/null +++ b/tests/ui/deref-patterns/issue-71676-1.stderr @@ -0,0 +1,63 @@ +error[E0308]: mismatched types + --> $DIR/issue-71676-1.rs:43:24 + | +LL | let _: *const u8 = &a; + | --------- ^^ expected `*const u8`, found `&Emm` + | | + | expected due to this + | + = note: expected raw pointer `*const u8` + found reference `&Emm` +help: consider dereferencing + | +LL | let _: *const u8 = &***a; + | +++ + +error[E0308]: mismatched types + --> $DIR/issue-71676-1.rs:46:22 + | +LL | let _: *mut u8 = &a; + | ------- ^^ types differ in mutability + | | + | expected due to this + | + = note: expected raw pointer `*mut u8` + found reference `&Emm` +help: consider dereferencing + | +LL | let _: *mut u8 = &mut ***a; + | +++++++ + +error[E0308]: mismatched types + --> $DIR/issue-71676-1.rs:49:24 + | +LL | let _: *const u8 = &mut a; + | --------- ^^^^^^ expected `*const u8`, found `&mut Emm` + | | + | expected due to this + | + = note: expected raw pointer `*const u8` + found mutable reference `&mut Emm` +help: consider dereferencing + | +LL | let _: *const u8 = &***a; + | ~~~ + +error[E0308]: mismatched types + --> $DIR/issue-71676-1.rs:52:22 + | +LL | let _: *mut u8 = &mut a; + | ------- ^^^^^^ expected `*mut u8`, found `&mut Emm` + | | + | expected due to this + | + = note: expected raw pointer `*mut u8` + found mutable reference `&mut Emm` +help: consider dereferencing + | +LL | let _: *mut u8 = &mut ***a; + | +++ + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/deref-patterns/issue-71676-2.rs b/tests/ui/deref-patterns/issue-71676-2.rs new file mode 100644 index 00000000000..f3183899dc5 --- /dev/null +++ b/tests/ui/deref-patterns/issue-71676-2.rs @@ -0,0 +1,42 @@ +use std::ops::Deref; +use std::ops::DerefMut; +struct Bar(u8); +struct Foo(Bar); +struct Emm(Foo); +impl Deref for Bar{ + type Target = u8; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Foo { + type Target = Bar; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl Deref for Emm { + type Target = Foo; + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl DerefMut for Bar{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +impl DerefMut for Foo { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +impl DerefMut for Emm { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +fn main() { + let a = Emm(Foo(Bar(0))); + let _: *mut u8 = &a; //~ ERROR mismatched types +} diff --git a/tests/ui/deref-patterns/issue-71676-2.stderr b/tests/ui/deref-patterns/issue-71676-2.stderr new file mode 100644 index 00000000000..6ed318c8768 --- /dev/null +++ b/tests/ui/deref-patterns/issue-71676-2.stderr @@ -0,0 +1,18 @@ +error[E0308]: mismatched types + --> $DIR/issue-71676-2.rs:41:22 + | +LL | let _: *mut u8 = &a; + | ------- ^^ types differ in mutability + | | + | expected due to this + | + = note: expected raw pointer `*mut u8` + found reference `&Emm` +help: consider dereferencing + | +LL | let _: *mut u8 = &mut ***a; + | +++++++ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/enum/auxiliary/issue-19340-1.rs b/tests/ui/enum/auxiliary/issue-19340-1.rs new file mode 100644 index 00000000000..39ee36b8b91 --- /dev/null +++ b/tests/ui/enum/auxiliary/issue-19340-1.rs @@ -0,0 +1,3 @@ +pub enum Homura { + Madoka { name: String }, +} diff --git a/tests/ui/enum/issue-19340-1.rs b/tests/ui/enum/issue-19340-1.rs new file mode 100644 index 00000000000..c1ba0d23b6f --- /dev/null +++ b/tests/ui/enum/issue-19340-1.rs @@ -0,0 +1,17 @@ +//@ run-pass +#![allow(unused_variables)] +//@ aux-build:issue-19340-1.rs + +//@ pretty-expanded FIXME #23616 + +extern crate issue_19340_1 as lib; + +use lib::Homura; + +fn main() { + let homura = Homura::Madoka { name: "Kaname".to_string() }; + + match homura { + Homura::Madoka { name } => (), + }; +} diff --git a/tests/ui/enum/issue-19340-2.rs b/tests/ui/enum/issue-19340-2.rs new file mode 100644 index 00000000000..dd1bda78a97 --- /dev/null +++ b/tests/ui/enum/issue-19340-2.rs @@ -0,0 +1,24 @@ +//@ run-pass +#![allow(unused_variables)] +//@ pretty-expanded FIXME #23616 + +enum Homura { + Madoka { + name: String, + age: u32, + }, +} + +fn main() { + let homura = Homura::Madoka { + name: "Akemi".to_string(), + age: 14, + }; + + match homura { + Homura::Madoka { + name, + age, + } => (), + }; +} diff --git a/tests/ui/enum/issue-23304-1.rs b/tests/ui/enum/issue-23304-1.rs new file mode 100644 index 00000000000..6b80646704a --- /dev/null +++ b/tests/ui/enum/issue-23304-1.rs @@ -0,0 +1,25 @@ +//@ run-pass +#![allow(dead_code)] + +#[repr(u8)] +#[allow(dead_code)] +enum ValueType { + DOUBLE = 0x00, + INT32 = 0x01, +} + +#[repr(u32)] +enum ValueTag { + INT32 = 0x1FFF0u32 | (ValueType::INT32 as u32), + X, +} + +#[repr(u64)] +enum ValueShiftedTag { + INT32 = ValueTag::INT32 as u64, + X, +} + +fn main() { + println!("{}", ValueTag::INT32 as u32); +} diff --git a/tests/ui/enum/issue-23304-2.rs b/tests/ui/enum/issue-23304-2.rs new file mode 100644 index 00000000000..17eb79e93d2 --- /dev/null +++ b/tests/ui/enum/issue-23304-2.rs @@ -0,0 +1,13 @@ +//@ run-pass +#![allow(dead_code)] + +enum X { A = 42 as isize } + +enum Y { A = X::A as isize } + +fn main() { + let x = X::A; + let x = x as isize; + assert_eq!(x, 42); + assert_eq!(Y::A as isize, 42); +} diff --git a/tests/ui/expr/issue-22933-1.rs b/tests/ui/expr/issue-22933-1.rs new file mode 100644 index 00000000000..8f1f5a5048a --- /dev/null +++ b/tests/ui/expr/issue-22933-1.rs @@ -0,0 +1,23 @@ +//@ check-pass + +struct CNFParser { + token: char, +} + +impl CNFParser { + fn is_whitespace(c: char) -> bool { + c == ' ' || c == '\n' + } + + fn consume_whitespace(&mut self) { + self.consume_while(&(CNFParser::is_whitespace)) + } + + fn consume_while(&mut self, p: &dyn Fn(char) -> bool) { + while p(self.token) { + return + } + } +} + +fn main() {} diff --git a/tests/ui/expr/issue-22933-2.rs b/tests/ui/expr/issue-22933-2.rs new file mode 100644 index 00000000000..dfd84b9a79d --- /dev/null +++ b/tests/ui/expr/issue-22933-2.rs @@ -0,0 +1,8 @@ +enum Delicious { + Pie = 0x1, + Apple = 0x2, + ApplePie = Delicious::Apple as isize | Delicious::PIE as isize, + //~^ ERROR no variant or associated item named `PIE` found +} + +fn main() {} diff --git a/tests/ui/expr/issue-22933-2.stderr b/tests/ui/expr/issue-22933-2.stderr new file mode 100644 index 00000000000..8cda8598f3c --- /dev/null +++ b/tests/ui/expr/issue-22933-2.stderr @@ -0,0 +1,15 @@ +error[E0599]: no variant or associated item named `PIE` found for enum `Delicious` in the current scope + --> $DIR/issue-22933-2.rs:4:55 + | +LL | enum Delicious { + | -------------- variant or associated item `PIE` not found for this enum +... +LL | ApplePie = Delicious::Apple as isize | Delicious::PIE as isize, + | ^^^ + | | + | variant or associated item not found in `Delicious` + | help: there is a variant with a similar name: `Pie` + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0599`. diff --git a/tests/ui/issues/auxiliary/issue-19340-1.rs b/tests/ui/issues/auxiliary/issue-19340-1.rs deleted file mode 100644 index 39ee36b8b91..00000000000 --- a/tests/ui/issues/auxiliary/issue-19340-1.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub enum Homura { - Madoka { name: String }, -} diff --git a/tests/ui/issues/issue-11692-1.rs b/tests/ui/issues/issue-11692-1.rs deleted file mode 100644 index b6f3bb8ef05..00000000000 --- a/tests/ui/issues/issue-11692-1.rs +++ /dev/null @@ -1,3 +0,0 @@ -fn main() { - print!(testo!()); //~ ERROR cannot find macro `testo` in this scope -} diff --git a/tests/ui/issues/issue-11692-1.stderr b/tests/ui/issues/issue-11692-1.stderr deleted file mode 100644 index 46382f65218..00000000000 --- a/tests/ui/issues/issue-11692-1.stderr +++ /dev/null @@ -1,8 +0,0 @@ -error: cannot find macro `testo` in this scope - --> $DIR/issue-11692-1.rs:2:12 - | -LL | print!(testo!()); - | ^^^^^ - -error: aborting due to 1 previous error - diff --git a/tests/ui/issues/issue-11692-2.rs b/tests/ui/issues/issue-11692-2.rs deleted file mode 100644 index 5957ed338f4..00000000000 --- a/tests/ui/issues/issue-11692-2.rs +++ /dev/null @@ -1,3 +0,0 @@ -fn main() { - concat!(test!()); //~ ERROR cannot find macro `test` in this scope -} diff --git a/tests/ui/issues/issue-11692-2.stderr b/tests/ui/issues/issue-11692-2.stderr deleted file mode 100644 index 53add509ca5..00000000000 --- a/tests/ui/issues/issue-11692-2.stderr +++ /dev/null @@ -1,10 +0,0 @@ -error: cannot find macro `test` in this scope - --> $DIR/issue-11692-2.rs:2:13 - | -LL | concat!(test!()); - | ^^^^ - | - = note: `test` is in scope, but it is an attribute: `#[test]` - -error: aborting due to 1 previous error - diff --git a/tests/ui/issues/issue-12187-1.rs b/tests/ui/issues/issue-12187-1.rs deleted file mode 100644 index 86128ed94bd..00000000000 --- a/tests/ui/issues/issue-12187-1.rs +++ /dev/null @@ -1,8 +0,0 @@ -fn new() -> &'static T { - panic!() -} - -fn main() { - let &v = new(); - //~^ ERROR type annotations needed -} diff --git a/tests/ui/issues/issue-12187-1.stderr b/tests/ui/issues/issue-12187-1.stderr deleted file mode 100644 index 704854fe585..00000000000 --- a/tests/ui/issues/issue-12187-1.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error[E0282]: type annotations needed for `&_` - --> $DIR/issue-12187-1.rs:6:9 - | -LL | let &v = new(); - | ^^ ----- type must be known at this point - | -help: consider giving this pattern a type, where the type for type parameter `T` is specified - | -LL | let &v: &T = new(); - | ++++ - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0282`. diff --git a/tests/ui/issues/issue-12187-2.rs b/tests/ui/issues/issue-12187-2.rs deleted file mode 100644 index 080a6206be7..00000000000 --- a/tests/ui/issues/issue-12187-2.rs +++ /dev/null @@ -1,8 +0,0 @@ -fn new<'r, T>() -> &'r T { - panic!() -} - -fn main() { - let &v = new(); - //~^ ERROR type annotations needed -} diff --git a/tests/ui/issues/issue-12187-2.stderr b/tests/ui/issues/issue-12187-2.stderr deleted file mode 100644 index eeef63a1d0b..00000000000 --- a/tests/ui/issues/issue-12187-2.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error[E0282]: type annotations needed for `&_` - --> $DIR/issue-12187-2.rs:6:9 - | -LL | let &v = new(); - | ^^ ----- type must be known at this point - | -help: consider giving this pattern a type, where the type for type parameter `T` is specified - | -LL | let &v: &T = new(); - | ++++ - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0282`. diff --git a/tests/ui/issues/issue-19129-1.rs b/tests/ui/issues/issue-19129-1.rs deleted file mode 100644 index 65340b413e9..00000000000 --- a/tests/ui/issues/issue-19129-1.rs +++ /dev/null @@ -1,16 +0,0 @@ -//@ check-pass -//@ pretty-expanded FIXME #23616 - -trait Trait { - type Output; - - fn method() -> >::Output; -} - -impl Trait for () { - type Output = (); - - fn method() {} -} - -fn main() {} diff --git a/tests/ui/issues/issue-19129-2.rs b/tests/ui/issues/issue-19129-2.rs deleted file mode 100644 index 6562c54b0b7..00000000000 --- a/tests/ui/issues/issue-19129-2.rs +++ /dev/null @@ -1,11 +0,0 @@ -//@ check-pass -#![allow(unused_variables)] -//@ pretty-expanded FIXME #23616 - -trait Trait { - type Output; - - fn method(&self, i: Input) -> bool { false } -} - -fn main() {} diff --git a/tests/ui/issues/issue-19244-1.rs b/tests/ui/issues/issue-19244-1.rs deleted file mode 100644 index 77fab7cfa32..00000000000 --- a/tests/ui/issues/issue-19244-1.rs +++ /dev/null @@ -1,6 +0,0 @@ -const TUP: (usize,) = (42,); - -fn main() { - let a: [isize; TUP.1]; - //~^ ERROR no field `1` on type `(usize,)` -} diff --git a/tests/ui/issues/issue-19244-1.stderr b/tests/ui/issues/issue-19244-1.stderr deleted file mode 100644 index 9c1336402e6..00000000000 --- a/tests/ui/issues/issue-19244-1.stderr +++ /dev/null @@ -1,9 +0,0 @@ -error[E0609]: no field `1` on type `(usize,)` - --> $DIR/issue-19244-1.rs:4:24 - | -LL | let a: [isize; TUP.1]; - | ^ unknown field - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0609`. diff --git a/tests/ui/issues/issue-19244-2.rs b/tests/ui/issues/issue-19244-2.rs deleted file mode 100644 index c9a68b05c5b..00000000000 --- a/tests/ui/issues/issue-19244-2.rs +++ /dev/null @@ -1,7 +0,0 @@ -struct MyStruct { field: usize } -const STRUCT: MyStruct = MyStruct { field: 42 }; - -fn main() { - let a: [isize; STRUCT.nonexistent_field]; - //~^ no field `nonexistent_field` on type `MyStruct` -} diff --git a/tests/ui/issues/issue-19244-2.stderr b/tests/ui/issues/issue-19244-2.stderr deleted file mode 100644 index 533861b1114..00000000000 --- a/tests/ui/issues/issue-19244-2.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error[E0609]: no field `nonexistent_field` on type `MyStruct` - --> $DIR/issue-19244-2.rs:5:27 - | -LL | let a: [isize; STRUCT.nonexistent_field]; - | ^^^^^^^^^^^^^^^^^ unknown field - | - = note: available field is: `field` - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0609`. diff --git a/tests/ui/issues/issue-19340-1.rs b/tests/ui/issues/issue-19340-1.rs deleted file mode 100644 index c1ba0d23b6f..00000000000 --- a/tests/ui/issues/issue-19340-1.rs +++ /dev/null @@ -1,17 +0,0 @@ -//@ run-pass -#![allow(unused_variables)] -//@ aux-build:issue-19340-1.rs - -//@ pretty-expanded FIXME #23616 - -extern crate issue_19340_1 as lib; - -use lib::Homura; - -fn main() { - let homura = Homura::Madoka { name: "Kaname".to_string() }; - - match homura { - Homura::Madoka { name } => (), - }; -} diff --git a/tests/ui/issues/issue-19340-2.rs b/tests/ui/issues/issue-19340-2.rs deleted file mode 100644 index dd1bda78a97..00000000000 --- a/tests/ui/issues/issue-19340-2.rs +++ /dev/null @@ -1,24 +0,0 @@ -//@ run-pass -#![allow(unused_variables)] -//@ pretty-expanded FIXME #23616 - -enum Homura { - Madoka { - name: String, - age: u32, - }, -} - -fn main() { - let homura = Homura::Madoka { - name: "Akemi".to_string(), - age: 14, - }; - - match homura { - Homura::Madoka { - name, - age, - } => (), - }; -} diff --git a/tests/ui/issues/issue-20763-1.rs b/tests/ui/issues/issue-20763-1.rs deleted file mode 100644 index ea2e696767d..00000000000 --- a/tests/ui/issues/issue-20763-1.rs +++ /dev/null @@ -1,29 +0,0 @@ -//@ check-pass -#![allow(dead_code)] -//@ pretty-expanded FIXME #23616 - -trait T0 { - type O; - fn dummy(&self) { } -} - -struct S(A); -impl T0 for S { type O = A; } - -trait T1: T0 { - // this looks okay but as we see below, `f` is unusable - fn m0::O) -> bool>(self, f: F) -> bool; -} - -// complains about the bounds on F here not being required by the trait -impl T1 for S { - fn m0 bool>(self, f: F) -> bool { f(self.0) } -} - -// // complains about mismatched types: as T0>::O vs. A -// impl T1 for S -// { -// fn m0::O) -> bool>(self, f: F) -> bool { f(self.0) } -// } - -fn main() { } diff --git a/tests/ui/issues/issue-20763-2.rs b/tests/ui/issues/issue-20763-2.rs deleted file mode 100644 index 149bfcb8c99..00000000000 --- a/tests/ui/issues/issue-20763-2.rs +++ /dev/null @@ -1,24 +0,0 @@ -//@ check-pass -#![allow(dead_code)] -//@ pretty-expanded FIXME #23616 - -trait T0 { - type O; - fn dummy(&self) { } -} - -struct S(A); -impl T0 for S { type O = A; } - -trait T1: T0 { - // this looks okay but as we see below, `f` is unusable - fn m0::O) -> bool>(self, f: F) -> bool; -} - -// complains about mismatched types: as T0>::O vs. A -impl T1 for S -{ - fn m0::O) -> bool>(self, f: F) -> bool { f(self.0) } -} - -fn main() { } diff --git a/tests/ui/issues/issue-22864-1.rs b/tests/ui/issues/issue-22864-1.rs deleted file mode 100644 index 3d88a2a50b4..00000000000 --- a/tests/ui/issues/issue-22864-1.rs +++ /dev/null @@ -1,7 +0,0 @@ -//@ run-pass -pub fn main() { - struct Fun(F); - let f = Fun(|x| 3*x); - let Fun(g) = f; - println!("{:?}",g(4)); -} diff --git a/tests/ui/issues/issue-22864-2.rs b/tests/ui/issues/issue-22864-2.rs deleted file mode 100644 index d98dbeda46b..00000000000 --- a/tests/ui/issues/issue-22864-2.rs +++ /dev/null @@ -1,7 +0,0 @@ -//@ run-pass -//@ needs-threads - -pub fn main() { - let f = || || 0; - std::thread::spawn(f()); -} diff --git a/tests/ui/issues/issue-22933-1.rs b/tests/ui/issues/issue-22933-1.rs deleted file mode 100644 index 8f1f5a5048a..00000000000 --- a/tests/ui/issues/issue-22933-1.rs +++ /dev/null @@ -1,23 +0,0 @@ -//@ check-pass - -struct CNFParser { - token: char, -} - -impl CNFParser { - fn is_whitespace(c: char) -> bool { - c == ' ' || c == '\n' - } - - fn consume_whitespace(&mut self) { - self.consume_while(&(CNFParser::is_whitespace)) - } - - fn consume_while(&mut self, p: &dyn Fn(char) -> bool) { - while p(self.token) { - return - } - } -} - -fn main() {} diff --git a/tests/ui/issues/issue-22933-2.rs b/tests/ui/issues/issue-22933-2.rs deleted file mode 100644 index dfd84b9a79d..00000000000 --- a/tests/ui/issues/issue-22933-2.rs +++ /dev/null @@ -1,8 +0,0 @@ -enum Delicious { - Pie = 0x1, - Apple = 0x2, - ApplePie = Delicious::Apple as isize | Delicious::PIE as isize, - //~^ ERROR no variant or associated item named `PIE` found -} - -fn main() {} diff --git a/tests/ui/issues/issue-22933-2.stderr b/tests/ui/issues/issue-22933-2.stderr deleted file mode 100644 index 8cda8598f3c..00000000000 --- a/tests/ui/issues/issue-22933-2.stderr +++ /dev/null @@ -1,15 +0,0 @@ -error[E0599]: no variant or associated item named `PIE` found for enum `Delicious` in the current scope - --> $DIR/issue-22933-2.rs:4:55 - | -LL | enum Delicious { - | -------------- variant or associated item `PIE` not found for this enum -... -LL | ApplePie = Delicious::Apple as isize | Delicious::PIE as isize, - | ^^^ - | | - | variant or associated item not found in `Delicious` - | help: there is a variant with a similar name: `Pie` - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0599`. diff --git a/tests/ui/issues/issue-23122-1.rs b/tests/ui/issues/issue-23122-1.rs deleted file mode 100644 index 7fe0900ed5f..00000000000 --- a/tests/ui/issues/issue-23122-1.rs +++ /dev/null @@ -1,14 +0,0 @@ -trait Next { - type Next: Next; -} - -struct GetNext { - t: T, -} - -impl Next for GetNext { - type Next = as Next>::Next; - //~^ ERROR overflow evaluating the requirement -} - -fn main() {} diff --git a/tests/ui/issues/issue-23122-1.stderr b/tests/ui/issues/issue-23122-1.stderr deleted file mode 100644 index c432a502c13..00000000000 --- a/tests/ui/issues/issue-23122-1.stderr +++ /dev/null @@ -1,9 +0,0 @@ -error[E0275]: overflow evaluating the requirement ` as Next>::Next == _` - --> $DIR/issue-23122-1.rs:10:17 - | -LL | type Next = as Next>::Next; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0275`. diff --git a/tests/ui/issues/issue-23122-2.rs b/tests/ui/issues/issue-23122-2.rs deleted file mode 100644 index 2880b956417..00000000000 --- a/tests/ui/issues/issue-23122-2.rs +++ /dev/null @@ -1,15 +0,0 @@ -//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash" -trait Next { - type Next: Next; -} - -struct GetNext { - t: T, -} - -impl Next for GetNext { - type Next = as Next>::Next; - //~^ ERROR overflow evaluating the requirement -} - -fn main() {} diff --git a/tests/ui/issues/issue-23122-2.stderr b/tests/ui/issues/issue-23122-2.stderr deleted file mode 100644 index 10463ab2c33..00000000000 --- a/tests/ui/issues/issue-23122-2.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error[E0275]: overflow evaluating the requirement `<<<<<<<... as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next: Sized` - --> $DIR/issue-23122-2.rs:11:17 - | -LL | type Next = as Next>::Next; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_23122_2`) -note: required for `GetNext<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next>` to implement `Next` - --> $DIR/issue-23122-2.rs:10:15 - | -LL | impl Next for GetNext { - | - ^^^^ ^^^^^^^^^^ - | | - | unsatisfied trait bound introduced here - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0275`. diff --git a/tests/ui/issues/issue-23304-1.rs b/tests/ui/issues/issue-23304-1.rs deleted file mode 100644 index 6b80646704a..00000000000 --- a/tests/ui/issues/issue-23304-1.rs +++ /dev/null @@ -1,25 +0,0 @@ -//@ run-pass -#![allow(dead_code)] - -#[repr(u8)] -#[allow(dead_code)] -enum ValueType { - DOUBLE = 0x00, - INT32 = 0x01, -} - -#[repr(u32)] -enum ValueTag { - INT32 = 0x1FFF0u32 | (ValueType::INT32 as u32), - X, -} - -#[repr(u64)] -enum ValueShiftedTag { - INT32 = ValueTag::INT32 as u64, - X, -} - -fn main() { - println!("{}", ValueTag::INT32 as u32); -} diff --git a/tests/ui/issues/issue-23304-2.rs b/tests/ui/issues/issue-23304-2.rs deleted file mode 100644 index 17eb79e93d2..00000000000 --- a/tests/ui/issues/issue-23304-2.rs +++ /dev/null @@ -1,13 +0,0 @@ -//@ run-pass -#![allow(dead_code)] - -enum X { A = 42 as isize } - -enum Y { A = X::A as isize } - -fn main() { - let x = X::A; - let x = x as isize; - assert_eq!(x, 42); - assert_eq!(Y::A as isize, 42); -} diff --git a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.fixed b/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.fixed deleted file mode 100644 index abcef9fcbd9..00000000000 --- a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.fixed +++ /dev/null @@ -1,17 +0,0 @@ -//@ run-rustfix -use std::ops::Deref; - -struct Foo(u8); - -impl Deref for Foo { - type Target = u8; - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -fn main() { - let a = Foo(0); - // Should suggest `&*` when coercing &ty to *const ty - let _: *const u8 = &*a; //~ ERROR mismatched types -} diff --git a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.rs b/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.rs deleted file mode 100644 index 920ec348419..00000000000 --- a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.rs +++ /dev/null @@ -1,17 +0,0 @@ -//@ run-rustfix -use std::ops::Deref; - -struct Foo(u8); - -impl Deref for Foo { - type Target = u8; - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -fn main() { - let a = Foo(0); - // Should suggest `&*` when coercing &ty to *const ty - let _: *const u8 = &a; //~ ERROR mismatched types -} diff --git a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.stderr b/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.stderr deleted file mode 100644 index ae5dffe1fad..00000000000 --- a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-1.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error[E0308]: mismatched types - --> $DIR/issue-32122-1.rs:16:24 - | -LL | let _: *const u8 = &a; - | --------- ^^ expected `*const u8`, found `&Foo` - | | - | expected due to this - | - = note: expected raw pointer `*const u8` - found reference `&Foo` -help: consider dereferencing - | -LL | let _: *const u8 = &*a; - | + - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.fixed b/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.fixed deleted file mode 100644 index db406a4c3ac..00000000000 --- a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.fixed +++ /dev/null @@ -1,28 +0,0 @@ -//@ run-rustfix -use std::ops::Deref; -struct Bar(u8); -struct Foo(Bar); -struct Emm(Foo); -impl Deref for Bar{ - type Target = u8; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Foo { - type Target = Bar; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Emm { - type Target = Foo; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -fn main() { - let a = Emm(Foo(Bar(0))); - // Should suggest `&***` even when deref is pretty deep - let _: *const u8 = &***a; //~ ERROR mismatched types -} diff --git a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.rs b/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.rs deleted file mode 100644 index 74242931b4e..00000000000 --- a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.rs +++ /dev/null @@ -1,28 +0,0 @@ -//@ run-rustfix -use std::ops::Deref; -struct Bar(u8); -struct Foo(Bar); -struct Emm(Foo); -impl Deref for Bar{ - type Target = u8; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Foo { - type Target = Bar; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Emm { - type Target = Foo; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -fn main() { - let a = Emm(Foo(Bar(0))); - // Should suggest `&***` even when deref is pretty deep - let _: *const u8 = &a; //~ ERROR mismatched types -} diff --git a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.stderr b/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.stderr deleted file mode 100644 index eb4327bef62..00000000000 --- a/tests/ui/issues/issue-32122-deref-coercions-composition/issue-32122-2.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error[E0308]: mismatched types - --> $DIR/issue-32122-2.rs:27:24 - | -LL | let _: *const u8 = &a; - | --------- ^^ expected `*const u8`, found `&Emm` - | | - | expected due to this - | - = note: expected raw pointer `*const u8` - found reference `&Emm` -help: consider dereferencing - | -LL | let _: *const u8 = &***a; - | +++ - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/issues/issue-3214.rs b/tests/ui/issues/issue-3214.rs deleted file mode 100644 index b2c27f5be95..00000000000 --- a/tests/ui/issues/issue-3214.rs +++ /dev/null @@ -1,11 +0,0 @@ -fn foo() { - struct Foo { - x: T, //~ ERROR can't use generic parameters from outer item - } - - impl Drop for Foo { - //~^ ERROR struct takes 0 generic arguments but 1 generic argument - fn drop(&mut self) {} - } -} -fn main() {} diff --git a/tests/ui/issues/issue-3214.stderr b/tests/ui/issues/issue-3214.stderr deleted file mode 100644 index 5b57c1baf90..00000000000 --- a/tests/ui/issues/issue-3214.stderr +++ /dev/null @@ -1,28 +0,0 @@ -error[E0401]: can't use generic parameters from outer item - --> $DIR/issue-3214.rs:3:12 - | -LL | fn foo() { - | - type parameter from outer item -LL | struct Foo { - | - help: try introducing a local generic parameter here: `` -LL | x: T, - | ^ use of generic parameter from outer item - -error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied - --> $DIR/issue-3214.rs:6:22 - | -LL | impl Drop for Foo { - | ^^^--- help: remove these generics - | | - | expected 0 generic arguments - | -note: struct defined here, with 0 generic parameters - --> $DIR/issue-3214.rs:2:12 - | -LL | struct Foo { - | ^^^ - -error: aborting due to 2 previous errors - -Some errors have detailed explanations: E0107, E0401. -For more information about an error, try `rustc --explain E0107`. diff --git a/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.rs b/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.rs deleted file mode 100644 index 254956ae306..00000000000 --- a/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.rs +++ /dev/null @@ -1,10 +0,0 @@ -// Check that we do not suggest `ref f` here in the `main()` function. -struct Foo { - pub v: Vec, -} - -fn main() { - let mut f = Foo { v: Vec::new() }; - f.v.push("hello".to_string()); - let e = f.v[0]; //~ ERROR cannot move out of index -} diff --git a/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr b/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr deleted file mode 100644 index d27b6e6324f..00000000000 --- a/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error[E0507]: cannot move out of index of `Vec` - --> $DIR/issue-40402-1.rs:9:13 - | -LL | let e = f.v[0]; - | ^^^^^^ move occurs because value has type `String`, which does not implement the `Copy` trait - | -help: consider borrowing here - | -LL | let e = &f.v[0]; - | + -help: consider cloning the value if the performance cost is acceptable - | -LL | let e = f.v[0].clone(); - | ++++++++ - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0507`. diff --git a/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.rs b/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.rs deleted file mode 100644 index 1fb6e31e964..00000000000 --- a/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.rs +++ /dev/null @@ -1,6 +0,0 @@ -// Check that we do suggest `(ref a, ref b)` here, since `a` and `b` -// are nested within a pattern -fn main() { - let x = vec![(String::new(), String::new())]; - let (a, b) = x[0]; //~ ERROR cannot move out of index -} diff --git a/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr b/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr deleted file mode 100644 index 987558903ee..00000000000 --- a/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error[E0507]: cannot move out of index of `Vec<(String, String)>` - --> $DIR/issue-40402-2.rs:5:18 - | -LL | let (a, b) = x[0]; - | - - ^^^^ - | | | - | | ...and here - | data moved here - | - = note: move occurs because these variables have types that don't implement the `Copy` trait -help: consider borrowing here - | -LL | let (a, b) = &x[0]; - | + - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0507`. diff --git a/tests/ui/issues/issue-5239-1.rs b/tests/ui/issues/issue-5239-1.rs deleted file mode 100644 index 708ae34c6c6..00000000000 --- a/tests/ui/issues/issue-5239-1.rs +++ /dev/null @@ -1,6 +0,0 @@ -// Regression test for issue #5239 - -fn main() { - let x = |ref x: isize| { x += 1; }; - //~^ ERROR E0368 -} diff --git a/tests/ui/issues/issue-5239-1.stderr b/tests/ui/issues/issue-5239-1.stderr deleted file mode 100644 index 63c2dbfc55c..00000000000 --- a/tests/ui/issues/issue-5239-1.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error[E0368]: binary assignment operation `+=` cannot be applied to type `&isize` - --> $DIR/issue-5239-1.rs:4:30 - | -LL | let x = |ref x: isize| { x += 1; }; - | -^^^^^ - | | - | cannot use `+=` on type `&isize` - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0368`. diff --git a/tests/ui/issues/issue-5239-2.rs b/tests/ui/issues/issue-5239-2.rs deleted file mode 100644 index 8239b06404a..00000000000 --- a/tests/ui/issues/issue-5239-2.rs +++ /dev/null @@ -1,9 +0,0 @@ -//@ run-pass -// Regression test for issue #5239 - - -pub fn main() { - let _f = |ref x: isize| { *x }; - let foo = 10; - assert_eq!(_f(foo), 10); -} diff --git a/tests/ui/issues/issue-57362-1.rs b/tests/ui/issues/issue-57362-1.rs deleted file mode 100644 index 1fa417fe98a..00000000000 --- a/tests/ui/issues/issue-57362-1.rs +++ /dev/null @@ -1,23 +0,0 @@ -// Test for issue #57362, ensuring that the self ty is shown in cases of higher-ranked lifetimes -// conflicts: the `expected` and `found` trait refs would otherwise be printed the same, leading -// to confusing notes such as: -// = note: expected type `Trait` -// found type `Trait` - -// from issue #57362 -trait Trait { - fn f(self); -} - -impl Trait for fn(&T) { - fn f(self) { - println!("f"); - } -} - -fn f() { - let a: fn(_) = |_: &u8| {}; - a.f(); //~ ERROR no method named `f` -} - -fn main() {} diff --git a/tests/ui/issues/issue-57362-1.stderr b/tests/ui/issues/issue-57362-1.stderr deleted file mode 100644 index 79b1b131afa..00000000000 --- a/tests/ui/issues/issue-57362-1.stderr +++ /dev/null @@ -1,16 +0,0 @@ -error[E0599]: no method named `f` found for fn pointer `fn(&u8)` in the current scope - --> $DIR/issue-57362-1.rs:20:7 - | -LL | a.f(); - | ^ method not found in `fn(&u8)` - | - = help: items from traits can only be used if the trait is implemented and in scope -note: `Trait` defines an item `f`, perhaps you need to implement it - --> $DIR/issue-57362-1.rs:8:1 - | -LL | trait Trait { - | ^^^^^^^^^^^ - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0599`. diff --git a/tests/ui/issues/issue-57362-2.rs b/tests/ui/issues/issue-57362-2.rs deleted file mode 100644 index a0b0ea1d038..00000000000 --- a/tests/ui/issues/issue-57362-2.rs +++ /dev/null @@ -1,25 +0,0 @@ -// Test for issue #57362, ensuring that the self ty is shown in cases of higher-ranked lifetimes -// conflicts: the `expected` and `found` trait refs would otherwise be printed the same, leading -// to confusing notes such as: -// = note: expected type `Trait` -// found type `Trait` - -// extracted from a similar issue: #57642 -trait X { - type G; - fn make_g() -> Self::G; -} - -impl<'a> X for fn(&'a ()) { - type G = &'a (); - - fn make_g() -> Self::G { - &() - } -} - -fn g() { - let x = ::make_g(); //~ ERROR the function -} - -fn main() {} diff --git a/tests/ui/issues/issue-57362-2.stderr b/tests/ui/issues/issue-57362-2.stderr deleted file mode 100644 index 57477f5341e..00000000000 --- a/tests/ui/issues/issue-57362-2.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error[E0599]: the function or associated item `make_g` exists for fn pointer `fn(&())`, but its trait bounds were not satisfied - --> $DIR/issue-57362-2.rs:22:25 - | -LL | let x = ::make_g(); - | ^^^^^^ function or associated item cannot be called on `fn(&())` due to unsatisfied trait bounds - | - = note: the following trait bounds were not satisfied: - `for<'a> fn(&'a ()): X` - = help: items from traits can only be used if the trait is implemented and in scope -note: `X` defines an item `make_g`, perhaps you need to implement it - --> $DIR/issue-57362-2.rs:8:1 - | -LL | trait X { - | ^^^^^^^ - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0599`. diff --git a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.fixed b/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.fixed deleted file mode 100644 index 8b473de4ac2..00000000000 --- a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.fixed +++ /dev/null @@ -1,53 +0,0 @@ -//@ run-rustfix -use std::ops::Deref; -use std::ops::DerefMut; -struct Bar(u8); -struct Foo(Bar); -struct Emm(Foo); -impl Deref for Bar{ - type Target = u8; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Foo { - type Target = Bar; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Emm { - type Target = Foo; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl DerefMut for Bar{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -impl DerefMut for Foo { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -impl DerefMut for Emm { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -fn main() { - // Suggest dereference with arbitrary mutability - let a = Emm(Foo(Bar(0))); - let _: *const u8 = &***a; //~ ERROR mismatched types - - let mut a = Emm(Foo(Bar(0))); - let _: *mut u8 = &mut ***a; //~ ERROR mismatched types - - let a = Emm(Foo(Bar(0))); - let _: *const u8 = &***a; //~ ERROR mismatched types - - let mut a = Emm(Foo(Bar(0))); - let _: *mut u8 = &mut ***a; //~ ERROR mismatched types -} diff --git a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.rs b/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.rs deleted file mode 100644 index 38d23fb8428..00000000000 --- a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.rs +++ /dev/null @@ -1,53 +0,0 @@ -//@ run-rustfix -use std::ops::Deref; -use std::ops::DerefMut; -struct Bar(u8); -struct Foo(Bar); -struct Emm(Foo); -impl Deref for Bar{ - type Target = u8; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Foo { - type Target = Bar; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Emm { - type Target = Foo; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl DerefMut for Bar{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -impl DerefMut for Foo { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -impl DerefMut for Emm { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -fn main() { - // Suggest dereference with arbitrary mutability - let a = Emm(Foo(Bar(0))); - let _: *const u8 = &a; //~ ERROR mismatched types - - let mut a = Emm(Foo(Bar(0))); - let _: *mut u8 = &a; //~ ERROR mismatched types - - let a = Emm(Foo(Bar(0))); - let _: *const u8 = &mut a; //~ ERROR mismatched types - - let mut a = Emm(Foo(Bar(0))); - let _: *mut u8 = &mut a; //~ ERROR mismatched types -} diff --git a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.stderr b/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.stderr deleted file mode 100644 index 164641ff775..00000000000 --- a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-1.stderr +++ /dev/null @@ -1,63 +0,0 @@ -error[E0308]: mismatched types - --> $DIR/issue-71676-1.rs:43:24 - | -LL | let _: *const u8 = &a; - | --------- ^^ expected `*const u8`, found `&Emm` - | | - | expected due to this - | - = note: expected raw pointer `*const u8` - found reference `&Emm` -help: consider dereferencing - | -LL | let _: *const u8 = &***a; - | +++ - -error[E0308]: mismatched types - --> $DIR/issue-71676-1.rs:46:22 - | -LL | let _: *mut u8 = &a; - | ------- ^^ types differ in mutability - | | - | expected due to this - | - = note: expected raw pointer `*mut u8` - found reference `&Emm` -help: consider dereferencing - | -LL | let _: *mut u8 = &mut ***a; - | +++++++ - -error[E0308]: mismatched types - --> $DIR/issue-71676-1.rs:49:24 - | -LL | let _: *const u8 = &mut a; - | --------- ^^^^^^ expected `*const u8`, found `&mut Emm` - | | - | expected due to this - | - = note: expected raw pointer `*const u8` - found mutable reference `&mut Emm` -help: consider dereferencing - | -LL | let _: *const u8 = &***a; - | ~~~ - -error[E0308]: mismatched types - --> $DIR/issue-71676-1.rs:52:22 - | -LL | let _: *mut u8 = &mut a; - | ------- ^^^^^^ expected `*mut u8`, found `&mut Emm` - | | - | expected due to this - | - = note: expected raw pointer `*mut u8` - found mutable reference `&mut Emm` -help: consider dereferencing - | -LL | let _: *mut u8 = &mut ***a; - | +++ - -error: aborting due to 4 previous errors - -For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-2.rs b/tests/ui/issues/issue-71676-suggest-deref/issue-71676-2.rs deleted file mode 100644 index f3183899dc5..00000000000 --- a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-2.rs +++ /dev/null @@ -1,42 +0,0 @@ -use std::ops::Deref; -use std::ops::DerefMut; -struct Bar(u8); -struct Foo(Bar); -struct Emm(Foo); -impl Deref for Bar{ - type Target = u8; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Foo { - type Target = Bar; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl Deref for Emm { - type Target = Foo; - fn deref(&self) -> &Self::Target { - &self.0 - } -} -impl DerefMut for Bar{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -impl DerefMut for Foo { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -impl DerefMut for Emm { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} -fn main() { - let a = Emm(Foo(Bar(0))); - let _: *mut u8 = &a; //~ ERROR mismatched types -} diff --git a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-2.stderr b/tests/ui/issues/issue-71676-suggest-deref/issue-71676-2.stderr deleted file mode 100644 index 6ed318c8768..00000000000 --- a/tests/ui/issues/issue-71676-suggest-deref/issue-71676-2.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error[E0308]: mismatched types - --> $DIR/issue-71676-2.rs:41:22 - | -LL | let _: *mut u8 = &a; - | ------- ^^ types differ in mutability - | | - | expected due to this - | - = note: expected raw pointer `*mut u8` - found reference `&Emm` -help: consider dereferencing - | -LL | let _: *mut u8 = &mut ***a; - | +++++++ - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/issues/issue-7607-1.rs b/tests/ui/issues/issue-7607-1.rs deleted file mode 100644 index 5221f2c529b..00000000000 --- a/tests/ui/issues/issue-7607-1.rs +++ /dev/null @@ -1,9 +0,0 @@ -struct Foo { - x: isize -} - -impl Fo { //~ ERROR cannot find type `Fo` in this scope - fn foo() {} -} - -fn main() {} diff --git a/tests/ui/issues/issue-7607-1.stderr b/tests/ui/issues/issue-7607-1.stderr deleted file mode 100644 index db4c8f25dbc..00000000000 --- a/tests/ui/issues/issue-7607-1.stderr +++ /dev/null @@ -1,12 +0,0 @@ -error[E0412]: cannot find type `Fo` in this scope - --> $DIR/issue-7607-1.rs:5:6 - | -LL | impl Fo { - | ^^ help: a trait with a similar name exists: `Fn` - --> $SRC_DIR/core/src/ops/function.rs:LL:COL - | - = note: similarly named trait `Fn` defined here - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0412`. diff --git a/tests/ui/issues/issue-7607-2.rs b/tests/ui/issues/issue-7607-2.rs deleted file mode 100644 index 654f26bf298..00000000000 --- a/tests/ui/issues/issue-7607-2.rs +++ /dev/null @@ -1,16 +0,0 @@ -//@ check-pass -#![allow(dead_code)] -//@ pretty-expanded FIXME #23616 - -pub mod a { - pub struct Foo { a: usize } -} - -pub mod b { - use a::Foo; - impl Foo { - fn bar(&self) { } - } -} - -pub fn main() { } diff --git a/tests/ui/macros/issue-11692-1.rs b/tests/ui/macros/issue-11692-1.rs new file mode 100644 index 00000000000..b6f3bb8ef05 --- /dev/null +++ b/tests/ui/macros/issue-11692-1.rs @@ -0,0 +1,3 @@ +fn main() { + print!(testo!()); //~ ERROR cannot find macro `testo` in this scope +} diff --git a/tests/ui/macros/issue-11692-1.stderr b/tests/ui/macros/issue-11692-1.stderr new file mode 100644 index 00000000000..46382f65218 --- /dev/null +++ b/tests/ui/macros/issue-11692-1.stderr @@ -0,0 +1,8 @@ +error: cannot find macro `testo` in this scope + --> $DIR/issue-11692-1.rs:2:12 + | +LL | print!(testo!()); + | ^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/macros/issue-11692-2.rs b/tests/ui/macros/issue-11692-2.rs new file mode 100644 index 00000000000..5957ed338f4 --- /dev/null +++ b/tests/ui/macros/issue-11692-2.rs @@ -0,0 +1,3 @@ +fn main() { + concat!(test!()); //~ ERROR cannot find macro `test` in this scope +} diff --git a/tests/ui/macros/issue-11692-2.stderr b/tests/ui/macros/issue-11692-2.stderr new file mode 100644 index 00000000000..53add509ca5 --- /dev/null +++ b/tests/ui/macros/issue-11692-2.stderr @@ -0,0 +1,10 @@ +error: cannot find macro `test` in this scope + --> $DIR/issue-11692-2.rs:2:13 + | +LL | concat!(test!()); + | ^^^^ + | + = note: `test` is in scope, but it is an attribute: `#[test]` + +error: aborting due to 1 previous error + diff --git a/tests/ui/nll/issue-57362-1.rs b/tests/ui/nll/issue-57362-1.rs new file mode 100644 index 00000000000..1fa417fe98a --- /dev/null +++ b/tests/ui/nll/issue-57362-1.rs @@ -0,0 +1,23 @@ +// Test for issue #57362, ensuring that the self ty is shown in cases of higher-ranked lifetimes +// conflicts: the `expected` and `found` trait refs would otherwise be printed the same, leading +// to confusing notes such as: +// = note: expected type `Trait` +// found type `Trait` + +// from issue #57362 +trait Trait { + fn f(self); +} + +impl Trait for fn(&T) { + fn f(self) { + println!("f"); + } +} + +fn f() { + let a: fn(_) = |_: &u8| {}; + a.f(); //~ ERROR no method named `f` +} + +fn main() {} diff --git a/tests/ui/nll/issue-57362-1.stderr b/tests/ui/nll/issue-57362-1.stderr new file mode 100644 index 00000000000..79b1b131afa --- /dev/null +++ b/tests/ui/nll/issue-57362-1.stderr @@ -0,0 +1,16 @@ +error[E0599]: no method named `f` found for fn pointer `fn(&u8)` in the current scope + --> $DIR/issue-57362-1.rs:20:7 + | +LL | a.f(); + | ^ method not found in `fn(&u8)` + | + = help: items from traits can only be used if the trait is implemented and in scope +note: `Trait` defines an item `f`, perhaps you need to implement it + --> $DIR/issue-57362-1.rs:8:1 + | +LL | trait Trait { + | ^^^^^^^^^^^ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0599`. diff --git a/tests/ui/nll/issue-57362-2.rs b/tests/ui/nll/issue-57362-2.rs new file mode 100644 index 00000000000..a0b0ea1d038 --- /dev/null +++ b/tests/ui/nll/issue-57362-2.rs @@ -0,0 +1,25 @@ +// Test for issue #57362, ensuring that the self ty is shown in cases of higher-ranked lifetimes +// conflicts: the `expected` and `found` trait refs would otherwise be printed the same, leading +// to confusing notes such as: +// = note: expected type `Trait` +// found type `Trait` + +// extracted from a similar issue: #57642 +trait X { + type G; + fn make_g() -> Self::G; +} + +impl<'a> X for fn(&'a ()) { + type G = &'a (); + + fn make_g() -> Self::G { + &() + } +} + +fn g() { + let x = ::make_g(); //~ ERROR the function +} + +fn main() {} diff --git a/tests/ui/nll/issue-57362-2.stderr b/tests/ui/nll/issue-57362-2.stderr new file mode 100644 index 00000000000..57477f5341e --- /dev/null +++ b/tests/ui/nll/issue-57362-2.stderr @@ -0,0 +1,18 @@ +error[E0599]: the function or associated item `make_g` exists for fn pointer `fn(&())`, but its trait bounds were not satisfied + --> $DIR/issue-57362-2.rs:22:25 + | +LL | let x = ::make_g(); + | ^^^^^^ function or associated item cannot be called on `fn(&())` due to unsatisfied trait bounds + | + = note: the following trait bounds were not satisfied: + `for<'a> fn(&'a ()): X` + = help: items from traits can only be used if the trait is implemented and in scope +note: `X` defines an item `make_g`, perhaps you need to implement it + --> $DIR/issue-57362-2.rs:8:1 + | +LL | trait X { + | ^^^^^^^ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0599`. diff --git a/tests/ui/parser/issue-12187-1.rs b/tests/ui/parser/issue-12187-1.rs new file mode 100644 index 00000000000..86128ed94bd --- /dev/null +++ b/tests/ui/parser/issue-12187-1.rs @@ -0,0 +1,8 @@ +fn new() -> &'static T { + panic!() +} + +fn main() { + let &v = new(); + //~^ ERROR type annotations needed +} diff --git a/tests/ui/parser/issue-12187-1.stderr b/tests/ui/parser/issue-12187-1.stderr new file mode 100644 index 00000000000..704854fe585 --- /dev/null +++ b/tests/ui/parser/issue-12187-1.stderr @@ -0,0 +1,14 @@ +error[E0282]: type annotations needed for `&_` + --> $DIR/issue-12187-1.rs:6:9 + | +LL | let &v = new(); + | ^^ ----- type must be known at this point + | +help: consider giving this pattern a type, where the type for type parameter `T` is specified + | +LL | let &v: &T = new(); + | ++++ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0282`. diff --git a/tests/ui/parser/issue-12187-2.rs b/tests/ui/parser/issue-12187-2.rs new file mode 100644 index 00000000000..080a6206be7 --- /dev/null +++ b/tests/ui/parser/issue-12187-2.rs @@ -0,0 +1,8 @@ +fn new<'r, T>() -> &'r T { + panic!() +} + +fn main() { + let &v = new(); + //~^ ERROR type annotations needed +} diff --git a/tests/ui/parser/issue-12187-2.stderr b/tests/ui/parser/issue-12187-2.stderr new file mode 100644 index 00000000000..eeef63a1d0b --- /dev/null +++ b/tests/ui/parser/issue-12187-2.stderr @@ -0,0 +1,14 @@ +error[E0282]: type annotations needed for `&_` + --> $DIR/issue-12187-2.rs:6:9 + | +LL | let &v = new(); + | ^^ ----- type must be known at this point + | +help: consider giving this pattern a type, where the type for type parameter `T` is specified + | +LL | let &v: &T = new(); + | ++++ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0282`. diff --git a/tests/ui/recursion/issue-23122-1.rs b/tests/ui/recursion/issue-23122-1.rs new file mode 100644 index 00000000000..7fe0900ed5f --- /dev/null +++ b/tests/ui/recursion/issue-23122-1.rs @@ -0,0 +1,14 @@ +trait Next { + type Next: Next; +} + +struct GetNext { + t: T, +} + +impl Next for GetNext { + type Next = as Next>::Next; + //~^ ERROR overflow evaluating the requirement +} + +fn main() {} diff --git a/tests/ui/recursion/issue-23122-1.stderr b/tests/ui/recursion/issue-23122-1.stderr new file mode 100644 index 00000000000..c432a502c13 --- /dev/null +++ b/tests/ui/recursion/issue-23122-1.stderr @@ -0,0 +1,9 @@ +error[E0275]: overflow evaluating the requirement ` as Next>::Next == _` + --> $DIR/issue-23122-1.rs:10:17 + | +LL | type Next = as Next>::Next; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0275`. diff --git a/tests/ui/recursion/issue-23122-2.rs b/tests/ui/recursion/issue-23122-2.rs new file mode 100644 index 00000000000..2880b956417 --- /dev/null +++ b/tests/ui/recursion/issue-23122-2.rs @@ -0,0 +1,15 @@ +//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash" +trait Next { + type Next: Next; +} + +struct GetNext { + t: T, +} + +impl Next for GetNext { + type Next = as Next>::Next; + //~^ ERROR overflow evaluating the requirement +} + +fn main() {} diff --git a/tests/ui/recursion/issue-23122-2.stderr b/tests/ui/recursion/issue-23122-2.stderr new file mode 100644 index 00000000000..10463ab2c33 --- /dev/null +++ b/tests/ui/recursion/issue-23122-2.stderr @@ -0,0 +1,18 @@ +error[E0275]: overflow evaluating the requirement `<<<<<<<... as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next: Sized` + --> $DIR/issue-23122-2.rs:11:17 + | +LL | type Next = as Next>::Next; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_23122_2`) +note: required for `GetNext<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next as Next>::Next>` to implement `Next` + --> $DIR/issue-23122-2.rs:10:15 + | +LL | impl Next for GetNext { + | - ^^^^ ^^^^^^^^^^ + | | + | unsatisfied trait bound introduced here + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0275`. diff --git a/tests/ui/resolve/issue-3214.rs b/tests/ui/resolve/issue-3214.rs new file mode 100644 index 00000000000..b2c27f5be95 --- /dev/null +++ b/tests/ui/resolve/issue-3214.rs @@ -0,0 +1,11 @@ +fn foo() { + struct Foo { + x: T, //~ ERROR can't use generic parameters from outer item + } + + impl Drop for Foo { + //~^ ERROR struct takes 0 generic arguments but 1 generic argument + fn drop(&mut self) {} + } +} +fn main() {} diff --git a/tests/ui/resolve/issue-3214.stderr b/tests/ui/resolve/issue-3214.stderr new file mode 100644 index 00000000000..5b57c1baf90 --- /dev/null +++ b/tests/ui/resolve/issue-3214.stderr @@ -0,0 +1,28 @@ +error[E0401]: can't use generic parameters from outer item + --> $DIR/issue-3214.rs:3:12 + | +LL | fn foo() { + | - type parameter from outer item +LL | struct Foo { + | - help: try introducing a local generic parameter here: `` +LL | x: T, + | ^ use of generic parameter from outer item + +error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied + --> $DIR/issue-3214.rs:6:22 + | +LL | impl Drop for Foo { + | ^^^--- help: remove these generics + | | + | expected 0 generic arguments + | +note: struct defined here, with 0 generic parameters + --> $DIR/issue-3214.rs:2:12 + | +LL | struct Foo { + | ^^^ + +error: aborting due to 2 previous errors + +Some errors have detailed explanations: E0107, E0401. +For more information about an error, try `rustc --explain E0107`. diff --git a/tests/ui/type/issue-7607-1.rs b/tests/ui/type/issue-7607-1.rs new file mode 100644 index 00000000000..5221f2c529b --- /dev/null +++ b/tests/ui/type/issue-7607-1.rs @@ -0,0 +1,9 @@ +struct Foo { + x: isize +} + +impl Fo { //~ ERROR cannot find type `Fo` in this scope + fn foo() {} +} + +fn main() {} diff --git a/tests/ui/type/issue-7607-1.stderr b/tests/ui/type/issue-7607-1.stderr new file mode 100644 index 00000000000..db4c8f25dbc --- /dev/null +++ b/tests/ui/type/issue-7607-1.stderr @@ -0,0 +1,12 @@ +error[E0412]: cannot find type `Fo` in this scope + --> $DIR/issue-7607-1.rs:5:6 + | +LL | impl Fo { + | ^^ help: a trait with a similar name exists: `Fn` + --> $SRC_DIR/core/src/ops/function.rs:LL:COL + | + = note: similarly named trait `Fn` defined here + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0412`. diff --git a/tests/ui/type/issue-7607-2.rs b/tests/ui/type/issue-7607-2.rs new file mode 100644 index 00000000000..654f26bf298 --- /dev/null +++ b/tests/ui/type/issue-7607-2.rs @@ -0,0 +1,16 @@ +//@ check-pass +#![allow(dead_code)] +//@ pretty-expanded FIXME #23616 + +pub mod a { + pub struct Foo { a: usize } +} + +pub mod b { + use a::Foo; + impl Foo { + fn bar(&self) { } + } +} + +pub fn main() { } -- cgit 1.4.1-3-g733a5