nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #122852 - compiler-errors:raw-ptr, r=lcnr

Browse Source 
Remove `TypeAndMut` from `ty::RawPtr` variant, make it take `Ty` and `Mutability`

Pretty much mechanically converting `ty::RawPtr(ty::TypeAndMut { ty, mutbl })` to `ty::RawPtr(ty, mutbl)` and its fallout.

r? lcnr

cc rust-lang/types-team#124
This commit is contained in:
bors 2024-03-22 20:34:14 +00:00
commit 85e449a323
126 changed files with 409 additions and 578 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_borrowck/src/diagnostics/mod.rs
View File

@ -366,7 +366,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
Some(variant.fields[field].name.to_string()) Some(variant.fields[field].name.to_string())
} }
ty::Tuple(_) => Some(field.index().to_string()), ty::Tuple(_) => Some(field.index().to_string()),
ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => { ty::Ref(_, ty, _) | ty::RawPtr(ty, _) => {
self.describe_field_from_ty(ty, field, variant_index, including_tuple_field) self.describe_field_from_ty(ty, field, variant_index, including_tuple_field)
} }
ty::Array(ty, _) | ty::Slice(ty) => { ty::Array(ty, _) | ty::Slice(ty) => {

6
compiler/rustc_borrowck/src/diagnostics/region_errors.rs
View File

@ -503,10 +503,10 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
ty::VarianceDiagInfo::None => {} ty::VarianceDiagInfo::None => {}
ty::VarianceDiagInfo::Invariant { ty, param_index } => { ty::VarianceDiagInfo::Invariant { ty, param_index } => {
let (desc, note) = match ty.kind() { let (desc, note) = match ty.kind() {
ty::RawPtr(ty_mut) => { ty::RawPtr(ty, mutbl) => {
assert_eq!(ty_mut.mutbl, rustc_hir::Mutability::Mut); assert_eq!(*mutbl, rustc_hir::Mutability::Mut);
( (
format!("a mutable pointer to `{}`", ty_mut.ty), format!("a mutable pointer to `{}`", ty),
"mutable pointers are invariant over their type parameter".to_string(), "mutable pointers are invariant over their type parameter".to_string(),
) )
} }

4
compiler/rustc_borrowck/src/diagnostics/region_name.rs
View File

@ -555,8 +555,8 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
search_stack.push((*elem_ty, elem_hir_ty)); search_stack.push((*elem_ty, elem_hir_ty));
} }
(ty::RawPtr(mut_ty), hir::TyKind::Ptr(mut_hir_ty)) => { (ty::RawPtr(mut_ty, _), hir::TyKind::Ptr(mut_hir_ty)) => {
search_stack.push((mut_ty.ty, &mut_hir_ty.ty)); search_stack.push((*mut_ty, &mut_hir_ty.ty));
} }
_ => { _ => {

6
compiler/rustc_borrowck/src/lib.rs
View File

@ -1649,7 +1649,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)
@ -2284,8 +2284,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
} }
} }
} }
ty::RawPtr(tnm) => { ty::RawPtr(_, mutbl) => {
match tnm.mutbl { match mutbl {
// `*const` raw pointers are not mutable // `*const` raw pointers are not mutable
hir::Mutability::Not => Err(place), hir::Mutability::Not => Err(place),
// `*mut` raw pointers are always mutable, regardless of // `*mut` raw pointers are always mutable, regardless of

23
compiler/rustc_borrowck/src/type_check/mod.rs
View File

@ -2157,15 +2157,12 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
} }
CastKind::PointerCoercion(PointerCoercion::MutToConstPointer) => { CastKind::PointerCoercion(PointerCoercion::MutToConstPointer) => {
let ty::RawPtr(ty::TypeAndMut { ty: ty_from, mutbl: hir::Mutability::Mut }) = let ty::RawPtr(ty_from, hir::Mutability::Mut) = op.ty(body, tcx).kind()
op.ty(body, tcx).kind()
else { else {
span_mirbug!(self, rvalue, "unexpected base type for cast {:?}", ty,); span_mirbug!(self, rvalue, "unexpected base type for cast {:?}", ty,);
return; return;
}; };
let ty::RawPtr(ty::TypeAndMut { ty: ty_to, mutbl: hir::Mutability::Not }) = let ty::RawPtr(ty_to, hir::Mutability::Not) = ty.kind() else {
ty.kind()
else {
span_mirbug!(self, rvalue, "unexpected target type for cast {:?}", ty,); span_mirbug!(self, rvalue, "unexpected target type for cast {:?}", ty,);
return; return;
}; };
@ -2190,12 +2187,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
let ty_from = op.ty(body, tcx); let ty_from = op.ty(body, tcx);
let opt_ty_elem_mut = match ty_from.kind() { let opt_ty_elem_mut = match ty_from.kind() {
ty::RawPtr(ty::TypeAndMut { mutbl: array_mut, ty: array_ty }) => { ty::RawPtr(array_ty, array_mut) => match array_ty.kind() {
match array_ty.kind() { ty::Array(ty_elem, _) => Some((ty_elem, *array_mut)),
ty::Array(ty_elem, _) => Some((ty_elem, *array_mut)), _ => None,
_ => None, },
}
}
_ => None, _ => None,
}; };
@ -2210,9 +2205,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}; };
let (ty_to, ty_to_mut) = match ty.kind() { let (ty_to, ty_to_mut) = match ty.kind() {
ty::RawPtr(ty::TypeAndMut { mutbl: ty_to_mut, ty: ty_to }) => { ty::RawPtr(ty_to, ty_to_mut) => (ty_to, *ty_to_mut),
(ty_to, *ty_to_mut)
}
_ => { _ => {
span_mirbug!( span_mirbug!(
self, self,
@ -2413,7 +2406,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
let ty_left = left.ty(body, tcx); let ty_left = left.ty(body, tcx);
match ty_left.kind() { match ty_left.kind() {
// Types with regions are comparable if they have a common super-type. // Types with regions are comparable if they have a common super-type.
ty::RawPtr(_) | ty::FnPtr(_) => { ty::RawPtr(_, _) | ty::FnPtr(_) => {
let ty_right = right.ty(body, tcx); let ty_right = right.ty(body, tcx);
let common_ty = self.infcx.next_ty_var(TypeVariableOrigin { let common_ty = self.infcx.next_ty_var(TypeVariableOrigin {
kind: TypeVariableOriginKind::MiscVariable, kind: TypeVariableOriginKind::MiscVariable,

6
compiler/rustc_codegen_cranelift/src/abi/mod.rs
View File

@ -677,11 +677,7 @@ pub(crate) fn codegen_drop<'tcx>(
let arg_value = drop_place.place_ref( let arg_value = drop_place.place_ref(
fx, fx,
fx.layout_of(Ty::new_ref( fx.layout_of(Ty::new_mut_ref(fx.tcx, fx.tcx.lifetimes.re_erased, ty)),
fx.tcx,
fx.tcx.lifetimes.re_erased,
TypeAndMut { ty, mutbl: crate::rustc_hir::Mutability::Mut },
)),
); );
let arg_value = adjust_arg_for_abi(fx, arg_value, &fn_abi.args[0], true); let arg_value = adjust_arg_for_abi(fx, arg_value, &fn_abi.args[0], true);

4
compiler/rustc_codegen_cranelift/src/common.rs
View File

@ -69,7 +69,7 @@ fn clif_type_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<types::Typ
FloatTy::F128 => unimplemented!("f16_f128"), FloatTy::F128 => unimplemented!("f16_f128"),
}, },
ty::FnPtr(_) => pointer_ty(tcx), ty::FnPtr(_) => pointer_ty(tcx),
ty::RawPtr(TypeAndMut { ty: pointee_ty, mutbl: _ }) | ty::Ref(_, pointee_ty, _) => { ty::RawPtr(pointee_ty, _) | ty::Ref(_, pointee_ty, _) => {
if has_ptr_meta(tcx, *pointee_ty) { if has_ptr_meta(tcx, *pointee_ty) {
return None; return None;
} else { } else {
@ -89,7 +89,7 @@ fn clif_pair_type_from_ty<'tcx>(
ty::Tuple(types) if types.len() == 2 => { ty::Tuple(types) if types.len() == 2 => {
(clif_type_from_ty(tcx, types[0])?, clif_type_from_ty(tcx, types[1])?) (clif_type_from_ty(tcx, types[0])?, clif_type_from_ty(tcx, types[1])?)
} }
ty::RawPtr(TypeAndMut { ty: pointee_ty, mutbl: _ }) | ty::Ref(_, pointee_ty, _) => { ty::RawPtr(pointee_ty, _) | ty::Ref(_, pointee_ty, _) => {
if has_ptr_meta(tcx, *pointee_ty) { if has_ptr_meta(tcx, *pointee_ty) {
(pointer_ty(tcx), pointer_ty(tcx)) (pointer_ty(tcx), pointer_ty(tcx))
} else { } else {

6
compiler/rustc_codegen_cranelift/src/unsize.rs
View File

@ -70,10 +70,8 @@ fn unsize_ptr<'tcx>(
) -> (Value, Value) { ) -> (Value, Value) {
match (&src_layout.ty.kind(), &dst_layout.ty.kind()) { match (&src_layout.ty.kind(), &dst_layout.ty.kind()) {
(&ty::Ref(_, a, _), &ty::Ref(_, b, _)) (&ty::Ref(_, a, _), &ty::Ref(_, b, _))
| (&ty::Ref(_, a, _), &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) | (&ty::Ref(_, a, _), &ty::RawPtr(b, _))
| (&ty::RawPtr(ty::TypeAndMut { ty: a, .. }), &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) => { | (&ty::RawPtr(a, _), &ty::RawPtr(b, _)) => (src, unsized_info(fx, *a, *b, old_info)),
(src, unsized_info(fx, *a, *b, old_info))
}
(&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => { (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
assert_eq!(def_a, def_b); assert_eq!(def_a, def_b);

9
compiler/rustc_codegen_cranelift/src/value_and_place.rs
View File

@ -865,15 +865,10 @@ pub(crate) fn assert_assignable<'tcx>(
return; return;
} }
match (from_ty.kind(), to_ty.kind()) { match (from_ty.kind(), to_ty.kind()) {
(ty::Ref(_, a, _), ty::Ref(_, b, _)) (ty::Ref(_, a, _), ty::Ref(_, b, _)) | (ty::RawPtr(a, _), ty::RawPtr(b, _)) => {
| (
ty::RawPtr(TypeAndMut { ty: a, mutbl: _ }),
ty::RawPtr(TypeAndMut { ty: b, mutbl: _ }),
) => {
assert_assignable(fx, *a, *b, limit - 1); assert_assignable(fx, *a, *b, limit - 1);
} }
(ty::Ref(_, a, _), ty::RawPtr(TypeAndMut { ty: b, mutbl: _ })) (ty::Ref(_, a, _), ty::RawPtr(b, _)) | (ty::RawPtr(a, _), ty::Ref(_, b, _)) => {
| (ty::RawPtr(TypeAndMut { ty: a, mutbl: _ }), ty::Ref(_, b, _)) => {
assert_assignable(fx, *a, *b, limit - 1); assert_assignable(fx, *a, *b, limit - 1);
} }
(ty::FnPtr(_), ty::FnPtr(_)) => { (ty::FnPtr(_), ty::FnPtr(_)) => {

24
compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
View File

@ -796,16 +796,16 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
// This counts how many pointers // This counts how many pointers
fn ptr_count(t: Ty<'_>) -> usize { fn ptr_count(t: Ty<'_>) -> usize {
match t.kind() { match *t.kind() {
ty::RawPtr(p) => 1 + ptr_count(p.ty), ty::RawPtr(p_ty, _) => 1 + ptr_count(p_ty),
_ => 0, _ => 0,
} }
} }
// Non-ptr type // Non-ptr type
fn non_ptr(t: Ty<'_>) -> Ty<'_> { fn non_ptr(t: Ty<'_>) -> Ty<'_> {
match t.kind() { match *t.kind() {
ty::RawPtr(p) => non_ptr(p.ty), ty::RawPtr(p_ty, _) => non_ptr(p_ty),
_ => t, _ => t,
} }
} }
@ -814,8 +814,8 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
// to the element type of the first argument // to the element type of the first argument
let (_, element_ty0) = arg_tys[0].simd_size_and_type(bx.tcx()); let (_, element_ty0) = arg_tys[0].simd_size_and_type(bx.tcx());
let (_, element_ty1) = arg_tys[1].simd_size_and_type(bx.tcx()); let (_, element_ty1) = arg_tys[1].simd_size_and_type(bx.tcx());
let (pointer_count, underlying_ty) = match element_ty1.kind() { let (pointer_count, underlying_ty) = match *element_ty1.kind() {
ty::RawPtr(p) if p.ty == in_elem => (ptr_count(element_ty1), non_ptr(element_ty1)), ty::RawPtr(p_ty, _) if p_ty == in_elem => (ptr_count(element_ty1), non_ptr(element_ty1)),
_ => { _ => {
require!( require!(
false, false,
@ -910,16 +910,16 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
// This counts how many pointers // This counts how many pointers
fn ptr_count(t: Ty<'_>) -> usize { fn ptr_count(t: Ty<'_>) -> usize {
match t.kind() { match *t.kind() {
ty::RawPtr(p) => 1 + ptr_count(p.ty), ty::RawPtr(p_ty, _) => 1 + ptr_count(p_ty),
_ => 0, _ => 0,
} }
} }
// Non-ptr type // Non-ptr type
fn non_ptr(t: Ty<'_>) -> Ty<'_> { fn non_ptr(t: Ty<'_>) -> Ty<'_> {
match t.kind() { match *t.kind() {
ty::RawPtr(p) => non_ptr(p.ty), ty::RawPtr(p_ty, _) => non_ptr(p_ty),
_ => t, _ => t,
} }
} }
@ -929,8 +929,8 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
let (_, element_ty0) = arg_tys[0].simd_size_and_type(bx.tcx()); let (_, element_ty0) = arg_tys[0].simd_size_and_type(bx.tcx());
let (_, element_ty1) = arg_tys[1].simd_size_and_type(bx.tcx()); let (_, element_ty1) = arg_tys[1].simd_size_and_type(bx.tcx());
let (_, element_ty2) = arg_tys[2].simd_size_and_type(bx.tcx()); let (_, element_ty2) = arg_tys[2].simd_size_and_type(bx.tcx());
let (pointer_count, underlying_ty) = match element_ty1.kind() { let (pointer_count, underlying_ty) = match *element_ty1.kind() {
ty::RawPtr(p) if p.ty == in_elem && p.mutbl == hir::Mutability::Mut => { ty::RawPtr(p_ty, mutbl) if p_ty == in_elem && mutbl == hir::Mutability::Mut => {
(ptr_count(element_ty1), non_ptr(element_ty1)) (ptr_count(element_ty1), non_ptr(element_ty1))
} }
_ => { _ => {

2
compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
View File

@ -452,7 +452,7 @@ pub fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll D
ty::Slice(_) | ty::Str => build_slice_type_di_node(cx, t, unique_type_id), ty::Slice(_) | ty::Str => build_slice_type_di_node(cx, t, unique_type_id),
ty::Dynamic(..) => build_dyn_type_di_node(cx, t, unique_type_id), ty::Dynamic(..) => build_dyn_type_di_node(cx, t, unique_type_id),
ty::Foreign(..) => build_foreign_type_di_node(cx, t, unique_type_id), ty::Foreign(..) => build_foreign_type_di_node(cx, t, unique_type_id),
ty::RawPtr(ty::TypeAndMut { ty: pointee_type, .. }) | ty::Ref(_, pointee_type, _) => { ty::RawPtr(pointee_type, _) | ty::Ref(_, pointee_type, _) => {
build_pointer_or_reference_di_node(cx, t, pointee_type, unique_type_id) build_pointer_or_reference_di_node(cx, t, pointee_type, unique_type_id)
} }
// Some `Box` are newtyped pointers, make debuginfo aware of that. // Some `Box` are newtyped pointers, make debuginfo aware of that.

34
compiler/rustc_codegen_llvm/src/intrinsic.rs
View File

@ -1483,7 +1483,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
v.normalize(bx.target_spec().pointer_width).bit_width().unwrap() v.normalize(bx.target_spec().pointer_width).bit_width().unwrap()
), ),
ty::Float(v) => format!("v{}f{}", vec_len, v.bit_width()), ty::Float(v) => format!("v{}f{}", vec_len, v.bit_width()),
ty::RawPtr(_) => format!("v{}p0", vec_len), ty::RawPtr(_, _) => format!("v{}p0", vec_len),
_ => unreachable!(), _ => unreachable!(),
} }
} }
@ -1493,7 +1493,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
ty::Int(v) => cx.type_int_from_ty(v), ty::Int(v) => cx.type_int_from_ty(v),
ty::Uint(v) => cx.type_uint_from_ty(v), ty::Uint(v) => cx.type_uint_from_ty(v),
ty::Float(v) => cx.type_float_from_ty(v), ty::Float(v) => cx.type_float_from_ty(v),
ty::RawPtr(_) => cx.type_ptr(), ty::RawPtr(_, _) => cx.type_ptr(),
_ => unreachable!(), _ => unreachable!(),
}; };
cx.type_vector(elem_ty, vec_len) cx.type_vector(elem_ty, vec_len)
@ -1548,8 +1548,8 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
require!( require!(
matches!( matches!(
element_ty1.kind(), *element_ty1.kind(),
ty::RawPtr(p) if p.ty == in_elem && p.ty.kind() == element_ty0.kind() ty::RawPtr(p_ty, _) if p_ty == in_elem && p_ty.kind() == element_ty0.kind()
), ),
InvalidMonomorphization::ExpectedElementType { InvalidMonomorphization::ExpectedElementType {
span, span,
@ -1654,8 +1654,8 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
require!( require!(
matches!( matches!(
pointer_ty.kind(), *pointer_ty.kind(),
ty::RawPtr(p) if p.ty == values_elem && p.ty.kind() == values_elem.kind() ty::RawPtr(p_ty, _) if p_ty == values_elem && p_ty.kind() == values_elem.kind()
), ),
InvalidMonomorphization::ExpectedElementType { InvalidMonomorphization::ExpectedElementType {
span, span,
@ -1746,8 +1746,8 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
// The second argument must be a mutable pointer type matching the element type // The second argument must be a mutable pointer type matching the element type
require!( require!(
matches!( matches!(
pointer_ty.kind(), *pointer_ty.kind(),
ty::RawPtr(p) if p.ty == values_elem && p.ty.kind() == values_elem.kind() && p.mutbl.is_mut() ty::RawPtr(p_ty, p_mutbl) if p_ty == values_elem && p_ty.kind() == values_elem.kind() && p_mutbl.is_mut()
), ),
InvalidMonomorphization::ExpectedElementType { InvalidMonomorphization::ExpectedElementType {
span, span,
@ -1843,9 +1843,9 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
require!( require!(
matches!( matches!(
element_ty1.kind(), *element_ty1.kind(),
ty::RawPtr(p) ty::RawPtr(p_ty, p_mutbl)
if p.ty == in_elem && p.mutbl.is_mut() && p.ty.kind() == element_ty0.kind() if p_ty == in_elem && p_mutbl.is_mut() && p_ty.kind() == element_ty0.kind()
), ),
InvalidMonomorphization::ExpectedElementType { InvalidMonomorphization::ExpectedElementType {
span, span,
@ -2074,8 +2074,8 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
); );
match in_elem.kind() { match in_elem.kind() {
ty::RawPtr(p) => { ty::RawPtr(p_ty, _) => {
let metadata = p.ty.ptr_metadata_ty(bx.tcx, |ty| { let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
bx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), ty) bx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), ty)
}); });
require!( require!(
@ -2088,8 +2088,8 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
} }
} }
match out_elem.kind() { match out_elem.kind() {
ty::RawPtr(p) => { ty::RawPtr(p_ty, _) => {
let metadata = p.ty.ptr_metadata_ty(bx.tcx, |ty| { let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
bx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), ty) bx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), ty)
}); });
require!( require!(
@ -2120,7 +2120,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
); );
match in_elem.kind() { match in_elem.kind() {
ty::RawPtr(_) => {} ty::RawPtr(_, _) => {}
_ => { _ => {
return_error!(InvalidMonomorphization::ExpectedPointer { span, name, ty: in_elem }) return_error!(InvalidMonomorphization::ExpectedPointer { span, name, ty: in_elem })
} }
@ -2152,7 +2152,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
_ => return_error!(InvalidMonomorphization::ExpectedUsize { span, name, ty: in_elem }), _ => return_error!(InvalidMonomorphization::ExpectedUsize { span, name, ty: in_elem }),
} }
match out_elem.kind() { match out_elem.kind() {
ty::RawPtr(_) => {} ty::RawPtr(_, _) => {}
_ => { _ => {
return_error!(InvalidMonomorphization::ExpectedPointer { span, name, ty: out_elem }) return_error!(InvalidMonomorphization::ExpectedPointer { span, name, ty: out_elem })
} }

4
compiler/rustc_codegen_ssa/src/base.rs
View File

@ -193,8 +193,8 @@ pub fn unsize_ptr<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
) -> (Bx::Value, Bx::Value) { ) -> (Bx::Value, Bx::Value) {
debug!("unsize_ptr: {:?} => {:?}", src_ty, dst_ty); debug!("unsize_ptr: {:?} => {:?}", src_ty, dst_ty);
match (src_ty.kind(), dst_ty.kind()) { match (src_ty.kind(), dst_ty.kind()) {
(&ty::Ref(_, a, _), &ty::Ref(_, b, _) | &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) (&ty::Ref(_, a, _), &ty::Ref(_, b, _) | &ty::RawPtr(b, _))
| (&ty::RawPtr(ty::TypeAndMut { ty: a, .. }), &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) => { | (&ty::RawPtr(a, _), &ty::RawPtr(b, _)) => {
assert_eq!(bx.cx().type_is_sized(a), old_info.is_none()); assert_eq!(bx.cx().type_is_sized(a), old_info.is_none());
(src, unsized_info(bx, a, b, old_info)) (src, unsized_info(bx, a, b, old_info))
} }

2
compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
View File

@ -138,7 +138,7 @@ fn push_debuginfo_type_name<'tcx>(
output.push(')'); output.push(')');
} }
} }
ty::RawPtr(ty::TypeAndMut { ty: inner_type, mutbl }) => { ty::RawPtr(inner_type, mutbl) => {
if cpp_like_debuginfo { if cpp_like_debuginfo {
match mutbl { match mutbl {
Mutability::Not => output.push_str("ptr_const$<"), Mutability::Not => output.push_str("ptr_const$<"),

5
compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
View File

@ -414,10 +414,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
calculate_debuginfo_offset(bx, var.projection, base); calculate_debuginfo_offset(bx, var.projection, base);
// Create a variable which will be a pointer to the actual value // Create a variable which will be a pointer to the actual value
let ptr_ty = Ty::new_ptr( let ptr_ty = Ty::new_mut_ptr(bx.tcx(), place.layout.ty);
bx.tcx(),
ty::TypeAndMut { mutbl: mir::Mutability::Mut, ty: place.layout.ty },
);
let ptr_layout = bx.layout_of(ptr_ty); let ptr_layout = bx.layout_of(ptr_ty);
let alloca = PlaceRef::alloca(bx, ptr_layout); let alloca = PlaceRef::alloca(bx, ptr_layout);
bx.set_var_name(alloca.llval, &(var.name.to_string() + ".dbg.spill")); bx.set_var_name(alloca.llval, &(var.name.to_string() + ".dbg.spill"));

11
compiler/rustc_codegen_ssa/src/mir/rvalue.rs
View File

@ -572,20 +572,15 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
mir::Rvalue::Ref(_, bk, place) => { mir::Rvalue::Ref(_, bk, place) => {
let mk_ref = move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| { let mk_ref = move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| {
Ty::new_ref( Ty::new_ref(tcx, tcx.lifetimes.re_erased, ty, bk.to_mutbl_lossy())
tcx,
tcx.lifetimes.re_erased,
ty::TypeAndMut { ty, mutbl: bk.to_mutbl_lossy() },
)
}; };
self.codegen_place_to_pointer(bx, place, mk_ref) self.codegen_place_to_pointer(bx, place, mk_ref)
} }
mir::Rvalue::CopyForDeref(place) => self.codegen_operand(bx, &Operand::Copy(place)), mir::Rvalue::CopyForDeref(place) => self.codegen_operand(bx, &Operand::Copy(place)),
mir::Rvalue::AddressOf(mutability, place) => { mir::Rvalue::AddressOf(mutability, place) => {
let mk_ptr = move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| { let mk_ptr =
Ty::new_ptr(tcx, ty::TypeAndMut { ty, mutbl: mutability }) move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| Ty::new_ptr(tcx, ty, mutability);
};
self.codegen_place_to_pointer(bx, place, mk_ptr) self.codegen_place_to_pointer(bx, place, mk_ptr)
} }

4
compiler/rustc_const_eval/src/const_eval/valtrees.rs
View File

@ -98,7 +98,7 @@ fn const_to_valtree_inner<'tcx>(
Ok(ty::ValTree::Leaf(val.assert_int())) Ok(ty::ValTree::Leaf(val.assert_int()))
} }
ty::RawPtr(_) => { ty::RawPtr(_, _) => {
// Not all raw pointers are allowed, as we cannot properly test them for // Not all raw pointers are allowed, as we cannot properly test them for
// equality at compile-time (see `ptr_guaranteed_cmp`). // equality at compile-time (see `ptr_guaranteed_cmp`).
// However we allow those that are just integers in disguise. // However we allow those that are just integers in disguise.
@ -278,7 +278,7 @@ pub fn valtree_to_const_value<'tcx>(
assert!(valtree.unwrap_branch().is_empty()); assert!(valtree.unwrap_branch().is_empty());
mir::ConstValue::ZeroSized mir::ConstValue::ZeroSized
} }
ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Char | ty::RawPtr(_) => { ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Char | ty::RawPtr(_, _) => {
match valtree { match valtree {
ty::ValTree::Leaf(scalar_int) => mir::ConstValue::Scalar(Scalar::Int(scalar_int)), ty::ValTree::Leaf(scalar_int) => mir::ConstValue::Scalar(Scalar::Int(scalar_int)),
ty::ValTree::Branch(_) => bug!( ty::ValTree::Branch(_) => bug!(

12
compiler/rustc_const_eval/src/interpret/cast.rs
View File

@ -6,7 +6,7 @@ use rustc_middle::mir::interpret::{InterpResult, PointerArithmetic, Scalar};
use rustc_middle::mir::CastKind; use rustc_middle::mir::CastKind;
use rustc_middle::ty::adjustment::PointerCoercion; use rustc_middle::ty::adjustment::PointerCoercion;
use rustc_middle::ty::layout::{IntegerExt, LayoutOf, TyAndLayout}; use rustc_middle::ty::layout::{IntegerExt, LayoutOf, TyAndLayout};
use rustc_middle::ty::{self, FloatTy, Ty, TypeAndMut}; use rustc_middle::ty::{self, FloatTy, Ty};
use rustc_target::abi::Integer; use rustc_target::abi::Integer;
use rustc_type_ir::TyKind::*; use rustc_type_ir::TyKind::*;
@ -230,7 +230,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
src: &ImmTy<'tcx, M::Provenance>, src: &ImmTy<'tcx, M::Provenance>,
cast_to: TyAndLayout<'tcx>, cast_to: TyAndLayout<'tcx>,
) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> { ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
assert_matches!(src.layout.ty.kind(), ty::RawPtr(_) | ty::FnPtr(_)); assert_matches!(src.layout.ty.kind(), ty::RawPtr(_, _) | ty::FnPtr(_));
assert!(cast_to.ty.is_integral()); assert!(cast_to.ty.is_integral());
let scalar = src.to_scalar(); let scalar = src.to_scalar();
@ -248,7 +248,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
cast_to: TyAndLayout<'tcx>, cast_to: TyAndLayout<'tcx>,
) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> { ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
assert!(src.layout.ty.is_integral()); assert!(src.layout.ty.is_integral());
assert_matches!(cast_to.ty.kind(), ty::RawPtr(_)); assert_matches!(cast_to.ty.kind(), ty::RawPtr(_, _));
// First cast to usize. // First cast to usize.
let scalar = src.to_scalar(); let scalar = src.to_scalar();
@ -435,10 +435,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
) -> InterpResult<'tcx> { ) -> InterpResult<'tcx> {
trace!("Unsizing {:?} of type {} into {}", *src, src.layout.ty, cast_ty.ty); trace!("Unsizing {:?} of type {} into {}", *src, src.layout.ty, cast_ty.ty);
match (&src.layout.ty.kind(), &cast_ty.ty.kind()) { match (&src.layout.ty.kind(), &cast_ty.ty.kind()) {
(&ty::Ref(_, s, _), &ty::Ref(_, c, _) | &ty::RawPtr(TypeAndMut { ty: c, .. })) (&ty::Ref(_, s, _), &ty::Ref(_, c, _) | &ty::RawPtr(c, _))
| (&ty::RawPtr(TypeAndMut { ty: s, .. }), &ty::RawPtr(TypeAndMut { ty: c, .. })) => { | (&ty::RawPtr(s, _), &ty::RawPtr(c, _)) => self.unsize_into_ptr(src, dest, *s, *c),
self.unsize_into_ptr(src, dest, *s, *c)
}
(&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => { (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
assert_eq!(def_a, def_b); // implies same number of fields assert_eq!(def_a, def_b); // implies same number of fields

2
compiler/rustc_const_eval/src/interpret/intrinsics.rs
View File

@ -79,7 +79,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)

2
compiler/rustc_const_eval/src/interpret/terminator.rs
View File

@ -375,7 +375,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// We cannot use `builtin_deref` here since we need to reject `Box<T, MyAlloc>`. // We cannot use `builtin_deref` here since we need to reject `Box<T, MyAlloc>`.
Ok(Some(match ty.kind() { Ok(Some(match ty.kind() {
ty::Ref(_, ty, _) => *ty, ty::Ref(_, ty, _) => *ty,
ty::RawPtr(mt) => mt.ty, ty::RawPtr(ty, _) => *ty,
// We only accept `Box` with the default allocator. // We only accept `Box` with the default allocator.
_ if ty.is_box_global(*self.tcx) => ty.boxed_ty(), _ if ty.is_box_global(*self.tcx) => ty.boxed_ty(),
_ => return Ok(None), _ => return Ok(None),

2
compiler/rustc_const_eval/src/util/type_name.rs
View File

@ -33,7 +33,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnPtr(_) | ty::FnPtr(_)
| ty::Never | ty::Never

9
compiler/rustc_hir_analysis/src/check/check.rs
View File

@ -499,7 +499,7 @@ fn is_enum_of_nonnullable_ptr<'tcx>(
fn check_static_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) { fn check_static_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) {
if tcx.codegen_fn_attrs(def_id).import_linkage.is_some() { if tcx.codegen_fn_attrs(def_id).import_linkage.is_some() {
if match tcx.type_of(def_id).instantiate_identity().kind() { if match tcx.type_of(def_id).instantiate_identity().kind() {
ty::RawPtr(_) => false, ty::RawPtr(_, _) => false,
ty::Adt(adt_def, args) => !is_enum_of_nonnullable_ptr(tcx, *adt_def, *args), ty::Adt(adt_def, args) => !is_enum_of_nonnullable_ptr(tcx, *adt_def, *args),
_ => true, _ => true,
} { } {
@ -934,10 +934,13 @@ pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
// No: char, "fat" pointers, compound types // No: char, "fat" pointers, compound types
match e.kind() { match e.kind() {
ty::Param(_) => (), // pass struct<T>(T, T, T, T) through, let monomorphization catch errors ty::Param(_) => (), // pass struct<T>(T, T, T, T) through, let monomorphization catch errors
ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::RawPtr(_) => (), // struct(u8, u8, u8, u8) is ok ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::RawPtr(_, _) => (), // struct(u8, u8, u8, u8) is ok
ty::Array(t, _) if matches!(t.kind(), ty::Param(_)) => (), // pass struct<T>([T; N]) through, let monomorphization catch errors ty::Array(t, _) if matches!(t.kind(), ty::Param(_)) => (), // pass struct<T>([T; N]) through, let monomorphization catch errors
ty::Array(t, _clen) ty::Array(t, _clen)
if matches!(t.kind(), ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::RawPtr(_)) => if matches!(
t.kind(),
ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::RawPtr(_, _)
) =>
{ /* struct([f32; 4]) is ok */ } { /* struct([f32; 4]) is ok */ }
_ => { _ => {
struct_span_code_err!( struct_span_code_err!(

42
compiler/rustc_hir_analysis/src/check/intrinsic.rs
View File

@ -191,7 +191,7 @@ pub fn check_intrinsic_type(
ty::BoundRegion { var: ty::BoundVar::from_u32(2), kind: ty::BrEnv }, ty::BoundRegion { var: ty::BoundVar::from_u32(2), kind: ty::BrEnv },
); );
let va_list_ty = tcx.type_of(did).instantiate(tcx, &[region.into()]); let va_list_ty = tcx.type_of(did).instantiate(tcx, &[region.into()]);
(Ty::new_ref(tcx, env_region, ty::TypeAndMut { ty: va_list_ty, mutbl }), va_list_ty) (Ty::new_ref(tcx, env_region, va_list_ty, mutbl), va_list_ty)
}) })
}; };
@ -240,15 +240,9 @@ pub fn check_intrinsic_type(
sym::prefetch_read_data sym::prefetch_read_data
| sym::prefetch_write_data | sym::prefetch_write_data
| sym::prefetch_read_instruction | sym::prefetch_read_instruction
| sym::prefetch_write_instruction => ( | sym::prefetch_write_instruction => {
1, (1, 0, vec![Ty::new_imm_ptr(tcx, param(0)), tcx.types.i32], Ty::new_unit(tcx))
0, }
vec![
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }),
tcx.types.i32,
],
Ty::new_unit(tcx),
),
sym::needs_drop => (1, 0, vec![], tcx.types.bool), sym::needs_drop => (1, 0, vec![], tcx.types.bool),
sym::type_name => (1, 0, vec![], Ty::new_static_str(tcx)), sym::type_name => (1, 0, vec![], Ty::new_static_str(tcx)),
@ -257,28 +251,22 @@ pub fn check_intrinsic_type(
sym::arith_offset => ( sym::arith_offset => (
1, 1,
0, 0,
vec![ vec![Ty::new_imm_ptr(tcx, param(0)), tcx.types.isize],
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), Ty::new_imm_ptr(tcx, param(0)),
tcx.types.isize,
],
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }),
), ),
sym::ptr_mask => ( sym::ptr_mask => (
1, 1,
0, 0,
vec![ vec![Ty::new_imm_ptr(tcx, param(0)), tcx.types.usize],
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), Ty::new_imm_ptr(tcx, param(0)),
tcx.types.usize,
],
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }),
), ),
sym::copy | sym::copy_nonoverlapping => ( sym::copy | sym::copy_nonoverlapping => (
1, 1,
0, 0,
vec![ vec![
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), Ty::new_imm_ptr(tcx, param(0)),
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }), Ty::new_mut_ptr(tcx, param(0)),
tcx.types.usize, tcx.types.usize,
], ],
Ty::new_unit(tcx), Ty::new_unit(tcx),
@ -287,8 +275,8 @@ pub fn check_intrinsic_type(
1, 1,
0, 0,
vec![ vec![
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }), Ty::new_mut_ptr(tcx, param(0)),
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), Ty::new_imm_ptr(tcx, param(0)),
tcx.types.usize, tcx.types.usize,
], ],
Ty::new_unit(tcx), Ty::new_unit(tcx),
@ -300,11 +288,7 @@ pub fn check_intrinsic_type(
sym::write_bytes | sym::volatile_set_memory => ( sym::write_bytes | sym::volatile_set_memory => (
1, 1,
0, 0,
vec![ vec![Ty::new_mut_ptr(tcx, param(0)), tcx.types.u8, tcx.types.usize],
Ty::new_ptr(tcx, ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }),
tcx.types.u8,
tcx.types.usize,
],
Ty::new_unit(tcx), Ty::new_unit(tcx),
), ),

4
compiler/rustc_hir_analysis/src/check/intrinsicck.rs
View File

@ -62,9 +62,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
ty::Float(FloatTy::F32) => Some(InlineAsmType::F32), ty::Float(FloatTy::F32) => Some(InlineAsmType::F32),
ty::Float(FloatTy::F64) => Some(InlineAsmType::F64), ty::Float(FloatTy::F64) => Some(InlineAsmType::F64),
ty::FnPtr(_) => Some(asm_ty_isize), ty::FnPtr(_) => Some(asm_ty_isize),
ty::RawPtr(ty::TypeAndMut { ty, mutbl: _ }) if self.is_thin_ptr_ty(ty) => { ty::RawPtr(ty, _) if self.is_thin_ptr_ty(ty) => Some(asm_ty_isize),
Some(asm_ty_isize)
}
ty::Adt(adt, args) if adt.repr().simd() => { ty::Adt(adt, args) if adt.repr().simd() => {
let fields = &adt.non_enum_variant().fields; let fields = &adt.non_enum_variant().fields;
let elem_ty = fields[FieldIdx::from_u32(0)].ty(self.tcx, args); let elem_ty = fields[FieldIdx::from_u32(0)].ty(self.tcx, args);

2
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View File

@ -954,7 +954,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
hir_ty.span, hir_ty.span,
"using function pointers as const generic parameters is forbidden", "using function pointers as const generic parameters is forbidden",
), ),
ty::RawPtr(_) => tcx.dcx().struct_span_err( ty::RawPtr(_, _) => tcx.dcx().struct_span_err(
hir_ty.span, hir_ty.span,
"using raw pointers as const generic parameters is forbidden", "using raw pointers as const generic parameters is forbidden",
), ),

19
compiler/rustc_hir_analysis/src/coherence/builtin.rs
View File

@ -195,7 +195,7 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
{ {
Ok(()) Ok(())
} }
(&RawPtr(tm_a), &RawPtr(tm_b)) if tm_a.mutbl == tm_b.mutbl => Ok(()), (&RawPtr(_, a_mutbl), &RawPtr(_, b_mutbl)) if a_mutbl == b_mutbl => Ok(()),
(&Adt(def_a, args_a), &Adt(def_b, args_b)) if def_a.is_struct() && def_b.is_struct() => { (&Adt(def_a, args_a), &Adt(def_b, args_b)) if def_a.is_struct() && def_b.is_struct() => {
if def_a != def_b { if def_a != def_b {
let source_path = tcx.def_path_str(def_a.did()); let source_path = tcx.def_path_str(def_a.did());
@ -351,14 +351,17 @@ pub fn coerce_unsized_info<'tcx>(
check_mutbl(mt_a, mt_b, &|ty| Ty::new_imm_ref(tcx, r_b, ty)) check_mutbl(mt_a, mt_b, &|ty| Ty::new_imm_ref(tcx, r_b, ty))
} }
(&ty::Ref(_, ty_a, mutbl_a), &ty::RawPtr(mt_b)) => { (&ty::Ref(_, ty_a, mutbl_a), &ty::RawPtr(ty_b, mutbl_b)) => check_mutbl(
let mt_a = ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a }; ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a },
check_mutbl(mt_a, mt_b, &|ty| Ty::new_imm_ptr(tcx, ty)) ty::TypeAndMut { ty: ty_b, mutbl: mutbl_b },
} &|ty| Ty::new_imm_ptr(tcx, ty),
),
(&ty::RawPtr(mt_a), &ty::RawPtr(mt_b)) => { (&ty::RawPtr(ty_a, mutbl_a), &ty::RawPtr(ty_b, mutbl_b)) => check_mutbl(
check_mutbl(mt_a, mt_b, &|ty| Ty::new_imm_ptr(tcx, ty)) ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a },
} ty::TypeAndMut { ty: ty_b, mutbl: mutbl_b },
&|ty| Ty::new_imm_ptr(tcx, ty),
),
(&ty::Adt(def_a, args_a), &ty::Adt(def_b, args_b)) (&ty::Adt(def_a, args_a), &ty::Adt(def_b, args_b))
if def_a.is_struct() && def_b.is_struct() => if def_a.is_struct() && def_b.is_struct() =>

2
compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
View File

@ -162,7 +162,7 @@ impl<'tcx> InherentCollect<'tcx> {
| ty::Str | ty::Str
| ty::Array(..) | ty::Array(..)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::Never | ty::Never
| ty::FnPtr(_) | ty::FnPtr(_)

8
compiler/rustc_hir_analysis/src/coherence/orphan.rs
View File

@ -323,7 +323,7 @@ fn emit_orphan_check_error<'tcx>(
let is_foreign = let is_foreign =
!trait_ref.def_id.is_local() && matches!(is_target_ty, IsFirstInputType::No); !trait_ref.def_id.is_local() && matches!(is_target_ty, IsFirstInputType::No);
match &ty.kind() { match *ty.kind() {
ty::Slice(_) => { ty::Slice(_) => {
push_to_foreign_or_name( push_to_foreign_or_name(
is_foreign, is_foreign,
@ -354,14 +354,14 @@ fn emit_orphan_check_error<'tcx>(
ty::Alias(ty::Opaque, ..) => { ty::Alias(ty::Opaque, ..) => {
opaque.push(errors::OnlyCurrentTraitsOpaque { span }) opaque.push(errors::OnlyCurrentTraitsOpaque { span })
} }
ty::RawPtr(ptr_ty) => { ty::RawPtr(ptr_ty, mutbl) => {
if !self_ty.has_param() { if !self_ty.has_param() {
let mut_key = ptr_ty.mutbl.prefix_str(); let mut_key = mutbl.prefix_str();
sugg = Some(errors::OnlyCurrentTraitsPointerSugg { sugg = Some(errors::OnlyCurrentTraitsPointerSugg {
wrapper_span: self_ty_span, wrapper_span: self_ty_span,
struct_span: full_impl_span.shrink_to_lo(), struct_span: full_impl_span.shrink_to_lo(),
mut_key, mut_key,
ptr_ty: ptr_ty.ty, ptr_ty,
}); });
} }
pointer.push(errors::OnlyCurrentTraitsPointer { span, pointer: ty }); pointer.push(errors::OnlyCurrentTraitsPointer { span, pointer: ty });

6
compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
View File

@ -2299,14 +2299,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
self.lower_delegation_ty(*sig_id, *idx, hir_ty.span) self.lower_delegation_ty(*sig_id, *idx, hir_ty.span)
} }
hir::TyKind::Slice(ty) => Ty::new_slice(tcx, self.lower_ty(ty)), hir::TyKind::Slice(ty) => Ty::new_slice(tcx, self.lower_ty(ty)),
hir::TyKind::Ptr(mt) => { hir::TyKind::Ptr(mt) => Ty::new_ptr(tcx, self.lower_ty(mt.ty), mt.mutbl),
Ty::new_ptr(tcx, ty::TypeAndMut { ty: self.lower_ty(mt.ty), mutbl: mt.mutbl })
}
hir::TyKind::Ref(region, mt) => { hir::TyKind::Ref(region, mt) => {
let r = self.lower_lifetime(region, None); let r = self.lower_lifetime(region, None);
debug!(?r); debug!(?r);
let t = self.lower_ty_common(mt.ty, true, false); let t = self.lower_ty_common(mt.ty, true, false);
Ty::new_ref(tcx, r, ty::TypeAndMut { ty: t, mutbl: mt.mutbl }) Ty::new_ref(tcx, r, t, mt.mutbl)
} }
hir::TyKind::Never => tcx.types.never, hir::TyKind::Never => tcx.types.never,
hir::TyKind::Tup(fields) => { hir::TyKind::Tup(fields) => {

4
compiler/rustc_hir_analysis/src/variance/constraints.rs
View File

@ -253,8 +253,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
self.add_constraints_from_ty(current, typ, variance); self.add_constraints_from_ty(current, typ, variance);
} }
ty::RawPtr(ref mt) => { ty::RawPtr(ty, mutbl) => {
self.add_constraints_from_mt(current, mt, variance); self.add_constraints_from_mt(current, &ty::TypeAndMut { ty, mutbl }, variance);
} }
ty::Tuple(subtys) => { ty::Tuple(subtys) => {

31
compiler/rustc_hir_typeck/src/cast.rs
View File

@ -128,7 +128,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
| ty::Float(_) | ty::Float(_)
| ty::Array(..) | ty::Array(..)
| ty::CoroutineWitness(..) | ty::CoroutineWitness(..)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::FnDef(..) | ty::FnDef(..)
| ty::FnPtr(..) | ty::FnPtr(..)
@ -332,13 +332,9 @@ impl<'a, 'tcx> CastCheck<'tcx> {
let mut sugg = None; let mut sugg = None;
let mut sugg_mutref = false; let mut sugg_mutref = false;
if let ty::Ref(reg, cast_ty, mutbl) = *self.cast_ty.kind() { if let ty::Ref(reg, cast_ty, mutbl) = *self.cast_ty.kind() {
if let ty::RawPtr(TypeAndMut { ty: expr_ty, .. }) = *self.expr_ty.kind() if let ty::RawPtr(expr_ty, _) = *self.expr_ty.kind()
&& fcx.can_coerce( && fcx.can_coerce(
Ty::new_ref( Ty::new_ref(fcx.tcx, fcx.tcx.lifetimes.re_erased, expr_ty, mutbl),
fcx.tcx,
fcx.tcx.lifetimes.re_erased,
TypeAndMut { ty: expr_ty, mutbl },
),
self.cast_ty, self.cast_ty,
) )
{ {
@ -346,14 +342,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
} else if let ty::Ref(expr_reg, expr_ty, expr_mutbl) = *self.expr_ty.kind() } else if let ty::Ref(expr_reg, expr_ty, expr_mutbl) = *self.expr_ty.kind()
&& expr_mutbl == Mutability::Not && expr_mutbl == Mutability::Not
&& mutbl == Mutability::Mut && mutbl == Mutability::Mut
&& fcx.can_coerce( && fcx.can_coerce(Ty::new_mut_ref(fcx.tcx, expr_reg, expr_ty), self.cast_ty)
Ty::new_ref(
fcx.tcx,
expr_reg,
TypeAndMut { ty: expr_ty, mutbl: Mutability::Mut },
),
self.cast_ty,
)
{ {
sugg_mutref = true; sugg_mutref = true;
} }
@ -361,19 +350,15 @@ impl<'a, 'tcx> CastCheck<'tcx> {
if !sugg_mutref if !sugg_mutref
&& sugg == None && sugg == None
&& fcx.can_coerce( && fcx.can_coerce(
Ty::new_ref(fcx.tcx, reg, TypeAndMut { ty: self.expr_ty, mutbl }), Ty::new_ref(fcx.tcx, reg, self.expr_ty, mutbl),
self.cast_ty, self.cast_ty,
) )
{ {
sugg = Some((format!("&{}", mutbl.prefix_str()), false)); sugg = Some((format!("&{}", mutbl.prefix_str()), false));
} }
} else if let ty::RawPtr(TypeAndMut { mutbl, .. }) = *self.cast_ty.kind() } else if let ty::RawPtr(_, mutbl) = *self.cast_ty.kind()
&& fcx.can_coerce( && fcx.can_coerce(
Ty::new_ref( Ty::new_ref(fcx.tcx, fcx.tcx.lifetimes.re_erased, self.expr_ty, mutbl),
fcx.tcx,
fcx.tcx.lifetimes.re_erased,
TypeAndMut { ty: self.expr_ty, mutbl },
),
self.cast_ty, self.cast_ty,
) )
{ {
@ -868,7 +853,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
// from a region pointer to a vector. // from a region pointer to a vector.
// Coerce to a raw pointer so that we generate AddressOf in MIR. // Coerce to a raw pointer so that we generate AddressOf in MIR.
let array_ptr_type = Ty::new_ptr(fcx.tcx, m_expr); let array_ptr_type = Ty::new_ptr(fcx.tcx, m_expr.ty, m_expr.mutbl);
fcx.coerce(self.expr, self.expr_ty, array_ptr_type, AllowTwoPhase::No, None) fcx.coerce(self.expr, self.expr_ty, array_ptr_type, AllowTwoPhase::No, None)
.unwrap_or_else(|_| { .unwrap_or_else(|_| {
bug!( bug!(

26
compiler/rustc_hir_typeck/src/coercion.rs
View File

@ -55,7 +55,7 @@ use rustc_middle::ty::adjustment::{
use rustc_middle::ty::error::TypeError; use rustc_middle::ty::error::TypeError;
use rustc_middle::ty::relate::RelateResult; use rustc_middle::ty::relate::RelateResult;
use rustc_middle::ty::visit::TypeVisitableExt; use rustc_middle::ty::visit::TypeVisitableExt;
use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt, TypeAndMut}; use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt};
use rustc_session::parse::feature_err; use rustc_session::parse::feature_err;
use rustc_span::symbol::sym; use rustc_span::symbol::sym;
use rustc_span::DesugaringKind; use rustc_span::DesugaringKind;
@ -222,8 +222,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
// Examine the supertype and consider auto-borrowing. // Examine the supertype and consider auto-borrowing.
match *b.kind() { match *b.kind() {
ty::RawPtr(mt_b) => { ty::RawPtr(_, b_mutbl) => {
return self.coerce_unsafe_ptr(a, b, mt_b.mutbl); return self.coerce_unsafe_ptr(a, b, b_mutbl);
} }
ty::Ref(r_b, _, mutbl_b) => { ty::Ref(r_b, _, mutbl_b) => {
return self.coerce_borrowed_pointer(a, b, r_b, mutbl_b); return self.coerce_borrowed_pointer(a, b, r_b, mutbl_b);
@ -440,10 +440,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
let derefd_ty_a = Ty::new_ref( let derefd_ty_a = Ty::new_ref(
self.tcx, self.tcx,
r, r,
TypeAndMut { referent_ty,
ty: referent_ty, mutbl_b, // [1] above
mutbl: mutbl_b, // [1] above
},
); );
match self.unify(derefd_ty_a, b) { match self.unify(derefd_ty_a, b) {
Ok(ok) => { Ok(ok) => {
@ -558,22 +556,18 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
Adjustment { kind: Adjust::Deref(None), target: ty_a }, Adjustment { kind: Adjust::Deref(None), target: ty_a },
Adjustment { Adjustment {
kind: Adjust::Borrow(AutoBorrow::Ref(r_borrow, mutbl)), kind: Adjust::Borrow(AutoBorrow::Ref(r_borrow, mutbl)),
target: Ty::new_ref( target: Ty::new_ref(self.tcx, r_borrow, ty_a, mutbl_b),
self.tcx,
r_borrow,
ty::TypeAndMut { mutbl: mutbl_b, ty: ty_a },
),
}, },
)) ))
} }
(&ty::Ref(_, ty_a, mt_a), &ty::RawPtr(ty::TypeAndMut { mutbl: mt_b, .. })) => { (&ty::Ref(_, ty_a, mt_a), &ty::RawPtr(_, mt_b)) => {
coerce_mutbls(mt_a, mt_b)?; coerce_mutbls(mt_a, mt_b)?;
Some(( Some((
Adjustment { kind: Adjust::Deref(None), target: ty_a }, Adjustment { kind: Adjust::Deref(None), target: ty_a },
Adjustment { Adjustment {
kind: Adjust::Borrow(AutoBorrow::RawPtr(mt_b)), kind: Adjust::Borrow(AutoBorrow::RawPtr(mt_b)),
target: Ty::new_ptr(self.tcx, ty::TypeAndMut { mutbl: mt_b, ty: ty_a }), target: Ty::new_ptr(self.tcx, ty_a, mt_b),
}, },
)) ))
} }
@ -984,13 +978,13 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
let (is_ref, mt_a) = match *a.kind() { let (is_ref, mt_a) = match *a.kind() {
ty::Ref(_, ty, mutbl) => (true, ty::TypeAndMut { ty, mutbl }), ty::Ref(_, ty, mutbl) => (true, ty::TypeAndMut { ty, mutbl }),
ty::RawPtr(mt) => (false, mt), ty::RawPtr(ty, mutbl) => (false, ty::TypeAndMut { ty, mutbl }),
_ => return self.unify_and(a, b, identity), _ => return self.unify_and(a, b, identity),
}; };
coerce_mutbls(mt_a.mutbl, mutbl_b)?; coerce_mutbls(mt_a.mutbl, mutbl_b)?;
// Check that the types which they point at are compatible. // Check that the types which they point at are compatible.
let a_unsafe = Ty::new_ptr(self.tcx, ty::TypeAndMut { mutbl: mutbl_b, ty: mt_a.ty }); let a_unsafe = Ty::new_ptr(self.tcx, mt_a.ty, mutbl_b);
// Although references and unsafe ptrs have the same // Although references and unsafe ptrs have the same
// representation, we still register an Adjust::DerefRef so that // representation, we still register an Adjust::DerefRef so that
// regionck knows that the region for `a` must be valid here. // regionck knows that the region for `a` must be valid here.

15
compiler/rustc_hir_typeck/src/expr.rs
View File

@ -426,7 +426,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) -> Ty<'tcx> { ) -> Ty<'tcx> {
let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| { let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
match ty.kind() { match ty.kind() {
ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => { ty::Ref(_, ty, _) | ty::RawPtr(ty, _) => {
if oprnd.is_syntactic_place_expr() { if oprnd.is_syntactic_place_expr() {
// Places may legitimately have unsized types. // Places may legitimately have unsized types.
// For example, dereferences of a fat pointer and // For example, dereferences of a fat pointer and
@ -442,12 +442,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let ty = let ty =
self.check_expr_with_expectation_and_needs(oprnd, hint, Needs::maybe_mut_place(mutbl)); self.check_expr_with_expectation_and_needs(oprnd, hint, Needs::maybe_mut_place(mutbl));
let tm = ty::TypeAndMut { ty, mutbl };
match kind { match kind {
_ if tm.ty.references_error() => Ty::new_misc_error(self.tcx), _ if ty.references_error() => Ty::new_misc_error(self.tcx),
hir::BorrowKind::Raw => { hir::BorrowKind::Raw => {
self.check_named_place_expr(oprnd); self.check_named_place_expr(oprnd);
Ty::new_ptr(self.tcx, tm) Ty::new_ptr(self.tcx, ty, mutbl)
} }
hir::BorrowKind::Ref => { hir::BorrowKind::Ref => {
// Note: at this point, we cannot say what the best lifetime // Note: at this point, we cannot say what the best lifetime
@ -465,7 +464,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// whose address was taken can actually be made to live as long // whose address was taken can actually be made to live as long
// as it needs to live. // as it needs to live.
let region = self.next_region_var(infer::AddrOfRegion(expr.span)); let region = self.next_region_var(infer::AddrOfRegion(expr.span));
Ty::new_ref(self.tcx, region, tm) Ty::new_ref(self.tcx, region, ty, mutbl)
} }
} }
} }
@ -2686,8 +2685,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expr, expr,
Some(span), Some(span),
); );
} else if let ty::RawPtr(ty_and_mut) = expr_t.kind() } else if let ty::RawPtr(ptr_ty, _) = expr_t.kind()
&& let ty::Adt(adt_def, _) = ty_and_mut.ty.kind() && let ty::Adt(adt_def, _) = ptr_ty.kind()
&& let ExprKind::Field(base_expr, _) = expr.kind && let ExprKind::Field(base_expr, _) = expr.kind
&& adt_def.variants().len() == 1 && adt_def.variants().len() == 1
&& adt_def && adt_def
@ -3225,7 +3224,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.demand_coerce(expr, ty, fnptr_ty, None, AllowTwoPhase::No); self.demand_coerce(expr, ty, fnptr_ty, None, AllowTwoPhase::No);
} }
ty::Ref(_, base_ty, mutbl) => { ty::Ref(_, base_ty, mutbl) => {
let ptr_ty = Ty::new_ptr(self.tcx, ty::TypeAndMut { ty: base_ty, mutbl }); let ptr_ty = Ty::new_ptr(self.tcx, base_ty, mutbl);
self.demand_coerce(expr, ty, ptr_ty, None, AllowTwoPhase::No); self.demand_coerce(expr, ty, ptr_ty, None, AllowTwoPhase::No);
} }
_ => {} _ => {}

5
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -1394,9 +1394,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
arg: &hir::Expr<'tcx>, arg: &hir::Expr<'tcx>,
err: &mut Diag<'tcx>, err: &mut Diag<'tcx>,
) { ) {
if let ty::RawPtr(ty::TypeAndMut { mutbl: hir::Mutability::Mut, .. }) = expected_ty.kind() if let ty::RawPtr(_, hir::Mutability::Mut) = expected_ty.kind()
&& let ty::RawPtr(ty::TypeAndMut { mutbl: hir::Mutability::Not, .. }) = && let ty::RawPtr(_, hir::Mutability::Not) = provided_ty.kind()
provided_ty.kind()
&& let hir::ExprKind::Call(callee, _) = arg.kind && let hir::ExprKind::Call(callee, _) = arg.kind
&& let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = callee.kind && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = callee.kind
&& let Res::Def(_, def_id) = path.res && let Res::Def(_, def_id) = path.res

9
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View File

@ -7,7 +7,6 @@ use crate::hir::is_range_literal;
use crate::method::probe; use crate::method::probe;
use crate::method::probe::{IsSuggestion, Mode, ProbeScope}; use crate::method::probe::{IsSuggestion, Mode, ProbeScope};
use crate::rustc_middle::ty::Article; use crate::rustc_middle::ty::Article;
use crate::ty::TypeAndMut;
use core::cmp::min; use core::cmp::min;
use core::iter; use core::iter;
use rustc_ast::util::parser::{ExprPrecedence, PREC_POSTFIX}; use rustc_ast::util::parser::{ExprPrecedence, PREC_POSTFIX};
@ -1479,7 +1478,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expected_ty: Ty<'tcx>, expected_ty: Ty<'tcx>,
) -> bool { ) -> bool {
// Expected type needs to be a raw pointer. // Expected type needs to be a raw pointer.
let ty::RawPtr(ty::TypeAndMut { mutbl, .. }) = expected_ty.kind() else { let ty::RawPtr(_, mutbl) = expected_ty.kind() else {
return false; return false;
}; };
@ -2509,11 +2508,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
return make_sugg(sp, expr.span.lo()); return make_sugg(sp, expr.span.lo());
} }
} }
( (_, &ty::RawPtr(ty_b, mutbl_b), &ty::Ref(_, ty_a, mutbl_a)) => {
_,
&ty::RawPtr(TypeAndMut { ty: ty_b, mutbl: mutbl_b }),
&ty::Ref(_, ty_a, mutbl_a),
) => {
if let Some(steps) = self.deref_steps(ty_a, ty_b) if let Some(steps) = self.deref_steps(ty_a, ty_b)
// Only suggest valid if dereferencing needed. // Only suggest valid if dereferencing needed.
&& steps > 0 && steps > 0

8
compiler/rustc_hir_typeck/src/mem_categorization.rs
View File

@ -268,11 +268,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
adjustment::Adjust::Deref(overloaded) => { adjustment::Adjust::Deref(overloaded) => {
// Equivalent to *expr or something similar. // Equivalent to *expr or something similar.
let base = if let Some(deref) = overloaded { let base = if let Some(deref) = overloaded {
let ref_ty = Ty::new_ref( let ref_ty = Ty::new_ref(self.tcx(), deref.region, target, deref.mutbl);
self.tcx(),
deref.region,
ty::TypeAndMut { ty: target, mutbl: deref.mutbl },
);
self.cat_rvalue(expr.hir_id, ref_ty) self.cat_rvalue(expr.hir_id, ref_ty)
} else { } else {
previous()? previous()?
@ -479,7 +475,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
let ty::Ref(region, _, mutbl) = *base_ty.kind() else { let ty::Ref(region, _, mutbl) = *base_ty.kind() else {
span_bug!(expr.span, "cat_overloaded_place: base is not a reference"); span_bug!(expr.span, "cat_overloaded_place: base is not a reference");
}; };
let ref_ty = Ty::new_ref(self.tcx(), region, ty::TypeAndMut { ty: place_ty, mutbl }); let ref_ty = Ty::new_ref(self.tcx(), region, place_ty, mutbl);
let base = self.cat_rvalue(expr.hir_id, ref_ty); let base = self.cat_rvalue(expr.hir_id, ref_ty);
self.cat_deref(expr, base) self.cat_deref(expr, base)

12
compiler/rustc_hir_typeck/src/method/confirm.rs
View File

@ -188,7 +188,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
// Type we're wrapping in a reference, used later for unsizing // Type we're wrapping in a reference, used later for unsizing
let base_ty = target; let base_ty = target;
target = Ty::new_ref(self.tcx, region, ty::TypeAndMut { mutbl, ty: target }); target = Ty::new_ref(self.tcx, region, target, mutbl);
// Method call receivers are the primary use case // Method call receivers are the primary use case
// for two-phase borrows. // for two-phase borrows.
@ -208,11 +208,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
base_ty base_ty
) )
}; };
target = Ty::new_ref( target = Ty::new_ref(self.tcx, region, unsized_ty, mutbl.into());
self.tcx,
region,
ty::TypeAndMut { mutbl: mutbl.into(), ty: unsized_ty },
);
adjustments.push(Adjustment { adjustments.push(Adjustment {
kind: Adjust::Pointer(PointerCoercion::Unsize), kind: Adjust::Pointer(PointerCoercion::Unsize),
target, target,
@ -221,9 +217,9 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
} }
Some(probe::AutorefOrPtrAdjustment::ToConstPtr) => { Some(probe::AutorefOrPtrAdjustment::ToConstPtr) => {
target = match target.kind() { target = match target.kind() {
&ty::RawPtr(ty::TypeAndMut { ty, mutbl }) => { &ty::RawPtr(ty, mutbl) => {
assert!(mutbl.is_mut()); assert!(mutbl.is_mut());
Ty::new_ptr(self.tcx, ty::TypeAndMut { mutbl: hir::Mutability::Not, ty }) Ty::new_imm_ptr(self.tcx, ty)
} }
other => panic!("Cannot adjust receiver type {other:?} to const ptr"), other => panic!("Cannot adjust receiver type {other:?} to const ptr"),
}; };

6
compiler/rustc_hir_typeck/src/method/mod.rs
View File

@ -200,11 +200,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let Some(span) = result.illegal_sized_bound { if let Some(span) = result.illegal_sized_bound {
let mut needs_mut = false; let mut needs_mut = false;
if let ty::Ref(region, t_type, mutability) = self_ty.kind() { if let ty::Ref(region, t_type, mutability) = self_ty.kind() {
let trait_type = Ty::new_ref( let trait_type = Ty::new_ref(self.tcx, *region, *t_type, mutability.invert());
self.tcx,
*region,
ty::TypeAndMut { ty: *t_type, mutbl: mutability.invert() },
);
// We probe again to see if there might be a borrow mutability discrepancy. // We probe again to see if there might be a borrow mutability discrepancy.
match self.lookup_probe( match self.lookup_probe(
segment.ident, segment.ident,

11
compiler/rustc_hir_typeck/src/method/probe.rs
View File

@ -528,7 +528,7 @@ fn method_autoderef_steps<'tcx>(
from_unsafe_deref: reached_raw_pointer, from_unsafe_deref: reached_raw_pointer,
unsize: false, unsize: false,
}; };
if let ty::RawPtr(_) = ty.kind() { if let ty::RawPtr(_, _) = ty.kind() {
// all the subsequent steps will be from_unsafe_deref // all the subsequent steps will be from_unsafe_deref
reached_raw_pointer = true; reached_raw_pointer = true;
} }
@ -696,7 +696,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
| ty::Str | ty::Str
| ty::Array(..) | ty::Array(..)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::Never | ty::Never
| ty::Tuple(..) => self.assemble_inherent_candidates_for_incoherent_ty(raw_self_ty), | ty::Tuple(..) => self.assemble_inherent_candidates_for_incoherent_ty(raw_self_ty),
@ -1213,7 +1213,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
// In general, during probing we erase regions. // In general, during probing we erase regions.
let region = tcx.lifetimes.re_erased; let region = tcx.lifetimes.re_erased;
let autoref_ty = Ty::new_ref(tcx, region, ty::TypeAndMut { ty: self_ty, mutbl }); let autoref_ty = Ty::new_ref(tcx, region, self_ty, mutbl);
self.pick_method(autoref_ty, unstable_candidates).map(|r| { self.pick_method(autoref_ty, unstable_candidates).map(|r| {
r.map(|mut pick| { r.map(|mut pick| {
pick.autoderefs = step.autoderefs; pick.autoderefs = step.autoderefs;
@ -1238,12 +1238,11 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
return None; return None;
} }
let &ty::RawPtr(ty::TypeAndMut { ty, mutbl: hir::Mutability::Mut }) = self_ty.kind() else { let &ty::RawPtr(ty, hir::Mutability::Mut) = self_ty.kind() else {
return None; return None;
}; };
let const_self_ty = ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }; let const_ptr_ty = Ty::new_imm_ptr(self.tcx, ty);
let const_ptr_ty = Ty::new_ptr(self.tcx, const_self_ty);
self.pick_method(const_ptr_ty, unstable_candidates).map(|r| { self.pick_method(const_ptr_ty, unstable_candidates).map(|r| {
r.map(|mut pick| { r.map(|mut pick| {
pick.autoderefs = step.autoderefs; pick.autoderefs = step.autoderefs;

9
compiler/rustc_hir_typeck/src/method/suggest.rs
View File

@ -304,11 +304,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} }
if let ty::Ref(region, t_type, mutability) = rcvr_ty.kind() { if let ty::Ref(region, t_type, mutability) = rcvr_ty.kind() {
if needs_mut { if needs_mut {
let trait_type = Ty::new_ref( let trait_type =
self.tcx, Ty::new_ref(self.tcx, *region, *t_type, mutability.invert());
*region,
ty::TypeAndMut { ty: *t_type, mutbl: mutability.invert() },
);
let msg = format!("you need `{trait_type}` instead of `{rcvr_ty}`"); let msg = format!("you need `{trait_type}` instead of `{rcvr_ty}`");
let mut kind = &self_expr.kind; let mut kind = &self_expr.kind;
while let hir::ExprKind::AddrOf(_, _, expr) while let hir::ExprKind::AddrOf(_, _, expr)
@ -533,7 +530,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Applicability::MachineApplicable, Applicability::MachineApplicable,
); );
} }
if let ty::RawPtr(_) = &rcvr_ty.kind() { if let ty::RawPtr(_, _) = &rcvr_ty.kind() {
err.note( err.note(
"try using `<*const T>::as_ref()` to get a reference to the \ "try using `<*const T>::as_ref()` to get a reference to the \
type behind the pointer: https://doc.rust-lang.org/std/\ type behind the pointer: https://doc.rust-lang.org/std/\

14
compiler/rustc_hir_typeck/src/op.rs
View File

@ -508,11 +508,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
suggest_deref_binop(&mut err, *lhs_deref_ty); suggest_deref_binop(&mut err, *lhs_deref_ty);
} else { } else {
let lhs_inv_mutbl = mutbl.invert(); let lhs_inv_mutbl = mutbl.invert();
let lhs_inv_mutbl_ty = Ty::new_ref( let lhs_inv_mutbl_ty =
self.tcx, Ty::new_ref(self.tcx, *region, *lhs_deref_ty, lhs_inv_mutbl);
*region,
ty::TypeAndMut { ty: *lhs_deref_ty, mutbl: lhs_inv_mutbl },
);
suggest_different_borrow( suggest_different_borrow(
&mut err, &mut err,
@ -524,11 +521,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let Ref(region, rhs_deref_ty, mutbl) = rhs_ty.kind() { if let Ref(region, rhs_deref_ty, mutbl) = rhs_ty.kind() {
let rhs_inv_mutbl = mutbl.invert(); let rhs_inv_mutbl = mutbl.invert();
let rhs_inv_mutbl_ty = Ty::new_ref( let rhs_inv_mutbl_ty =
self.tcx, Ty::new_ref(self.tcx, *region, *rhs_deref_ty, rhs_inv_mutbl);
*region,
ty::TypeAndMut { ty: *rhs_deref_ty, mutbl: rhs_inv_mutbl },
);
suggest_different_borrow( suggest_different_borrow(
&mut err, &mut err,

3
compiler/rustc_hir_typeck/src/pat.rs
View File

@ -2057,8 +2057,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// Create a reference type with a fresh region variable. /// Create a reference type with a fresh region variable.
fn new_ref_ty(&self, span: Span, mutbl: hir::Mutability, ty: Ty<'tcx>) -> Ty<'tcx> { fn new_ref_ty(&self, span: Span, mutbl: hir::Mutability, ty: Ty<'tcx>) -> Ty<'tcx> {
let region = self.next_region_var(infer::PatternRegion(span)); let region = self.next_region_var(infer::PatternRegion(span));
let mt = ty::TypeAndMut { ty, mutbl }; Ty::new_ref(self.tcx, region, ty, mutbl)
Ty::new_ref(self.tcx, region, mt)
} }
fn try_resolve_slice_ty_to_array_ty( fn try_resolve_slice_ty_to_array_ty(

12
compiler/rustc_hir_typeck/src/place_op.rs
View File

@ -162,11 +162,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let ty::Ref(region, _, hir::Mutability::Not) = method.sig.inputs()[0].kind() { if let ty::Ref(region, _, hir::Mutability::Not) = method.sig.inputs()[0].kind() {
adjustments.push(Adjustment { adjustments.push(Adjustment {
kind: Adjust::Borrow(AutoBorrow::Ref(*region, AutoBorrowMutability::Not)), kind: Adjust::Borrow(AutoBorrow::Ref(*region, AutoBorrowMutability::Not)),
target: Ty::new_ref( target: Ty::new_imm_ref(self.tcx, *region, adjusted_ty),
self.tcx,
*region,
ty::TypeAndMut { mutbl: hir::Mutability::Not, ty: adjusted_ty },
),
}); });
} else { } else {
span_bug!(expr.span, "input to index is not a ref?"); span_bug!(expr.span, "input to index is not a ref?");
@ -400,11 +396,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
allow_two_phase_borrow: AllowTwoPhase::No, allow_two_phase_borrow: AllowTwoPhase::No,
}; };
adjustment.kind = Adjust::Borrow(AutoBorrow::Ref(*region, mutbl)); adjustment.kind = Adjust::Borrow(AutoBorrow::Ref(*region, mutbl));
adjustment.target = Ty::new_ref( adjustment.target = Ty::new_ref(self.tcx, *region, source, mutbl.into());
self.tcx,
*region,
ty::TypeAndMut { ty: source, mutbl: mutbl.into() },
);
} }
source = adjustment.target; source = adjustment.target;
} }

10
compiler/rustc_hir_typeck/src/upvar.rs
View File

@ -1719,7 +1719,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
for pointer_ty in place.deref_tys() { for pointer_ty in place.deref_tys() {
match pointer_ty.kind() { match pointer_ty.kind() {
// We don't capture derefs of raw ptrs // We don't capture derefs of raw ptrs
ty::RawPtr(_) => unreachable!(), ty::RawPtr(_, _) => unreachable!(),
// Dereferencing a mut-ref allows us to mut the Place if we don't deref // Dereferencing a mut-ref allows us to mut the Place if we don't deref
// an immut-ref after on top of this. // an immut-ref after on top of this.
@ -1780,11 +1780,9 @@ fn apply_capture_kind_on_capture_ty<'tcx>(
) -> Ty<'tcx> { ) -> Ty<'tcx> {
match capture_kind { match capture_kind {
ty::UpvarCapture::ByValue => ty, ty::UpvarCapture::ByValue => ty,
ty::UpvarCapture::ByRef(kind) => Ty::new_ref( ty::UpvarCapture::ByRef(kind) => {
tcx, Ty::new_ref(tcx, region.unwrap(), ty, kind.to_mutbl_lossy())
region.unwrap(), }
ty::TypeAndMut { ty: ty, mutbl: kind.to_mutbl_lossy() },
),
} }
} }

4
compiler/rustc_lint/src/builtin.rs
View File

@ -2477,7 +2477,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
Adt(..) if ty.is_box() => Some("`Box` must be non-null".into()), Adt(..) if ty.is_box() => Some("`Box` must be non-null".into()),
FnPtr(..) => Some("function pointers must be non-null".into()), FnPtr(..) => Some("function pointers must be non-null".into()),
Never => Some("the `!` type has no valid value".into()), Never => Some("the `!` type has no valid value".into()),
RawPtr(tm) if matches!(tm.ty.kind(), Dynamic(..)) => RawPtr(ty, _) if matches!(ty.kind(), Dynamic(..)) =>
// raw ptr to dyn Trait // raw ptr to dyn Trait
{ {
Some("the vtable of a wide raw pointer must be non-null".into()) Some("the vtable of a wide raw pointer must be non-null".into())
@ -2493,7 +2493,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
Some("integers must be initialized".into()) Some("integers must be initialized".into())
} }
Float(_) if init == InitKind::Uninit => Some("floats must be initialized".into()), Float(_) if init == InitKind::Uninit => Some("floats must be initialized".into()),
RawPtr(_) if init == InitKind::Uninit => { RawPtr(_, _) if init == InitKind::Uninit => {
Some("raw pointers must be initialized".into()) Some("raw pointers must be initialized".into())
} }
// Recurse and checks for some compound types. (but not unions) // Recurse and checks for some compound types. (but not unions)

6
compiler/rustc_lint/src/foreign_modules.rs
View File

@ -322,10 +322,10 @@ fn structurally_same_type_impl<'tcx>(
(Slice(a_ty), Slice(b_ty)) => { (Slice(a_ty), Slice(b_ty)) => {
structurally_same_type_impl(seen_types, tcx, param_env, *a_ty, *b_ty, ckind) structurally_same_type_impl(seen_types, tcx, param_env, *a_ty, *b_ty, ckind)
} }
(RawPtr(a_tymut), RawPtr(b_tymut)) => { (RawPtr(a_ty, a_mutbl), RawPtr(b_ty, b_mutbl)) => {
a_tymut.mutbl == b_tymut.mutbl a_mutbl == b_mutbl
&& structurally_same_type_impl( && structurally_same_type_impl(
seen_types, tcx, param_env, a_tymut.ty, b_tymut.ty, ckind, seen_types, tcx, param_env, *a_ty, *b_ty, ckind,
) )
} }
(Ref(_a_region, a_ty, a_mut), Ref(_b_region, b_ty, b_mut)) => { (Ref(_a_region, a_ty, a_mut), Ref(_b_region, b_ty, b_mut)) => {

6
compiler/rustc_lint/src/reference_casting.rs
View File

@ -1,7 +1,7 @@
use rustc_ast::Mutability; use rustc_ast::Mutability;
use rustc_hir::{Expr, ExprKind, UnOp}; use rustc_hir::{Expr, ExprKind, UnOp};
use rustc_middle::ty::layout::LayoutOf as _; use rustc_middle::ty::layout::LayoutOf as _;
use rustc_middle::ty::{self, layout::TyAndLayout, TypeAndMut}; use rustc_middle::ty::{self, layout::TyAndLayout};
use rustc_span::sym; use rustc_span::sym;
use crate::{lints::InvalidReferenceCastingDiag, LateContext, LateLintPass, LintContext}; use crate::{lints::InvalidReferenceCastingDiag, LateContext, LateLintPass, LintContext};
@ -153,7 +153,7 @@ fn is_cast_from_ref_to_mut_ptr<'tcx>(
let end_ty = cx.typeck_results().node_type(orig_expr.hir_id); let end_ty = cx.typeck_results().node_type(orig_expr.hir_id);
// Bail out early if the end type is **not** a mutable pointer. // Bail out early if the end type is **not** a mutable pointer.
if !matches!(end_ty.kind(), ty::RawPtr(TypeAndMut { ty: _, mutbl: Mutability::Mut })) { if !matches!(end_ty.kind(), ty::RawPtr(_, Mutability::Mut)) {
return None; return None;
} }
@ -183,7 +183,7 @@ fn is_cast_to_bigger_memory_layout<'tcx>(
) -> Option<(TyAndLayout<'tcx>, TyAndLayout<'tcx>, Expr<'tcx>)> { ) -> Option<(TyAndLayout<'tcx>, TyAndLayout<'tcx>, Expr<'tcx>)> {
let end_ty = cx.typeck_results().node_type(orig_expr.hir_id); let end_ty = cx.typeck_results().node_type(orig_expr.hir_id);
let ty::RawPtr(TypeAndMut { ty: inner_end_ty, mutbl: _ }) = end_ty.kind() else { let ty::RawPtr(inner_end_ty, _) = end_ty.kind() else {
return None; return None;
}; };

16
compiler/rustc_lint/src/types.rs
View File

@ -18,10 +18,10 @@ use rustc_errors::DiagMessage;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::{is_range_literal, Expr, ExprKind, Node}; use rustc_hir::{is_range_literal, Expr, ExprKind, Node};
use rustc_middle::ty::layout::{IntegerExt, LayoutOf, SizeSkeleton}; use rustc_middle::ty::layout::{IntegerExt, LayoutOf, SizeSkeleton};
use rustc_middle::ty::GenericArgsRef;
use rustc_middle::ty::{ use rustc_middle::ty::{
self, AdtKind, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, self, AdtKind, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
}; };
use rustc_middle::ty::{GenericArgsRef, TypeAndMut};
use rustc_span::def_id::LocalDefId; use rustc_span::def_id::LocalDefId;
use rustc_span::source_map; use rustc_span::source_map;
use rustc_span::symbol::sym; use rustc_span::symbol::sym;
@ -673,7 +673,7 @@ fn lint_wide_pointer<'tcx>(
refs += 1; refs += 1;
} }
match ty.kind() { match ty.kind() {
ty::RawPtr(TypeAndMut { mutbl: _, ty }) => (!ty.is_sized(cx.tcx, cx.param_env)) ty::RawPtr(ty, _) => (!ty.is_sized(cx.tcx, cx.param_env))
.then(|| (refs, matches!(ty.kind(), ty::Dynamic(_, _, ty::Dyn)))), .then(|| (refs, matches!(ty.kind(), ty::Dynamic(_, _, ty::Dyn)))),
_ => None, _ => None,
} }
@ -1046,10 +1046,10 @@ fn get_nullable_type<'tcx>(
} }
ty::Int(ty) => Ty::new_int(tcx, ty), ty::Int(ty) => Ty::new_int(tcx, ty),
ty::Uint(ty) => Ty::new_uint(tcx, ty), ty::Uint(ty) => Ty::new_uint(tcx, ty),
ty::RawPtr(ty_mut) => Ty::new_ptr(tcx, ty_mut), ty::RawPtr(ty, mutbl) => Ty::new_ptr(tcx, ty, mutbl),
// As these types are always non-null, the nullable equivalent of // As these types are always non-null, the nullable equivalent of
// `Option<T>` of these types are their raw pointer counterparts. // `Option<T>` of these types are their raw pointer counterparts.
ty::Ref(_region, ty, mutbl) => Ty::new_ptr(tcx, ty::TypeAndMut { ty, mutbl }), ty::Ref(_region, ty, mutbl) => Ty::new_ptr(tcx, ty, mutbl),
// There is no nullable equivalent for Rust's function pointers, // There is no nullable equivalent for Rust's function pointers,
// you must use an `Option<fn(..) -> _>` to represent it. // you must use an `Option<fn(..) -> _>` to represent it.
ty::FnPtr(..) => ty, ty::FnPtr(..) => ty,
@ -1374,7 +1374,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
help: Some(fluent::lint_improper_ctypes_tuple_help), help: Some(fluent::lint_improper_ctypes_tuple_help),
}, },
ty::RawPtr(ty::TypeAndMut { ty, .. }) | ty::Ref(_, ty, _) ty::RawPtr(ty, _) | ty::Ref(_, ty, _)
if { if {
matches!(self.mode, CItemKind::Definition) matches!(self.mode, CItemKind::Definition)
&& ty.is_sized(self.cx.tcx, self.cx.param_env) && ty.is_sized(self.cx.tcx, self.cx.param_env)
@ -1383,7 +1383,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
FfiSafe FfiSafe
} }
ty::RawPtr(ty::TypeAndMut { ty, .. }) ty::RawPtr(ty, _)
if match ty.kind() { if match ty.kind() {
ty::Tuple(tuple) => tuple.is_empty(), ty::Tuple(tuple) => tuple.is_empty(),
_ => false, _ => false,
@ -1392,9 +1392,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
FfiSafe FfiSafe
} }
ty::RawPtr(ty::TypeAndMut { ty, .. }) | ty::Ref(_, ty, _) => { ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.check_type_for_ffi(cache, ty),
self.check_type_for_ffi(cache, ty)
}
ty::Array(inner_ty, _) => self.check_type_for_ffi(cache, inner_ty), ty::Array(inner_ty, _) => self.check_type_for_ffi(cache, inner_ty),

4
compiler/rustc_middle/src/mir/tcx.rs
View File

@ -170,11 +170,11 @@ impl<'tcx> Rvalue<'tcx> {
Rvalue::ThreadLocalRef(did) => tcx.thread_local_ptr_ty(did), Rvalue::ThreadLocalRef(did) => tcx.thread_local_ptr_ty(did),
Rvalue::Ref(reg, bk, ref place) => { Rvalue::Ref(reg, bk, ref place) => {
let place_ty = place.ty(local_decls, tcx).ty; let place_ty = place.ty(local_decls, tcx).ty;
Ty::new_ref(tcx, reg, ty::TypeAndMut { ty: place_ty, mutbl: bk.to_mutbl_lossy() }) Ty::new_ref(tcx, reg, place_ty, bk.to_mutbl_lossy())
} }
Rvalue::AddressOf(mutability, ref place) => { Rvalue::AddressOf(mutability, ref place) => {
let place_ty = place.ty(local_decls, tcx).ty; let place_ty = place.ty(local_decls, tcx).ty;
Ty::new_ptr(tcx, ty::TypeAndMut { ty: place_ty, mutbl: mutability }) Ty::new_ptr(tcx, place_ty, mutability)
} }
Rvalue::Len(..) => tcx.types.usize, Rvalue::Len(..) => tcx.types.usize,
Rvalue::Cast(.., ty) => ty, Rvalue::Cast(.., ty) => ty,

2
compiler/rustc_middle/src/ty/cast.rs
View File

@ -69,7 +69,7 @@ impl<'tcx> CastTy<'tcx> {
ty::Uint(u) => Some(CastTy::Int(IntTy::U(u))), ty::Uint(u) => Some(CastTy::Int(IntTy::U(u))),
ty::Float(_) => Some(CastTy::Float), ty::Float(_) => Some(CastTy::Float),
ty::Adt(d, _) if d.is_enum() && d.is_payloadfree() => Some(CastTy::Int(IntTy::CEnum)), ty::Adt(d, _) if d.is_enum() && d.is_payloadfree() => Some(CastTy::Int(IntTy::CEnum)),
ty::RawPtr(mt) => Some(CastTy::Ptr(mt)), ty::RawPtr(ty, mutbl) => Some(CastTy::Ptr(ty::TypeAndMut { ty, mutbl })),
ty::FnPtr(..) => Some(CastTy::FnPtr), ty::FnPtr(..) => Some(CastTy::FnPtr),
ty::Dynamic(_, _, ty::DynStar) => Some(CastTy::DynStar), ty::Dynamic(_, _, ty::DynStar) => Some(CastTy::DynStar),
_ => None, _ => None,

2
compiler/rustc_middle/src/ty/error.rs
View File

@ -286,7 +286,7 @@ impl<'tcx> Ty<'tcx> {
ty::Foreign(_) => "extern type".into(), ty::Foreign(_) => "extern type".into(),
ty::Array(..) => "array".into(), ty::Array(..) => "array".into(),
ty::Slice(_) => "slice".into(), ty::Slice(_) => "slice".into(),
ty::RawPtr(_) => "raw pointer".into(), ty::RawPtr(_, _) => "raw pointer".into(),
ty::Ref(.., mutbl) => match mutbl { ty::Ref(.., mutbl) => match mutbl {
hir::Mutability::Mut => "mutable reference", hir::Mutability::Mut => "mutable reference",
_ => "reference", _ => "reference",

8
compiler/rustc_middle/src/ty/fast_reject.rs
View File

@ -120,7 +120,7 @@ pub fn simplify_type<'tcx>(
ty::Str => Some(SimplifiedType::Str), ty::Str => Some(SimplifiedType::Str),
ty::Array(..) => Some(SimplifiedType::Array), ty::Array(..) => Some(SimplifiedType::Array),
ty::Slice(..) => Some(SimplifiedType::Slice), ty::Slice(..) => Some(SimplifiedType::Slice),
ty::RawPtr(ptr) => Some(SimplifiedType::Ptr(ptr.mutbl)), ty::RawPtr(_, mutbl) => Some(SimplifiedType::Ptr(mutbl)),
ty::Dynamic(trait_info, ..) => match trait_info.principal_def_id() { ty::Dynamic(trait_info, ..) => match trait_info.principal_def_id() {
Some(principal_def_id) if !tcx.trait_is_auto(principal_def_id) => { Some(principal_def_id) if !tcx.trait_is_auto(principal_def_id) => {
Some(SimplifiedType::Trait(principal_def_id)) Some(SimplifiedType::Trait(principal_def_id))
@ -286,8 +286,10 @@ impl DeepRejectCtxt {
} }
_ => false, _ => false,
}, },
ty::RawPtr(obl) => match k { ty::RawPtr(obl_ty, obl_mutbl) => match *k {
ty::RawPtr(imp) => obl.mutbl == imp.mutbl && self.types_may_unify(obl.ty, imp.ty), ty::RawPtr(imp_ty, imp_mutbl) => {
obl_mutbl == imp_mutbl && self.types_may_unify(obl_ty, imp_ty)
}
_ => false, _ => false,
}, },
ty::Dynamic(obl_preds, ..) => { ty::Dynamic(obl_preds, ..) => {

4
compiler/rustc_middle/src/ty/flags.rs
View File

@ -211,8 +211,8 @@ impl FlagComputation {
&ty::Slice(tt) => self.add_ty(tt), &ty::Slice(tt) => self.add_ty(tt),
ty::RawPtr(m) => { &ty::RawPtr(ty, _) => {
self.add_ty(m.ty); self.add_ty(ty);
} }
&ty::Ref(r, ty, _) => { &ty::Ref(r, ty, _) => {

8
compiler/rustc_middle/src/ty/layout.rs
View File

@ -328,7 +328,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
}; };
match *ty.kind() { match *ty.kind() {
ty::Ref(_, pointee, _) | ty::RawPtr(ty::TypeAndMut { ty: pointee, .. }) => { ty::Ref(_, pointee, _) | ty::RawPtr(pointee, _) => {
let non_zero = !ty.is_unsafe_ptr(); let non_zero = !ty.is_unsafe_ptr();
let tail = tcx.struct_tail_erasing_lifetimes(pointee, param_env); let tail = tcx.struct_tail_erasing_lifetimes(pointee, param_env);
match tail.kind() { match tail.kind() {
@ -742,7 +742,7 @@ where
} }
// Potentially-fat pointers. // Potentially-fat pointers.
ty::Ref(_, pointee, _) | ty::RawPtr(ty::TypeAndMut { ty: pointee, .. }) => { ty::Ref(_, pointee, _) | ty::RawPtr(pointee, _) => {
assert!(i < this.fields.count()); assert!(i < this.fields.count());
// Reuse the fat `*T` type as its own thin pointer data field. // Reuse the fat `*T` type as its own thin pointer data field.
@ -920,8 +920,8 @@ where
let param_env = cx.param_env(); let param_env = cx.param_env();
let pointee_info = match *this.ty.kind() { let pointee_info = match *this.ty.kind() {
ty::RawPtr(mt) if offset.bytes() == 0 => { ty::RawPtr(p_ty, _) if offset.bytes() == 0 => {
tcx.layout_of(param_env.and(mt.ty)).ok().map(|layout| PointeeInfo { tcx.layout_of(param_env.and(p_ty)).ok().map(|layout| PointeeInfo {
size: layout.size, size: layout.size,
align: layout.align.abi, align: layout.align.abi,
safe: None, safe: None,

2
compiler/rustc_middle/src/ty/print/mod.rs
View File

@ -263,7 +263,7 @@ fn characteristic_def_id_of_type_cached<'a>(
characteristic_def_id_of_type_cached(subty, visited) characteristic_def_id_of_type_cached(subty, visited)
} }
ty::RawPtr(mt) => characteristic_def_id_of_type_cached(mt.ty, visited), ty::RawPtr(ty, _) => characteristic_def_id_of_type_cached(ty, visited),
ty::Ref(_, ty, _) => characteristic_def_id_of_type_cached(ty, visited), ty::Ref(_, ty, _) => characteristic_def_id_of_type_cached(ty, visited),

8
compiler/rustc_middle/src/ty/print/pretty.rs
View File

@ -667,15 +667,15 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
ty::Int(t) => p!(write("{}", t.name_str())), ty::Int(t) => p!(write("{}", t.name_str())),
ty::Uint(t) => p!(write("{}", t.name_str())), ty::Uint(t) => p!(write("{}", t.name_str())),
ty::Float(t) => p!(write("{}", t.name_str())), ty::Float(t) => p!(write("{}", t.name_str())),
ty::RawPtr(ref tm) => { ty::RawPtr(ty, mutbl) => {
p!(write( p!(write(
"*{} ", "*{} ",
match tm.mutbl { match mutbl {
hir::Mutability::Mut => "mut", hir::Mutability::Mut => "mut",
hir::Mutability::Not => "const", hir::Mutability::Not => "const",
} }
)); ));
p!(print(tm.ty)) p!(print(ty))
} }
ty::Ref(r, ty, mutbl) => { ty::Ref(r, ty, mutbl) => {
p!("&"); p!("&");
@ -1752,7 +1752,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
p!(write("{:?}", char::try_from(int).unwrap())) p!(write("{:?}", char::try_from(int).unwrap()))
} }
// Pointer types // Pointer types
ty::Ref(..) | ty::RawPtr(_) | ty::FnPtr(_) => { ty::Ref(..) | ty::RawPtr(_, _) | ty::FnPtr(_) => {
let data = int.assert_bits(self.tcx().data_layout.pointer_size); let data = int.assert_bits(self.tcx().data_layout.pointer_size);
self.typed_value( self.typed_value(
|this| { |this| {

58
compiler/rustc_middle/src/ty/relate.rs
View File

@ -94,28 +94,6 @@ pub trait Relate<'tcx>: TypeFoldable<TyCtxt<'tcx>> + PartialEq + Copy {
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// Relate impls // Relate impls
pub fn relate_type_and_mut<'tcx, R: TypeRelation<'tcx>>(
relation: &mut R,
a: ty::TypeAndMut<'tcx>,
b: ty::TypeAndMut<'tcx>,
base_ty: Ty<'tcx>,
) -> RelateResult<'tcx, ty::TypeAndMut<'tcx>> {
debug!("{}.mts({:?}, {:?})", relation.tag(), a, b);
if a.mutbl != b.mutbl {
Err(TypeError::Mutability)
} else {
let mutbl = a.mutbl;
let (variance, info) = match mutbl {
hir::Mutability::Not => (ty::Covariant, ty::VarianceDiagInfo::None),
hir::Mutability::Mut => {
(ty::Invariant, ty::VarianceDiagInfo::Invariant { ty: base_ty, param_index: 0 })
}
};
let ty = relation.relate_with_variance(variance, info, a.ty, b.ty)?;
Ok(ty::TypeAndMut { ty, mutbl })
}
}
#[inline] #[inline]
pub fn relate_args_invariantly<'tcx, R: TypeRelation<'tcx>>( pub fn relate_args_invariantly<'tcx, R: TypeRelation<'tcx>>(
relation: &mut R, relation: &mut R,
@ -465,17 +443,39 @@ pub fn structurally_relate_tys<'tcx, R: TypeRelation<'tcx>>(
Ok(Ty::new_coroutine_closure(tcx, a_id, args)) Ok(Ty::new_coroutine_closure(tcx, a_id, args))
} }
(&ty::RawPtr(a_mt), &ty::RawPtr(b_mt)) => { (&ty::RawPtr(a_ty, a_mutbl), &ty::RawPtr(b_ty, b_mutbl)) => {
let mt = relate_type_and_mut(relation, a_mt, b_mt, a)?; if a_mutbl != b_mutbl {
Ok(Ty::new_ptr(tcx, mt)) return Err(TypeError::Mutability);
}
let (variance, info) = match a_mutbl {
hir::Mutability::Not => (ty::Covariant, ty::VarianceDiagInfo::None),
hir::Mutability::Mut => {
(ty::Invariant, ty::VarianceDiagInfo::Invariant { ty: a, param_index: 0 })
}
};
let ty = relation.relate_with_variance(variance, info, a_ty, b_ty)?;
Ok(Ty::new_ptr(tcx, ty, a_mutbl))
} }
(&ty::Ref(a_r, a_ty, a_mutbl), &ty::Ref(b_r, b_ty, b_mutbl)) => { (&ty::Ref(a_r, a_ty, a_mutbl), &ty::Ref(b_r, b_ty, b_mutbl)) => {
if a_mutbl != b_mutbl {
return Err(TypeError::Mutability);
}
let (variance, info) = match a_mutbl {
hir::Mutability::Not => (ty::Covariant, ty::VarianceDiagInfo::None),
hir::Mutability::Mut => {
(ty::Invariant, ty::VarianceDiagInfo::Invariant { ty: a, param_index: 0 })
}
};
let r = relation.relate(a_r, b_r)?; let r = relation.relate(a_r, b_r)?;
let a_mt = ty::TypeAndMut { ty: a_ty, mutbl: a_mutbl }; let ty = relation.relate_with_variance(variance, info, a_ty, b_ty)?;
let b_mt = ty::TypeAndMut { ty: b_ty, mutbl: b_mutbl };
let mt = relate_type_and_mut(relation, a_mt, b_mt, a)?; Ok(Ty::new_ref(tcx, r, ty, a_mutbl))
Ok(Ty::new_ref(tcx, r, mt))
} }
(&ty::Array(a_t, sz_a), &ty::Array(b_t, sz_b)) => { (&ty::Array(a_t, sz_a), &ty::Array(b_t, sz_b)) => {

4
compiler/rustc_middle/src/ty/structural_impls.rs
View File

@ -560,7 +560,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
folder: &mut F, folder: &mut F,
) -> Result<Self, F::Error> { ) -> Result<Self, F::Error> {
let kind = match *self.kind() { let kind = match *self.kind() {
ty::RawPtr(tm) => ty::RawPtr(tm.try_fold_with(folder)?), ty::RawPtr(ty, mutbl) => ty::RawPtr(ty.try_fold_with(folder)?, mutbl),
ty::Array(typ, sz) => ty::Array(typ.try_fold_with(folder)?, sz.try_fold_with(folder)?), ty::Array(typ, sz) => ty::Array(typ.try_fold_with(folder)?, sz.try_fold_with(folder)?),
ty::Slice(typ) => ty::Slice(typ.try_fold_with(folder)?), ty::Slice(typ) => ty::Slice(typ.try_fold_with(folder)?),
ty::Adt(tid, args) => ty::Adt(tid, args.try_fold_with(folder)?), ty::Adt(tid, args) => ty::Adt(tid, args.try_fold_with(folder)?),
@ -607,7 +607,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx> { impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx> {
fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result { fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
match self.kind() { match self.kind() {
ty::RawPtr(ref tm) => tm.visit_with(visitor), ty::RawPtr(ty, _mutbl) => ty.visit_with(visitor),
ty::Array(typ, sz) => { ty::Array(typ, sz) => {
try_visit!(typ.visit_with(visitor)); try_visit!(typ.visit_with(visitor));
sz.visit_with(visitor) sz.visit_with(visitor)

39
compiler/rustc_middle/src/ty/sty.rs
View File

@ -1587,33 +1587,38 @@ impl<'tcx> Ty<'tcx> {
} }
#[inline] #[inline]
pub fn new_ref(tcx: TyCtxt<'tcx>, r: Region<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> { pub fn new_ref(
Ty::new(tcx, Ref(r, tm.ty, tm.mutbl)) tcx: TyCtxt<'tcx>,
r: Region<'tcx>,
ty: Ty<'tcx>,
mutbl: ty::Mutability,
) -> Ty<'tcx> {
Ty::new(tcx, Ref(r, ty, mutbl))
} }
#[inline] #[inline]
pub fn new_mut_ref(tcx: TyCtxt<'tcx>, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { pub fn new_mut_ref(tcx: TyCtxt<'tcx>, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
Ty::new_ref(tcx, r, TypeAndMut { ty, mutbl: hir::Mutability::Mut }) Ty::new_ref(tcx, r, ty, hir::Mutability::Mut)
} }
#[inline] #[inline]
pub fn new_imm_ref(tcx: TyCtxt<'tcx>, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { pub fn new_imm_ref(tcx: TyCtxt<'tcx>, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
Ty::new_ref(tcx, r, TypeAndMut { ty, mutbl: hir::Mutability::Not }) Ty::new_ref(tcx, r, ty, hir::Mutability::Not)
} }
#[inline] #[inline]
pub fn new_ptr(tcx: TyCtxt<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> { pub fn new_ptr(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, mutbl: ty::Mutability) -> Ty<'tcx> {
Ty::new(tcx, RawPtr(tm)) Ty::new(tcx, ty::RawPtr(ty, mutbl))
} }
#[inline] #[inline]
pub fn new_mut_ptr(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { pub fn new_mut_ptr(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
Ty::new_ptr(tcx, TypeAndMut { ty, mutbl: hir::Mutability::Mut }) Ty::new_ptr(tcx, ty, hir::Mutability::Mut)
} }
#[inline] #[inline]
pub fn new_imm_ptr(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { pub fn new_imm_ptr(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
Ty::new_ptr(tcx, TypeAndMut { ty, mutbl: hir::Mutability::Not }) Ty::new_ptr(tcx, ty, hir::Mutability::Not)
} }
#[inline] #[inline]
@ -1910,7 +1915,7 @@ impl<'tcx> Ty<'tcx> {
pub fn is_array_slice(self) -> bool { pub fn is_array_slice(self) -> bool {
match self.kind() { match self.kind() {
Slice(_) => true, Slice(_) => true,
RawPtr(TypeAndMut { ty, .. }) | Ref(_, ty, _) => matches!(ty.kind(), Slice(_)), ty::RawPtr(ty, _) | Ref(_, ty, _) => matches!(ty.kind(), Slice(_)),
_ => false, _ => false,
} }
} }
@ -1964,11 +1969,7 @@ impl<'tcx> Ty<'tcx> {
#[inline] #[inline]
pub fn is_mutable_ptr(self) -> bool { pub fn is_mutable_ptr(self) -> bool {
matches!( matches!(self.kind(), RawPtr(_, hir::Mutability::Mut) | Ref(_, _, hir::Mutability::Mut))
self.kind(),
RawPtr(TypeAndMut { mutbl: hir::Mutability::Mut, .. })
| Ref(_, _, hir::Mutability::Mut)
)
} }
/// Get the mutability of the reference or `None` when not a reference /// Get the mutability of the reference or `None` when not a reference
@ -1982,7 +1983,7 @@ impl<'tcx> Ty<'tcx> {
#[inline] #[inline]
pub fn is_unsafe_ptr(self) -> bool { pub fn is_unsafe_ptr(self) -> bool {
matches!(self.kind(), RawPtr(_)) matches!(self.kind(), RawPtr(_, _))
} }
/// Tests if this is any kind of primitive pointer type (reference, raw pointer, fn pointer). /// Tests if this is any kind of primitive pointer type (reference, raw pointer, fn pointer).
@ -2038,7 +2039,7 @@ impl<'tcx> Ty<'tcx> {
| Uint(_) | Uint(_)
| FnDef(..) | FnDef(..)
| FnPtr(_) | FnPtr(_)
| RawPtr(_) | RawPtr(_, _)
| Infer(IntVar(_) | FloatVar(_)) | Infer(IntVar(_) | FloatVar(_))
) )
} }
@ -2174,7 +2175,7 @@ impl<'tcx> Ty<'tcx> {
Some(TypeAndMut { ty: self.boxed_ty(), mutbl: hir::Mutability::Not }) Some(TypeAndMut { ty: self.boxed_ty(), mutbl: hir::Mutability::Not })
} }
Ref(_, ty, mutbl) => Some(TypeAndMut { ty: *ty, mutbl: *mutbl }), Ref(_, ty, mutbl) => Some(TypeAndMut { ty: *ty, mutbl: *mutbl }),
RawPtr(mt) if explicit => Some(*mt), RawPtr(ty, mutbl) if explicit => Some(TypeAndMut { ty: *ty, mutbl: *mutbl }),
_ => None, _ => None,
} }
} }
@ -2293,7 +2294,7 @@ impl<'tcx> Ty<'tcx> {
| ty::Str | ty::Str
| ty::Array(..) | ty::Array(..)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::FnDef(..) | ty::FnDef(..)
| ty::FnPtr(..) | ty::FnPtr(..)
@ -2636,7 +2637,7 @@ impl<'tcx> Ty<'tcx> {
| Str | Str
| Array(_, _) | Array(_, _)
| Slice(_) | Slice(_)
| RawPtr(_) | RawPtr(_, _)
| Ref(_, _, _) | Ref(_, _, _)
| FnDef(_, _) | FnDef(_, _)
| FnPtr(_) | FnPtr(_)

12
compiler/rustc_middle/src/ty/util.rs
View File

@ -1237,7 +1237,7 @@ impl<'tcx> Ty<'tcx> {
| ty::Str | ty::Str
| ty::Never | ty::Never
| ty::Ref(..) | ty::Ref(..)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::FnDef(..) | ty::FnDef(..)
| ty::Error(_) | ty::Error(_)
| ty::FnPtr(_) => true, | ty::FnPtr(_) => true,
@ -1277,7 +1277,7 @@ impl<'tcx> Ty<'tcx> {
| ty::Str | ty::Str
| ty::Never | ty::Never
| ty::Ref(..) | ty::Ref(..)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::FnDef(..) | ty::FnDef(..)
| ty::Error(_) | ty::Error(_)
| ty::FnPtr(_) => true, | ty::FnPtr(_) => true,
@ -1401,7 +1401,7 @@ impl<'tcx> Ty<'tcx> {
ty::Ref(..) | ty::Array(..) | ty::Slice(_) | ty::Tuple(..) => true, ty::Ref(..) | ty::Array(..) | ty::Slice(_) | ty::Tuple(..) => true,
// Raw pointers use bitwise comparison. // Raw pointers use bitwise comparison.
ty::RawPtr(_) | ty::FnPtr(_) => true, ty::RawPtr(_, _) | ty::FnPtr(_) => true,
// Floating point numbers are not `Eq`. // Floating point numbers are not `Eq`.
ty::Float(_) => false, ty::Float(_) => false,
@ -1494,7 +1494,7 @@ impl<'tcx> ExplicitSelf<'tcx> {
match *self_arg_ty.kind() { match *self_arg_ty.kind() {
_ if is_self_ty(self_arg_ty) => ByValue, _ if is_self_ty(self_arg_ty) => ByValue,
ty::Ref(region, ty, mutbl) if is_self_ty(ty) => ByReference(region, mutbl), ty::Ref(region, ty, mutbl) if is_self_ty(ty) => ByReference(region, mutbl),
ty::RawPtr(ty::TypeAndMut { ty, mutbl }) if is_self_ty(ty) => ByRawPointer(mutbl), ty::RawPtr(ty, mutbl) if is_self_ty(ty) => ByRawPointer(mutbl),
ty::Adt(def, _) if def.is_box() && is_self_ty(self_arg_ty.boxed_ty()) => ByBox, ty::Adt(def, _) if def.is_box() && is_self_ty(self_arg_ty.boxed_ty()) => ByBox,
_ => Other, _ => Other,
} }
@ -1519,7 +1519,7 @@ pub fn needs_drop_components<'tcx>(
| ty::FnDef(..) | ty::FnDef(..)
| ty::FnPtr(_) | ty::FnPtr(_)
| ty::Char | ty::Char
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::Str => Ok(SmallVec::new()), | ty::Str => Ok(SmallVec::new()),
@ -1574,7 +1574,7 @@ pub fn is_trivially_const_drop(ty: Ty<'_>) -> bool {
| ty::Infer(ty::IntVar(_)) | ty::Infer(ty::IntVar(_))
| ty::Infer(ty::FloatVar(_)) | ty::Infer(ty::FloatVar(_))
| ty::Str | ty::Str
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::FnDef(..) | ty::FnDef(..)
| ty::FnPtr(_) | ty::FnPtr(_)

4
compiler/rustc_middle/src/ty/walk.rs
View File

@ -158,8 +158,8 @@ fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>)
ty::Slice(ty) => { ty::Slice(ty) => {
stack.push(ty.into()); stack.push(ty.into());
} }
ty::RawPtr(mt) => { ty::RawPtr(ty, _) => {
stack.push(mt.ty.into()); stack.push(ty.into());
} }
ty::Ref(lt, ty, _) => { ty::Ref(lt, ty, _) => {
stack.push(ty.into()); stack.push(ty.into());

8
compiler/rustc_mir_build/src/thir/cx/expr.rs
View File

@ -125,11 +125,7 @@ impl<'tcx> Cx<'tcx> {
expr = Expr { expr = Expr {
temp_lifetime, temp_lifetime,
ty: Ty::new_ref( ty: Ty::new_ref(self.tcx, deref.region, expr.ty, deref.mutbl),
self.tcx,
deref.region,
ty::TypeAndMut { ty: expr.ty, mutbl: deref.mutbl },
),
span, span,
kind: ExprKind::Borrow { kind: ExprKind::Borrow {
borrow_kind: deref.mutbl.to_borrow_kind(), borrow_kind: deref.mutbl.to_borrow_kind(),
@ -1021,7 +1017,7 @@ impl<'tcx> Cx<'tcx> {
let ty::Ref(region, _, mutbl) = *self.thir[args[0]].ty.kind() else { let ty::Ref(region, _, mutbl) = *self.thir[args[0]].ty.kind() else {
span_bug!(span, "overloaded_place: receiver is not a reference"); span_bug!(span, "overloaded_place: receiver is not a reference");
}; };
let ref_ty = Ty::new_ref(self.tcx, region, ty::TypeAndMut { ty: place_ty, mutbl }); let ref_ty = Ty::new_ref(self.tcx, region, place_ty, mutbl);
// construct the complete expression `foo()` for the overloaded call, // construct the complete expression `foo()` for the overloaded call,
// which will yield the &T type // which will yield the &T type

9
compiler/rustc_mir_dataflow/src/elaborate_drops.rs
View File

@ -1,4 +1,3 @@
use rustc_hir as hir;
use rustc_hir::lang_items::LangItem; use rustc_hir::lang_items::LangItem;
use rustc_index::Idx; use rustc_index::Idx;
use rustc_middle::mir::patch::MirPatch; use rustc_middle::mir::patch::MirPatch;
@ -629,11 +628,7 @@ where
let drop_fn = tcx.associated_item_def_ids(drop_trait)[0]; let drop_fn = tcx.associated_item_def_ids(drop_trait)[0];
let ty = self.place_ty(self.place); let ty = self.place_ty(self.place);
let ref_ty = Ty::new_ref( let ref_ty = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, ty);
tcx,
tcx.lifetimes.re_erased,
ty::TypeAndMut { ty, mutbl: hir::Mutability::Mut },
);
let ref_place = self.new_temp(ref_ty); let ref_place = self.new_temp(ref_ty);
let unit_temp = Place::from(self.new_temp(Ty::new_unit(tcx))); let unit_temp = Place::from(self.new_temp(Ty::new_unit(tcx)));
@ -700,7 +695,7 @@ where
let move_ = |place: Place<'tcx>| Operand::Move(place); let move_ = |place: Place<'tcx>| Operand::Move(place);
let tcx = self.tcx(); let tcx = self.tcx();
let ptr_ty = Ty::new_ptr(tcx, ty::TypeAndMut { ty: ety, mutbl: hir::Mutability::Mut }); let ptr_ty = Ty::new_mut_ptr(tcx, ety);
let ptr = Place::from(self.new_temp(ptr_ty)); let ptr = Place::from(self.new_temp(ptr_ty));
let can_go = Place::from(self.new_temp(tcx.types.bool)); let can_go = Place::from(self.new_temp(tcx.types.bool));
let one = self.constant_usize(1); let one = self.constant_usize(1);

2
compiler/rustc_mir_dataflow/src/move_paths/builder.rs
View File

@ -194,7 +194,7 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)

2
compiler/rustc_mir_dataflow/src/value_analysis.rs
View File

@ -843,7 +843,7 @@ impl Map {
self.value_count += 1; self.value_count += 1;
} }
if let ty::Ref(_, ref_ty, _) | ty::RawPtr(ty::TypeAndMut { ty: ref_ty, .. }) = ty.kind() if let ty::Ref(_, ref_ty, _) | ty::RawPtr(ref_ty, _) = ty.kind()
&& let ty::Slice(..) = ref_ty.kind() && let ty::Slice(..) = ref_ty.kind()
{ {
assert!(self.places[place].value_index.is_none(), "slices are not scalars"); assert!(self.places[place].value_index.is_none(), "slices are not scalars");

4
compiler/rustc_mir_transform/src/check_alignment.rs
View File

@ -5,7 +5,7 @@ use rustc_middle::mir::{
interpret::Scalar, interpret::Scalar,
visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor}, visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor},
}; };
use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt, TypeAndMut}; use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt};
use rustc_session::Session; use rustc_session::Session;
pub struct CheckAlignment; pub struct CheckAlignment;
@ -157,7 +157,7 @@ fn insert_alignment_check<'tcx>(
new_block: BasicBlock, new_block: BasicBlock,
) { ) {
// Cast the pointer to a *const () // Cast the pointer to a *const ()
let const_raw_ptr = Ty::new_ptr(tcx, TypeAndMut { ty: tcx.types.unit, mutbl: Mutability::Not }); let const_raw_ptr = Ty::new_imm_ptr(tcx, tcx.types.unit);
let rvalue = Rvalue::Cast(CastKind::PtrToPtr, Operand::Copy(pointer), const_raw_ptr); let rvalue = Rvalue::Cast(CastKind::PtrToPtr, Operand::Copy(pointer), const_raw_ptr);
let thin_ptr = local_decls.push(LocalDecl::with_source_info(const_raw_ptr, source_info)).into(); let thin_ptr = local_decls.push(LocalDecl::with_source_info(const_raw_ptr, source_info)).into();
block_data block_data

12
compiler/rustc_mir_transform/src/coroutine.rs
View File

@ -570,11 +570,7 @@ impl<'tcx> MutVisitor<'tcx> for TransformVisitor<'tcx> {
fn make_coroutine_state_argument_indirect<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) { fn make_coroutine_state_argument_indirect<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let coroutine_ty = body.local_decls.raw[1].ty; let coroutine_ty = body.local_decls.raw[1].ty;
let ref_coroutine_ty = Ty::new_ref( let ref_coroutine_ty = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, coroutine_ty);
tcx,
tcx.lifetimes.re_erased,
ty::TypeAndMut { ty: coroutine_ty, mutbl: Mutability::Mut },
);
// Replace the by value coroutine argument // Replace the by value coroutine argument
body.local_decls.raw[1].ty = ref_coroutine_ty; body.local_decls.raw[1].ty = ref_coroutine_ty;
@ -1265,10 +1261,8 @@ fn create_coroutine_drop_shim<'tcx>(
make_coroutine_state_argument_indirect(tcx, &mut body); make_coroutine_state_argument_indirect(tcx, &mut body);
// Change the coroutine argument from &mut to *mut // Change the coroutine argument from &mut to *mut
body.local_decls[SELF_ARG] = LocalDecl::with_source_info( body.local_decls[SELF_ARG] =
Ty::new_ptr(tcx, ty::TypeAndMut { ty: coroutine_ty, mutbl: hir::Mutability::Mut }), LocalDecl::with_source_info(Ty::new_mut_ptr(tcx, coroutine_ty), source_info);
source_info,
);
// Make sure we remove dead blocks to remove // Make sure we remove dead blocks to remove
// unrelated code from the resume part of the function // unrelated code from the resume part of the function

2
compiler/rustc_mir_transform/src/function_item_references.rs
View File

@ -121,7 +121,7 @@ impl<'tcx> FunctionItemRefChecker<'_, 'tcx> {
fn is_fn_ref(ty: Ty<'tcx>) -> Option<(DefId, GenericArgsRef<'tcx>)> { fn is_fn_ref(ty: Ty<'tcx>) -> Option<(DefId, GenericArgsRef<'tcx>)> {
let referent_ty = match ty.kind() { let referent_ty = match ty.kind() {
ty::Ref(_, referent_ty, _) => Some(referent_ty), ty::Ref(_, referent_ty, _) => Some(referent_ty),
ty::RawPtr(ty_and_mut) => Some(&ty_and_mut.ty), ty::RawPtr(referent_ty, _) => Some(referent_ty),
_ => None, _ => None,
}; };
referent_ty referent_ty

9
compiler/rustc_mir_transform/src/gvn.rs
View File

@ -94,7 +94,7 @@ use rustc_middle::mir::interpret::GlobalAlloc;
use rustc_middle::mir::visit::*; use rustc_middle::mir::visit::*;
use rustc_middle::mir::*; use rustc_middle::mir::*;
use rustc_middle::ty::layout::LayoutOf; use rustc_middle::ty::layout::LayoutOf;
use rustc_middle::ty::{self, Ty, TyCtxt, TypeAndMut}; use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::def_id::DefId; use rustc_span::def_id::DefId;
use rustc_span::DUMMY_SP; use rustc_span::DUMMY_SP;
use rustc_target::abi::{self, Abi, Size, VariantIdx, FIRST_VARIANT}; use rustc_target::abi::{self, Abi, Size, VariantIdx, FIRST_VARIANT};
@ -451,11 +451,10 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
AddressKind::Ref(bk) => Ty::new_ref( AddressKind::Ref(bk) => Ty::new_ref(
self.tcx, self.tcx,
self.tcx.lifetimes.re_erased, self.tcx.lifetimes.re_erased,
ty::TypeAndMut { ty: mplace.layout.ty, mutbl: bk.to_mutbl_lossy() }, mplace.layout.ty,
bk.to_mutbl_lossy(),
), ),
AddressKind::Address(mutbl) => { AddressKind::Address(mutbl) => Ty::new_ptr(self.tcx, mplace.layout.ty, mutbl),
Ty::new_ptr(self.tcx, TypeAndMut { ty: mplace.layout.ty, mutbl })
}
}; };
let layout = self.ecx.layout_of(ty).ok()?; let layout = self.ecx.layout_of(ty).ok()?;
ImmTy::from_immediate(pointer, layout).into() ImmTy::from_immediate(pointer, layout).into()

9
compiler/rustc_mir_transform/src/promote_consts.rs
View File

@ -464,7 +464,7 @@ impl<'tcx> Validator<'_, 'tcx> {
let op = *op; let op = *op;
let lhs_ty = lhs.ty(self.body, self.tcx); let lhs_ty = lhs.ty(self.body, self.tcx);
if let ty::RawPtr(_) | ty::FnPtr(..) = lhs_ty.kind() { if let ty::RawPtr(_, _) | ty::FnPtr(..) = lhs_ty.kind() {
// Raw and fn pointer operations are not allowed inside consts and thus not promotable. // Raw and fn pointer operations are not allowed inside consts and thus not promotable.
assert!(matches!( assert!(matches!(
op, op,
@ -820,11 +820,8 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
let ty = local_decls[place.local].ty; let ty = local_decls[place.local].ty;
let span = statement.source_info.span; let span = statement.source_info.span;
let ref_ty = Ty::new_ref( let ref_ty =
tcx, Ty::new_ref(tcx, tcx.lifetimes.re_erased, ty, borrow_kind.to_mutbl_lossy());
tcx.lifetimes.re_erased,
ty::TypeAndMut { ty, mutbl: borrow_kind.to_mutbl_lossy() },
);
let mut projection = vec![PlaceElem::Deref]; let mut projection = vec![PlaceElem::Deref];
projection.extend(place.projection); projection.extend(place.projection);

16
compiler/rustc_mir_transform/src/shim.rs
View File

@ -539,14 +539,8 @@ impl<'tcx> CloneShimBuilder<'tcx> {
const_: Const::zero_sized(func_ty), const_: Const::zero_sized(func_ty),
})); }));
let ref_loc = self.make_place( let ref_loc =
Mutability::Not, self.make_place(Mutability::Not, Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, ty));
Ty::new_ref(
tcx,
tcx.lifetimes.re_erased,
ty::TypeAndMut { ty, mutbl: hir::Mutability::Not },
),
);
// `let ref_loc: &ty = &src;` // `let ref_loc: &ty = &src;`
let statement = self.make_statement(StatementKind::Assign(Box::new(( let statement = self.make_statement(StatementKind::Assign(Box::new((
@ -771,11 +765,7 @@ fn build_call_shim<'tcx>(
// let rcvr = &mut rcvr; // let rcvr = &mut rcvr;
let ref_rcvr = local_decls.push( let ref_rcvr = local_decls.push(
LocalDecl::new( LocalDecl::new(
Ty::new_ref( Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, sig.inputs()[0]),
tcx,
tcx.lifetimes.re_erased,
ty::TypeAndMut { ty: sig.inputs()[0], mutbl: hir::Mutability::Mut },
),
span, span,
) )
.immutable(), .immutable(),

6
compiler/rustc_monomorphize/src/collector.rs
View File

@ -1211,10 +1211,8 @@ fn find_vtable_types_for_unsizing<'tcx>(
}; };
match (&source_ty.kind(), &target_ty.kind()) { match (&source_ty.kind(), &target_ty.kind()) {
(&ty::Ref(_, a, _), &ty::Ref(_, b, _) | &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) (&ty::Ref(_, a, _), &ty::Ref(_, b, _) | &ty::RawPtr(b, _))
| (&ty::RawPtr(ty::TypeAndMut { ty: a, .. }), &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) => { | (&ty::RawPtr(a, _), &ty::RawPtr(b, _)) => ptr_vtable(*a, *b),
ptr_vtable(*a, *b)
}
(&ty::Adt(def_a, _), &ty::Adt(def_b, _)) if def_a.is_box() && def_b.is_box() => { (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) if def_a.is_box() && def_b.is_box() => {
ptr_vtable(source_ty.boxed_ty(), target_ty.boxed_ty()) ptr_vtable(source_ty.boxed_ty(), target_ty.boxed_ty())
} }

2
compiler/rustc_next_trait_solver/src/canonicalizer.rs
View File

@ -351,7 +351,7 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)

2
compiler/rustc_pattern_analysis/src/rustc.rs
View File

@ -398,7 +398,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
ty::Float(_) ty::Float(_)
| ty::Str | ty::Str
| ty::Foreign(_) | ty::Foreign(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)
| ty::Dynamic(_, _, _) | ty::Dynamic(_, _, _)

7
compiler/rustc_smir/src/rustc_internal/internal.rs
View File

@ -95,10 +95,9 @@ impl RustcInternal for RigidTy {
} }
RigidTy::Str => rustc_ty::TyKind::Str, RigidTy::Str => rustc_ty::TyKind::Str,
RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)), RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)),
RigidTy::RawPtr(ty, mutability) => rustc_ty::TyKind::RawPtr(rustc_ty::TypeAndMut { RigidTy::RawPtr(ty, mutability) => {
ty: ty.internal(tables, tcx), rustc_ty::TyKind::RawPtr(ty.internal(tables, tcx), mutability.internal(tables, tcx))
mutbl: mutability.internal(tables, tcx), }
}),
RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref( RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref(
region.internal(tables, tcx), region.internal(tables, tcx),
ty.internal(tables, tcx), ty.internal(tables, tcx),

2
compiler/rustc_smir/src/rustc_smir/convert/ty.rs
View File

@ -331,7 +331,7 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
TyKind::RigidTy(RigidTy::Array(ty.stable(tables), constant.stable(tables))) TyKind::RigidTy(RigidTy::Array(ty.stable(tables), constant.stable(tables)))
} }
ty::Slice(ty) => TyKind::RigidTy(RigidTy::Slice(ty.stable(tables))), ty::Slice(ty) => TyKind::RigidTy(RigidTy::Slice(ty.stable(tables))),
ty::RawPtr(ty::TypeAndMut { ty, mutbl }) => { ty::RawPtr(ty, mutbl) => {
TyKind::RigidTy(RigidTy::RawPtr(ty.stable(tables), mutbl.stable(tables))) TyKind::RigidTy(RigidTy::RawPtr(ty.stable(tables), mutbl.stable(tables)))
} }
ty::Ref(region, ty, mutbl) => TyKind::RigidTy(RigidTy::Ref( ty::Ref(region, ty, mutbl) => TyKind::RigidTy(RigidTy::Ref(

13
compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs
View File

@ -683,13 +683,14 @@ fn encode_ty<'tcx>(
typeid.push_str(&s); typeid.push_str(&s);
} }
ty::RawPtr(tm) => { ty::RawPtr(ptr_ty, _mutbl) => {
// FIXME: This can definitely not be so spaghettified.
// P[K]<element-type> // P[K]<element-type>
let mut s = String::new(); let mut s = String::new();
s.push_str(&encode_ty(tcx, tm.ty, dict, options)); s.push_str(&encode_ty(tcx, *ptr_ty, dict, options));
if !ty.is_mutable_ptr() { if !ty.is_mutable_ptr() {
s = format!("{}{}", "K", &s); s = format!("{}{}", "K", &s);
compress(dict, DictKey::Ty(tm.ty, TyQ::Const), &mut s); compress(dict, DictKey::Ty(*ptr_ty, TyQ::Const), &mut s);
}; };
s = format!("{}{}", "P", &s); s = format!("{}{}", "P", &s);
compress(dict, DictKey::Ty(ty, TyQ::None), &mut s); compress(dict, DictKey::Ty(ty, TyQ::None), &mut s);
@ -930,7 +931,7 @@ fn transform_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, options: TransformTyOptio
} }
} }
ty::RawPtr(tm) => { ty::RawPtr(ptr_ty, _) => {
if options.contains(TransformTyOptions::GENERALIZE_POINTERS) { if options.contains(TransformTyOptions::GENERALIZE_POINTERS) {
if ty.is_mutable_ptr() { if ty.is_mutable_ptr() {
ty = Ty::new_mut_ptr(tcx, Ty::new_unit(tcx)); ty = Ty::new_mut_ptr(tcx, Ty::new_unit(tcx));
@ -939,9 +940,9 @@ fn transform_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, options: TransformTyOptio
} }
} else { } else {
if ty.is_mutable_ptr() { if ty.is_mutable_ptr() {
ty = Ty::new_mut_ptr(tcx, transform_ty(tcx, tm.ty, options)); ty = Ty::new_mut_ptr(tcx, transform_ty(tcx, *ptr_ty, options));
} else { } else {
ty = Ty::new_imm_ptr(tcx, transform_ty(tcx, tm.ty, options)); ty = Ty::new_imm_ptr(tcx, transform_ty(tcx, *ptr_ty, options));
} }
} }
} }

6
compiler/rustc_symbol_mangling/src/v0.rs
View File

@ -361,12 +361,12 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
ty.print(self)?; ty.print(self)?;
} }
ty::RawPtr(mt) => { ty::RawPtr(ty, mutbl) => {
self.push(match mt.mutbl { self.push(match mutbl {
hir::Mutability::Not => "P", hir::Mutability::Not => "P",
hir::Mutability::Mut => "O", hir::Mutability::Mut => "O",
}); });
mt.ty.print(self)?; ty.print(self)?;
} }
ty::Array(ty, len) => { ty::Array(ty, len) => {

6
compiler/rustc_trait_selection/src/solve/assembly/mod.rs
View File

@ -357,7 +357,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)
@ -590,7 +590,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)
@ -678,7 +678,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)

6
compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
View File

@ -46,7 +46,7 @@ pub(in crate::solve) fn instantiate_constituent_tys_for_auto_trait<'tcx>(
bug!("unexpected type `{ty}`") bug!("unexpected type `{ty}`")
} }
ty::RawPtr(ty::TypeAndMut { ty: element_ty, .. }) | ty::Ref(_, element_ty, _) => { ty::RawPtr(element_ty, _) | ty::Ref(_, element_ty, _) => {
Ok(vec![ty::Binder::dummy(element_ty)]) Ok(vec![ty::Binder::dummy(element_ty)])
} }
@ -340,7 +340,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<'tcx>(
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::Dynamic(_, _, _) | ty::Dynamic(_, _, _)
| ty::Coroutine(_, _) | ty::Coroutine(_, _)
@ -527,7 +527,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<'tc
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::Dynamic(_, _, _) | ty::Dynamic(_, _, _)
| ty::Coroutine(_, _) | ty::Coroutine(_, _)

2
compiler/rustc_trait_selection/src/solve/trait_goals.rs
View File

@ -1050,7 +1050,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)

8
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -31,8 +31,8 @@ use rustc_middle::traits::IsConstable;
use rustc_middle::ty::error::TypeError::{self, Sorts}; use rustc_middle::ty::error::TypeError::{self, Sorts};
use rustc_middle::ty::{ use rustc_middle::ty::{
self, suggest_arbitrary_trait_bound, suggest_constraining_type_param, AdtKind, GenericArgs, self, suggest_arbitrary_trait_bound, suggest_constraining_type_param, AdtKind, GenericArgs,
InferTy, IsSuggestable, ToPredicate, Ty, TyCtxt, TypeAndMut, TypeFoldable, TypeFolder, InferTy, IsSuggestable, ToPredicate, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable,
TypeSuperFoldable, TypeVisitableExt, TypeckResults, TypeVisitableExt, TypeckResults,
}; };
use rustc_span::def_id::LocalDefId; use rustc_span::def_id::LocalDefId;
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
@ -482,7 +482,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if let Some(steps) = if let Some(steps) =
autoderef.into_iter().enumerate().find_map(|(steps, (ty, obligations))| { autoderef.into_iter().enumerate().find_map(|(steps, (ty, obligations))| {
// Re-add the `&` // Re-add the `&`
let ty = Ty::new_ref(self.tcx, region, TypeAndMut { ty, mutbl }); let ty = Ty::new_ref(self.tcx, region, ty, mutbl);
// Remapping bound vars here // Remapping bound vars here
let real_trait_pred_and_ty = real_trait_pred let real_trait_pred_and_ty = real_trait_pred
@ -4352,7 +4352,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// Go through all the candidate impls to see if any of them is for // Go through all the candidate impls to see if any of them is for
// slices of `element_ty` with `mutability`. // slices of `element_ty` with `mutability`.
let mut is_slice = |candidate: Ty<'tcx>| match *candidate.kind() { let mut is_slice = |candidate: Ty<'tcx>| match *candidate.kind() {
ty::RawPtr(ty::TypeAndMut { ty: t, mutbl: m }) | ty::Ref(_, t, m) => { ty::RawPtr(t, m) | ty::Ref(_, t, m) => {
if matches!(*t.kind(), ty::Slice(e) if e == element_ty) if matches!(*t.kind(), ty::Slice(e) if e == element_ty)
&& m == mutability.unwrap_or(m) && m == mutability.unwrap_or(m)
{ {

6
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View File

@ -1357,7 +1357,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
"using function pointers as const generic parameters is forbidden", "using function pointers as const generic parameters is forbidden",
) )
} }
ty::RawPtr(_) => { ty::RawPtr(_, _) => {
struct_span_code_err!( struct_span_code_err!(
self.dcx(), self.dcx(),
span, span,
@ -1809,9 +1809,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let strip_references = |mut t: Ty<'tcx>| -> Ty<'tcx> { let strip_references = |mut t: Ty<'tcx>| -> Ty<'tcx> {
loop { loop {
match t.kind() { match t.kind() {
ty::Ref(_, inner, _) | ty::RawPtr(ty::TypeAndMut { ty: inner, .. }) => { ty::Ref(_, inner, _) | ty::RawPtr(inner, _) => t = *inner,
t = *inner
}
_ => break t, _ => break t,
} }
} }

2
compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
View File

@ -36,7 +36,7 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
| ty::FnPtr(_) | ty::FnPtr(_)
| ty::Char | ty::Char
| ty::CoroutineWitness(..) | ty::CoroutineWitness(..)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::Str | ty::Str
| ty::Foreign(..) | ty::Foreign(..)

10
compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
View File

@ -671,7 +671,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::Closure(..) | ty::Closure(..)
| ty::CoroutineClosure(..) | ty::CoroutineClosure(..)
@ -805,7 +805,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::Adt(..) | ty::Adt(..)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::FnDef(..) | ty::FnDef(..)
| ty::FnPtr(_) | ty::FnPtr(_)
@ -1186,7 +1186,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
| ty::Infer(ty::IntVar(_)) | ty::Infer(ty::IntVar(_))
| ty::Infer(ty::FloatVar(_)) | ty::Infer(ty::FloatVar(_))
| ty::Str | ty::Str
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::FnDef(..) | ty::FnDef(..)
| ty::FnPtr(_) | ty::FnPtr(_)
@ -1267,7 +1267,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
| ty::Str | ty::Str
| ty::Array(_, _) | ty::Array(_, _)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(_, _, _) | ty::Ref(_, _, _)
| ty::FnDef(_, _) | ty::FnDef(_, _)
| ty::FnPtr(_) | ty::FnPtr(_)
@ -1330,7 +1330,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
| ty::Str | ty::Str
| ty::Array(..) | ty::Array(..)
| ty::Slice(_) | ty::Slice(_)
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::FnDef(..) | ty::FnDef(..)
| ty::Placeholder(..) | ty::Placeholder(..)

2
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View File

@ -1413,7 +1413,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
| ty::Infer(ty::IntVar(_)) | ty::Infer(ty::IntVar(_))
| ty::Infer(ty::FloatVar(_)) | ty::Infer(ty::FloatVar(_))
| ty::Str | ty::Str
| ty::RawPtr(_) | ty::RawPtr(_, _)
| ty::Ref(..) | ty::Ref(..)
| ty::FnDef(..) | ty::FnDef(..)
| ty::FnPtr(_) | ty::FnPtr(_)

4
compiler/rustc_trait_selection/src/traits/select/mod.rs
View File

@ -2314,9 +2314,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
bug!("asked to assemble constituent types of unexpected type: {:?}", t); bug!("asked to assemble constituent types of unexpected type: {:?}", t);
} }
ty::RawPtr(ty::TypeAndMut { ty: element_ty, .. }) | ty::Ref(_, element_ty, _) => { ty::RawPtr(element_ty, _) | ty::Ref(_, element_ty, _) => t.rebind(vec![element_ty]),
t.rebind(vec![element_ty])
}
ty::Array(element_ty, _) | ty::Slice(element_ty) => t.rebind(vec![element_ty]), ty::Array(element_ty, _) | ty::Slice(element_ty) => t.rebind(vec![element_ty]),

2
compiler/rustc_trait_selection/src/traits/wf.rs
View File

@ -687,7 +687,7 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
} }
} }
ty::RawPtr(_) => { ty::RawPtr(_, _) => {
// Simple cases that are WF if their type args are WF. // Simple cases that are WF if their type args are WF.
} }

2
compiler/rustc_ty_utils/src/abi.rs
View File

@ -623,7 +623,7 @@ fn fn_abi_new_uncached<'tcx>(
let is_return = arg_idx.is_none(); let is_return = arg_idx.is_none();
let is_drop_target = is_drop_in_place && arg_idx == Some(0); let is_drop_target = is_drop_in_place && arg_idx == Some(0);
let drop_target_pointee = is_drop_target.then(|| match ty.kind() { let drop_target_pointee = is_drop_target.then(|| match ty.kind() {
ty::RawPtr(ty::TypeAndMut { ty, .. }) => *ty, ty::RawPtr(ty, _) => *ty,
_ => bug!("argument to drop_in_place is not a raw ptr: {:?}", ty), _ => bug!("argument to drop_in_place is not a raw ptr: {:?}", ty),
}); });

2
compiler/rustc_ty_utils/src/layout.rs
View File

@ -156,7 +156,7 @@ fn layout_of_uncached<'tcx>(
ty::Never => tcx.mk_layout(cx.layout_of_never_type()), ty::Never => tcx.mk_layout(cx.layout_of_never_type()),
// Potentially-wide pointers. // Potentially-wide pointers.
ty::Ref(_, pointee, _) | ty::RawPtr(ty::TypeAndMut { ty: pointee, .. }) => { ty::Ref(_, pointee, _) | ty::RawPtr(pointee, _) => {
let mut data_ptr = scalar_unit(Pointer(AddressSpace::DATA)); let mut data_ptr = scalar_unit(Pointer(AddressSpace::DATA));
if !ty.is_unsafe_ptr() { if !ty.is_unsafe_ptr() {
data_ptr.valid_range_mut().start = 1; data_ptr.valid_range_mut().start = 1;

8
compiler/rustc_type_ir/src/ty_kind.rs
View File

@ -112,7 +112,7 @@ pub enum TyKind<I: Interner> {
Slice(I::Ty), Slice(I::Ty),
/// A raw pointer. Written as `*mut T` or `*const T` /// A raw pointer. Written as `*mut T` or `*const T`
RawPtr(TypeAndMut<I>), RawPtr(I::Ty, Mutability),
/// A reference; a pointer with an associated lifetime. Written as /// A reference; a pointer with an associated lifetime. Written as
/// `&'a mut T` or `&'a T`. /// `&'a mut T` or `&'a T`.
@ -270,7 +270,7 @@ const fn tykind_discriminant<I: Interner>(value: &TyKind<I>) -> usize {
Str => 7, Str => 7,
Array(_, _) => 8, Array(_, _) => 8,
Slice(_) => 9, Slice(_) => 9,
RawPtr(_) => 10, RawPtr(_, _) => 10,
Ref(_, _, _) => 11, Ref(_, _, _) => 11,
FnDef(_, _) => 12, FnDef(_, _) => 12,
FnPtr(_) => 13, FnPtr(_) => 13,
@ -308,7 +308,7 @@ impl<I: Interner> PartialEq for TyKind<I> {
(Foreign(a_d), Foreign(b_d)) => a_d == b_d, (Foreign(a_d), Foreign(b_d)) => a_d == b_d,
(Array(a_t, a_c), Array(b_t, b_c)) => a_t == b_t && a_c == b_c, (Array(a_t, a_c), Array(b_t, b_c)) => a_t == b_t && a_c == b_c,
(Slice(a_t), Slice(b_t)) => a_t == b_t, (Slice(a_t), Slice(b_t)) => a_t == b_t,
(RawPtr(a_t), RawPtr(b_t)) => a_t == b_t, (RawPtr(a_t, a_m), RawPtr(b_t, b_m)) => a_t == b_t && a_m == b_m,
(Ref(a_r, a_t, a_m), Ref(b_r, b_t, b_m)) => a_r == b_r && a_t == b_t && a_m == b_m, (Ref(a_r, a_t, a_m), Ref(b_r, b_t, b_m)) => a_r == b_r && a_t == b_t && a_m == b_m,
(FnDef(a_d, a_s), FnDef(b_d, b_s)) => a_d == b_d && a_s == b_s, (FnDef(a_d, a_s), FnDef(b_d, b_s)) => a_d == b_d && a_s == b_s,
(FnPtr(a_s), FnPtr(b_s)) => a_s == b_s, (FnPtr(a_s), FnPtr(b_s)) => a_s == b_s,
@ -371,7 +371,7 @@ impl<I: Interner> DebugWithInfcx<I> for TyKind<I> {
Str => write!(f, "str"), Str => write!(f, "str"),
Array(t, c) => write!(f, "[{:?}; {:?}]", &this.wrap(t), &this.wrap(c)), Array(t, c) => write!(f, "[{:?}; {:?}]", &this.wrap(t), &this.wrap(c)),
Slice(t) => write!(f, "[{:?}]", &this.wrap(t)), Slice(t) => write!(f, "[{:?}]", &this.wrap(t)),
RawPtr(TypeAndMut { ty, mutbl }) => { RawPtr(ty, mutbl) => {
match mutbl { match mutbl {
Mutability::Mut => write!(f, "*mut "), Mutability::Mut => write!(f, "*mut "),
Mutability::Not => write!(f, "*const "), Mutability::Not => write!(f, "*const "),

4
src/librustdoc/clean/mod.rs
View File

@ -2053,8 +2053,8 @@ pub(crate) fn clean_middle_ty<'tcx>(
let n = print_const(cx, n); let n = print_const(cx, n);
Array(Box::new(clean_middle_ty(bound_ty.rebind(ty), cx, None, None)), n.into()) Array(Box::new(clean_middle_ty(bound_ty.rebind(ty), cx, None, None)), n.into())
} }
ty::RawPtr(mt) => { ty::RawPtr(ty, mutbl) => {
RawPointer(mt.mutbl, Box::new(clean_middle_ty(bound_ty.rebind(mt.ty), cx, None, None))) RawPointer(mutbl, Box::new(clean_middle_ty(bound_ty.rebind(ty), cx, None, None)))
} }
ty::Ref(r, ty, mutbl) => BorrowedRef { ty::Ref(r, ty, mutbl) => BorrowedRef {
lifetime: clean_middle_region(r), lifetime: clean_middle_region(r),

2
src/librustdoc/passes/collect_intra_doc_links.rs
View File

@ -493,7 +493,7 @@ impl<'a, 'tcx> LinkCollector<'a, 'tcx> {
ty::Tuple(_) => Res::Primitive(Tuple), ty::Tuple(_) => Res::Primitive(Tuple),
ty::Array(..) => Res::Primitive(Array), ty::Array(..) => Res::Primitive(Array),
ty::Slice(_) => Res::Primitive(Slice), ty::Slice(_) => Res::Primitive(Slice),
ty::RawPtr(_) => Res::Primitive(RawPointer), ty::RawPtr(_, _) => Res::Primitive(RawPointer),
ty::Ref(..) => Res::Primitive(Reference), ty::Ref(..) => Res::Primitive(Reference),
ty::FnDef(..) => panic!("type alias to a function definition"), ty::FnDef(..) => panic!("type alias to a function definition"),
ty::FnPtr(_) => Res::Primitive(Fn), ty::FnPtr(_) => Res::Primitive(Fn),

4
src/librustdoc/passes/collect_trait_impls.rs
View File

@ -115,9 +115,7 @@ pub(crate) fn collect_trait_impls(mut krate: Crate, cx: &mut DocContext<'_>) ->
// form that is valid for use in type inference. // form that is valid for use in type inference.
let ty = tcx.type_of(def_id).instantiate_identity(); let ty = tcx.type_of(def_id).instantiate_identity();
match ty.kind() { match ty.kind() {
ty::Slice(ty) ty::Slice(ty) | ty::Ref(_, ty, _) | ty::RawPtr(ty, _) => {
| ty::Ref(_, ty, _)
| ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
matches!(ty.kind(), ty::Param(..)) matches!(ty.kind(), ty::Param(..))
} }
ty::Tuple(tys) => tys.iter().all(|ty| matches!(ty.kind(), ty::Param(..))), ty::Tuple(tys) => tys.iter().all(|ty| matches!(ty.kind(), ty::Param(..))),

11
src/tools/clippy/clippy_lints/src/casts/as_ptr_cast_mut.rs
View File

@ -4,18 +4,13 @@ use rustc_errors::Applicability;
use rustc_hir::{Expr, ExprKind}; use rustc_hir::{Expr, ExprKind};
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::mir::Mutability; use rustc_middle::mir::Mutability;
use rustc_middle::ty::{self, Ty, TypeAndMut}; use rustc_middle::ty::{self, Ty};
use super::AS_PTR_CAST_MUT; use super::AS_PTR_CAST_MUT;
pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>) { pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>) {
if let ty::RawPtr(TypeAndMut { if let ty::RawPtr(ptrty, Mutability::Mut) = cast_to.kind()
mutbl: Mutability::Mut, && let ty::RawPtr(_, Mutability::Not) = cx.typeck_results().node_type(cast_expr.hir_id).kind()
ty: ptrty,
}) = cast_to.kind()
&& let ty::RawPtr(TypeAndMut {
mutbl: Mutability::Not, ..
}) = cx.typeck_results().node_type(cast_expr.hir_id).kind()
&& let ExprKind::MethodCall(method_name, receiver, [], _) = cast_expr.peel_blocks().kind && let ExprKind::MethodCall(method_name, receiver, [], _) = cast_expr.peel_blocks().kind
&& method_name.ident.name == rustc_span::sym::as_ptr && method_name.ident.name == rustc_span::sym::as_ptr
&& let Some(as_ptr_did) = cx && let Some(as_ptr_did) = cx

10
src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs
View File

@ -33,13 +33,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
} }
fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) { fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
if let ty::RawPtr(from_ptr_ty) = &cast_from.kind() if let ty::RawPtr(from_ptr_ty, _) = *cast_from.kind()
&& let ty::RawPtr(to_ptr_ty) = &cast_to.kind() && let ty::RawPtr(to_ptr_ty, _) = *cast_to.kind()
&& let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty) && let Ok(from_layout) = cx.layout_of(from_ptr_ty)
&& let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty) && let Ok(to_layout) = cx.layout_of(to_ptr_ty)
&& from_layout.align.abi < to_layout.align.abi && from_layout.align.abi < to_layout.align.abi
// with c_void, we inherently need to trust the user // with c_void, we inherently need to trust the user
&& !is_c_void(cx, from_ptr_ty.ty) && !is_c_void(cx, from_ptr_ty)
// when casting from a ZST, we don't know enough to properly lint // when casting from a ZST, we don't know enough to properly lint
&& !from_layout.is_zst() && !from_layout.is_zst()
&& !is_used_as_unaligned(cx, expr) && !is_used_as_unaligned(cx, expr)

2
src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs
View File

@ -87,7 +87,7 @@ fn is_child_of_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
/// the type is one of those slices /// the type is one of those slices
fn get_raw_slice_ty_mut(ty: Ty<'_>) -> Option<TypeAndMut<'_>> { fn get_raw_slice_ty_mut(ty: Ty<'_>) -> Option<TypeAndMut<'_>> {
match ty.kind() { match ty.kind() {
ty::RawPtr(TypeAndMut { ty: slice_ty, mutbl }) => match slice_ty.kind() { ty::RawPtr(slice_ty, mutbl) => match slice_ty.kind() {
ty::Slice(ty) => Some(TypeAndMut { ty: *ty, mutbl: *mutbl }), ty::Slice(ty) => Some(TypeAndMut { ty: *ty, mutbl: *mutbl }),
_ => None, _ => None,
}, },

4
src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
View File

@ -25,8 +25,8 @@ fn raw_parts_kind(cx: &LateContext<'_>, did: DefId) -> Option<RawPartsKind> {
pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>, msrv: &Msrv) { pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>, msrv: &Msrv) {
if msrv.meets(msrvs::PTR_SLICE_RAW_PARTS) if msrv.meets(msrvs::PTR_SLICE_RAW_PARTS)
&& let ty::RawPtr(ptrty) = cast_to.kind() && let ty::RawPtr(ptrty, _) = cast_to.kind()
&& let ty::Slice(_) = ptrty.ty.kind() && let ty::Slice(_) = ptrty.kind()
&& let ExprKind::Call(fun, [ptr_arg, len_arg]) = cast_expr.peel_blocks().kind && let ExprKind::Call(fun, [ptr_arg, len_arg]) = cast_expr.peel_blocks().kind
&& let ExprKind::Path(ref qpath) = fun.kind && let ExprKind::Path(ref qpath) = fun.kind
&& let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id() && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()

6
src/tools/clippy/clippy_lints/src/casts/ptr_as_ptr.rs
View File

@ -6,7 +6,7 @@ use rustc_errors::Applicability;
use rustc_hir::{Expr, ExprKind, Mutability, QPath, TyKind}; use rustc_hir::{Expr, ExprKind, Mutability, QPath, TyKind};
use rustc_hir_pretty::qpath_to_string; use rustc_hir_pretty::qpath_to_string;
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::ty::{self, TypeAndMut}; use rustc_middle::ty;
use rustc_span::sym; use rustc_span::sym;
use super::PTR_AS_PTR; use super::PTR_AS_PTR;
@ -33,8 +33,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind
&& let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr)) && let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr))
&& let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind() && let ty::RawPtr(_, from_mutbl) = cast_from.kind()
&& let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind() && let ty::RawPtr(to_pointee_ty, to_mutbl) = cast_to.kind()
&& matches!((from_mutbl, to_mutbl), && matches!((from_mutbl, to_mutbl),
(Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut)) (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut))
// The `U` in `pointer::cast` have to be `Sized` // The `U` in `pointer::cast` have to be `Sized`

12
src/tools/clippy/clippy_lints/src/casts/ptr_cast_constness.rs
View File

@ -4,7 +4,7 @@ use clippy_utils::sugg::Sugg;
use rustc_errors::Applicability; use rustc_errors::Applicability;
use rustc_hir::{Expr, Mutability}; use rustc_hir::{Expr, Mutability};
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::ty::{self, Ty, TypeAndMut}; use rustc_middle::ty::{self, Ty};
use super::PTR_CAST_CONSTNESS; use super::PTR_CAST_CONSTNESS;
@ -17,14 +17,8 @@ pub(super) fn check<'tcx>(
msrv: &Msrv, msrv: &Msrv,
) { ) {
if msrv.meets(msrvs::POINTER_CAST_CONSTNESS) if msrv.meets(msrvs::POINTER_CAST_CONSTNESS)
&& let ty::RawPtr(TypeAndMut { && let ty::RawPtr(from_ty, from_mutbl) = cast_from.kind()
mutbl: from_mutbl, && let ty::RawPtr(to_ty, to_mutbl) = cast_to.kind()
ty: from_ty,
}) = cast_from.kind()
&& let ty::RawPtr(TypeAndMut {
mutbl: to_mutbl,
ty: to_ty,
}) = cast_to.kind()
&& matches!( && matches!(
(from_mutbl, to_mutbl), (from_mutbl, to_mutbl),
(Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not) (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not)

Some files were not shown because too many files have changed in this diff Show More