nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-16 05:56:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #135994 - 1c3t3a:rename-unsafe-ptr, r=oli-obk

Browse Source 
Rename rustc_middle::Ty::is_unsafe_ptr to is_raw_ptr

The wording unsafe pointer is less common and not mentioned in a lot of places, instead this is usually called a "raw pointer". For the sake of uniformity, we rename this method.
This came up during the review of
https://github.com/rust-lang/rust/pull/134424.

r? `@Noratrieb`
This commit is contained in:
bors 2025-02-12 23:18:14 +00:00
commit 6dce9f8c2d
38 changed files with 64 additions and 64 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

@ -570,7 +570,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
// If we didn't find an overloaded deref or index, then assume it's a
// built in deref and check the type of the base.
let base_ty = deref_base.ty(self.body, tcx).ty;
if base_ty.is_unsafe_ptr() {
if base_ty.is_raw_ptr() {
BorrowedContentSource::DerefRawPointer
} else if base_ty.is_mutable_ptr() {
BorrowedContentSource::DerefMutableRef

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

@ -900,8 +900,8 @@ fn codegen_stmt<'tcx>(
};
let data = codegen_operand(fx, data);
let meta = codegen_operand(fx, meta);
assert!(data.layout().ty.is_unsafe_ptr());
assert!(layout.ty.is_unsafe_ptr());
assert!(data.layout().ty.is_raw_ptr());
assert!(layout.ty.is_raw_ptr());
let ptr_val = if meta.layout().is_zst() {
data.cast_pointer_to(layout)
} else {

2
compiler/rustc_codegen_cranelift/src/vtable.rs
View File

@ -48,7 +48,7 @@ pub(crate) fn get_ptr_and_method_ref<'tcx>(
) -> (Pointer, Value) {
let (ptr, vtable) = 'block: {
if let BackendRepr::Scalar(_) = arg.layout().backend_repr {
while !arg.layout().ty.is_unsafe_ptr() && !arg.layout().ty.is_ref() {
while !arg.layout().ty.is_raw_ptr() && !arg.layout().ty.is_ref() {
let (idx, _) = arg
.layout()
.non_1zst_field(fx)

4
compiler/rustc_codegen_ssa/src/mir/block.rs
View File

@ -1013,7 +1013,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
//
// This is also relevant for `Pin<&mut Self>`, where we need to peel the
// `Pin`.
while !op.layout.ty.is_unsafe_ptr() && !op.layout.ty.is_ref() {
while !op.layout.ty.is_raw_ptr() && !op.layout.ty.is_ref() {
let (idx, _) = op.layout.non_1zst_field(bx).expect(
"not exactly one non-1-ZST field in a `DispatchFromDyn` type",
);
@ -1045,7 +1045,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
}
Immediate(_) => {
// See comment above explaining why we peel these newtypes
while !op.layout.ty.is_unsafe_ptr() && !op.layout.ty.is_ref() {
while !op.layout.ty.is_raw_ptr() && !op.layout.ty.is_ref() {
let (idx, _) = op.layout.non_1zst_field(bx).expect(
"not exactly one non-1-ZST field in a `DispatchFromDyn` type",
);

8
compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
View File

@ -367,7 +367,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
bx.sess().dcx().emit_fatal(errors::AtomicCompareExchange);
};
let ty = fn_args.type_at(0);
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_unsafe_ptr() {
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_raw_ptr() {
let weak = instruction == "cxchgweak";
let dst = args[0].immediate();
let cmp = args[1].immediate();
@ -395,7 +395,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
"load" => {
let ty = fn_args.type_at(0);
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_unsafe_ptr() {
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_raw_ptr() {
let layout = bx.layout_of(ty);
let size = layout.size;
let source = args[0].immediate();
@ -413,7 +413,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
"store" => {
let ty = fn_args.type_at(0);
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_unsafe_ptr() {
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_raw_ptr() {
let size = bx.layout_of(ty).size;
let val = args[1].immediate();
let ptr = args[0].immediate();
@ -458,7 +458,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
};
let ty = fn_args.type_at(0);
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_unsafe_ptr() {
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_raw_ptr() {
let ptr = args[0].immediate();
let val = args[1].immediate();
bx.atomic_rmw(atom_op, ptr, val, parse_ordering(bx, ordering))

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

@ -689,7 +689,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
(OperandValue::Immediate(llval), operand.layout)
}
mir::UnOp::PtrMetadata => {
assert!(operand.layout.ty.is_unsafe_ptr() || operand.layout.ty.is_ref(),);
assert!(operand.layout.ty.is_raw_ptr() || operand.layout.ty.is_ref(),);
let (_, meta) = operand.val.pointer_parts();
assert_eq!(operand.layout.fields.count() > 1, meta.is_some());
if let Some(meta) = meta {

2
compiler/rustc_const_eval/src/check_consts/check.rs
View File

@ -710,7 +710,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
if is_int_bool_float_or_char(lhs_ty) && is_int_bool_float_or_char(rhs_ty) {
// Int, bool, float, and char operations are fine.
} else if lhs_ty.is_fn_ptr() || lhs_ty.is_unsafe_ptr() {
} else if lhs_ty.is_fn_ptr() || lhs_ty.is_raw_ptr() {
assert_matches!(
op,
BinOp::Eq

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

@ -203,7 +203,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
cast_to: TyAndLayout<'tcx>,
) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
assert!(src.layout.ty.is_any_ptr());
assert!(cast_to.ty.is_unsafe_ptr());
assert!(cast_to.ty.is_raw_ptr());
// Handle casting any ptr to raw ptr (might be a wide ptr).
if cast_to.size == src.layout.size {
// Thin or wide pointer that just has the ptr kind of target type changed.
@ -212,7 +212,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
// Casting the metadata away from a wide ptr.
assert_eq!(src.layout.size, 2 * self.pointer_size());
assert_eq!(cast_to.size, self.pointer_size());
assert!(src.layout.ty.is_unsafe_ptr());
assert!(src.layout.ty.is_raw_ptr());
return match **src {
Immediate::ScalarPair(data, _) => interp_ok(ImmTy::from_scalar(data, cast_to)),
Immediate::Scalar(..) => span_bug!(

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

@ -241,7 +241,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
// Figure out whether this is an addr_of of an already raw place.
let place_base_raw = if place.is_indirect_first_projection() {
let ty = self.frame().body.local_decls[place.local].ty;
ty.is_unsafe_ptr()
ty.is_raw_ptr()
} else {
// Not a deref, and thus not raw.
false

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

@ -690,7 +690,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
} else {
match self.try_coercion_cast(fcx) {
Ok(()) => {
if self.expr_ty.is_unsafe_ptr() && self.cast_ty.is_unsafe_ptr() {
if self.expr_ty.is_raw_ptr() && self.cast_ty.is_raw_ptr() {
// When casting a raw pointer to another raw pointer, we cannot convert the cast into
// a coercion because the pointee types might only differ in regions, which HIR typeck
// cannot distinguish. This would cause us to erroneously discard a cast which will

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

@ -219,7 +219,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
// or pin-ergonomics.
match *b.kind() {
ty::RawPtr(_, b_mutbl) => {
return self.coerce_unsafe_ptr(a, b, b_mutbl);
return self.coerce_raw_ptr(a, b, b_mutbl);
}
ty::Ref(r_b, _, mutbl_b) => {
return self.coerce_borrowed_pointer(a, b, r_b, mutbl_b);
@ -1017,13 +1017,13 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
}
}
fn coerce_unsafe_ptr(
fn coerce_raw_ptr(
&self,
a: Ty<'tcx>,
b: Ty<'tcx>,
mutbl_b: hir::Mutability,
) -> CoerceResult<'tcx> {
debug!("coerce_unsafe_ptr(a={:?}, b={:?})", a, b);
debug!("coerce_raw_ptr(a={:?}, b={:?})", a, b);
let (is_ref, mt_a) = match *a.kind() {
ty::Ref(_, ty, mutbl) => (true, ty::TypeAndMut { ty, mutbl }),
@ -1033,21 +1033,21 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
coerce_mutbls(mt_a.mutbl, mutbl_b)?;
// Check that the types which they point at are compatible.
let a_unsafe = Ty::new_ptr(self.tcx, mt_a.ty, mutbl_b);
// Although references and unsafe ptrs have the same
let a_raw = Ty::new_ptr(self.tcx, mt_a.ty, mutbl_b);
// Although references and raw ptrs have the same
// representation, we still register an Adjust::DerefRef so that
// regionck knows that the region for `a` must be valid here.
if is_ref {
self.unify_and(a_unsafe, b, |target| {
self.unify_and(a_raw, b, |target| {
vec![
Adjustment { kind: Adjust::Deref(None), target: mt_a.ty },
Adjustment { kind: Adjust::Borrow(AutoBorrow::RawPtr(mutbl_b)), target },
]
})
} else if mt_a.mutbl != mutbl_b {
self.unify_and(a_unsafe, b, simple(Adjust::Pointer(PointerCoercion::MutToConstPointer)))
self.unify_and(a_raw, b, simple(Adjust::Pointer(PointerCoercion::MutToConstPointer)))
} else {
self.unify_and(a_unsafe, b, identity)
self.unify_and(a_raw, b, identity)
}
}
}

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

@ -3556,7 +3556,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
if base_t.is_unsafe_ptr() && idx_t.is_integral() {
if base_t.is_raw_ptr() && idx_t.is_integral() {
err.multipart_suggestion(
"consider using `wrapping_add` or `add` for indexing into raw pointer",
vec![

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

@ -598,7 +598,7 @@ fn method_autoderef_steps<'tcx>(
unsize: false,
reachable_via_deref,
};
if ty.is_unsafe_ptr() {
if ty.is_raw_ptr() {
// all the subsequent steps will be from_unsafe_deref
reached_raw_pointer = true;
}
@ -618,7 +618,7 @@ fn method_autoderef_steps<'tcx>(
unsize: false,
reachable_via_deref: true,
};
if ty.is_unsafe_ptr() {
if ty.is_raw_ptr() {
// all the subsequent steps will be from_unsafe_deref
reached_raw_pointer = true;
}

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

@ -645,7 +645,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// pointer + {integer} or pointer - pointer.
if op.span.can_be_used_for_suggestions() {
match op.node {
hir::BinOpKind::Add if lhs_ty.is_unsafe_ptr() && rhs_ty.is_integral() => {
hir::BinOpKind::Add if lhs_ty.is_raw_ptr() && rhs_ty.is_integral() => {
err.multipart_suggestion(
"consider using `wrapping_add` or `add` for pointer + {integer}",
vec![
@ -659,7 +659,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
);
}
hir::BinOpKind::Sub => {
if lhs_ty.is_unsafe_ptr() && rhs_ty.is_integral() {
if lhs_ty.is_raw_ptr() && rhs_ty.is_integral() {
err.multipart_suggestion(
"consider using `wrapping_sub` or `sub` for \
pointer - {integer}",
@ -674,7 +674,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
);
}
if lhs_ty.is_unsafe_ptr() && rhs_ty.is_unsafe_ptr() {
if lhs_ty.is_raw_ptr() && rhs_ty.is_raw_ptr() {
err.multipart_suggestion(
"consider using `offset_from` for pointer - pointer if the \
pointers point to the same allocation",

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

@ -2042,7 +2042,7 @@ impl<'tcx> euv::Delegate<'tcx> for InferBorrowKind<'tcx> {
restrict_repr_packed_field_ref_capture(place_with_id.place.clone(), capture_kind);
// Raw pointers don't inherit mutability
if place_with_id.place.deref_tys().any(Ty::is_unsafe_ptr) {
if place_with_id.place.deref_tys().any(Ty::is_raw_ptr) {
capture_kind = ty::UpvarCapture::ByRef(ty::BorrowKind::Immutable);
}
@ -2093,7 +2093,7 @@ fn restrict_precision_for_unsafe(
mut place: Place<'_>,
mut curr_mode: ty::UpvarCapture,
) -> (Place<'_>, ty::UpvarCapture) {
if place.base_ty.is_unsafe_ptr() {
if place.base_ty.is_raw_ptr() {
truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, 0);
}
@ -2102,8 +2102,8 @@ fn restrict_precision_for_unsafe(
}
for (i, proj) in place.projections.iter().enumerate() {
if proj.ty.is_unsafe_ptr() {
// Don't apply any projections on top of an unsafe ptr.
if proj.ty.is_raw_ptr() {
// Don't apply any projections on top of a raw ptr.
truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, i + 1);
break;
}

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

@ -576,7 +576,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingCopyImplementations {
// and recommending Copy might be a bad idea.
for field in def.all_fields() {
let did = field.did;
if cx.tcx.type_of(did).instantiate_identity().is_unsafe_ptr() {
if cx.tcx.type_of(did).instantiate_identity().is_raw_ptr() {
return;
}
}

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

@ -368,7 +368,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
match *ty.kind() {
ty::Ref(_, pointee, _) | ty::RawPtr(pointee, _) => {
let non_zero = !ty.is_unsafe_ptr();
let non_zero = !ty.is_raw_ptr();
let tail = tcx.struct_tail_raw(
pointee,
@ -840,7 +840,7 @@ where
// as the `Abi` or `FieldsShape` is checked by users.
if i == 0 {
let nil = tcx.types.unit;
let unit_ptr_ty = if this.ty.is_unsafe_ptr() {
let unit_ptr_ty = if this.ty.is_raw_ptr() {
Ty::new_mut_ptr(tcx, nil)
} else {
Ty::new_mut_ref(tcx, tcx.lifetimes.re_static, nil)

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

@ -1199,7 +1199,7 @@ impl<'tcx> Ty<'tcx> {
}
#[inline]
pub fn is_unsafe_ptr(self) -> bool {
pub fn is_raw_ptr(self) -> bool {
matches!(self.kind(), RawPtr(_, _))
}
@ -1207,7 +1207,7 @@ impl<'tcx> Ty<'tcx> {
/// `Box` is *not* considered a pointer here!
#[inline]
pub fn is_any_ptr(self) -> bool {
self.is_ref() || self.is_unsafe_ptr() || self.is_fn_ptr()
self.is_ref() || self.is_raw_ptr() || self.is_fn_ptr()
}
#[inline]
@ -1394,7 +1394,7 @@ impl<'tcx> Ty<'tcx> {
/// Returns the type and mutability of `*ty`.
///
/// The parameter `explicit` indicates if this is an *explicit* dereference.
/// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.
/// Some types -- notably raw ptrs -- can only be dereferenced explicitly.
pub fn builtin_deref(self, explicit: bool) -> Option<Ty<'tcx>> {
match *self.kind() {
_ if let Some(boxed) = self.boxed_ty() => Some(boxed),

2
compiler/rustc_mir_build/src/check_unsafety.rs
View File

@ -554,7 +554,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
_ => self.requires_unsafe(expr.span, UseOfExternStatic),
}
}
} else if self.thir[arg].ty.is_unsafe_ptr() {
} else if self.thir[arg].ty.is_raw_ptr() {
self.requires_unsafe(expr.span, DerefOfRawPointer);
}
}

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

@ -190,7 +190,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PointerFinder<'a, 'tcx> {
let pointer_ty = self.local_decls[place.local].ty;
// We only want to check places based on raw pointers
if !pointer_ty.is_unsafe_ptr() {
if !pointer_ty.is_raw_ptr() {
trace!("Indirect, but not based on an raw ptr, not checking {:?}", place);
return;
}

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

@ -47,7 +47,7 @@ impl<'a, 'tcx> UndefinedTransmutesChecker<'a, 'tcx> {
{
let fn_sig = function.ty(self.body, self.tcx).fn_sig(self.tcx).skip_binder();
if let [input] = fn_sig.inputs() {
return input.is_unsafe_ptr() && fn_sig.output().is_integral();
return input.is_raw_ptr() && fn_sig.output().is_integral();
}
}
false

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

@ -1397,8 +1397,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
// or `*mut [i32]` <=> `*const [u64]`), including the common special
// case of `*const T` <=> `*mut T`.
if let Transmute = kind
&& from.is_unsafe_ptr()
&& to.is_unsafe_ptr()
&& from.is_raw_ptr()
&& to.is_raw_ptr()
&& self.pointers_have_same_metadata(from, to)
{
kind = PtrToPtr;

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

@ -749,7 +749,7 @@ fn make_thin_self_ptr<'tcx>(
// To get the type `*mut RcInner<Self>`, we just keep unwrapping newtypes until we
// get a built-in pointer type
let mut wide_pointer_layout = layout;
while !wide_pointer_layout.ty.is_unsafe_ptr() && !wide_pointer_layout.ty.is_ref() {
while !wide_pointer_layout.ty.is_raw_ptr() && !wide_pointer_layout.ty.is_ref() {
wide_pointer_layout = wide_pointer_layout
.non_1zst_field(cx)
.expect("not exactly one non-1-ZST field in a `DispatchFromDyn` type")

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

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

2
compiler/stable_mir/src/ty.rs
View File

@ -489,7 +489,7 @@ impl TyKind {
/// Returns the type and mutability of `*ty` for builtin types.
///
/// The parameter `explicit` indicates if this is an *explicit* dereference.
/// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.
/// Some types -- notably raw ptrs -- can only be dereferenced explicitly.
pub fn builtin_deref(&self, explicit: bool) -> Option<TypeAndMut> {
match self.rigid()? {
RigidTy::Adt(def, args) if def.is_box() => {

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

@ -66,7 +66,7 @@ fn is_used_as_unaligned(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
if matches!(name.ident.as_str(), "read_unaligned" | "write_unaligned")
&& let Some(def_id) = cx.typeck_results().type_dependent_def_id(parent.hir_id)
&& let Some(def_id) = cx.tcx.impl_of_method(def_id)
&& cx.tcx.type_of(def_id).instantiate_identity().is_unsafe_ptr()
&& cx.tcx.type_of(def_id).instantiate_identity().is_raw_ptr()
{
true
} else {

2
src/tools/clippy/clippy_lints/src/dereference.rs
View File

@ -682,7 +682,7 @@ fn try_parse_ref_op<'tcx>(
},
[arg],
) => (true, typeck.qpath_res(path, *hir_id).opt_def_id()?, arg),
ExprKind::Unary(UnOp::Deref, sub_expr) if !typeck.expr_ty(sub_expr).is_unsafe_ptr() => {
ExprKind::Unary(UnOp::Deref, sub_expr) if !typeck.expr_ty(sub_expr).is_raw_ptr() => {
return Some((RefOp::Deref, sub_expr));
},
ExprKind::AddrOf(BorrowKind::Ref, mutability, sub_expr) => return Some((RefOp::AddrOf(mutability), sub_expr)),

2
src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs
View File

@ -122,7 +122,7 @@ fn collect_unsafe_exprs<'tcx>(
unsafe_ops.push(("access of a mutable static occurs here", expr.span));
},
ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty_adjusted(e).is_unsafe_ptr() => {
ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty_adjusted(e).is_raw_ptr() => {
unsafe_ops.push(("raw pointer dereference occurs here", expr.span));
},

2
src/tools/clippy/clippy_lints/src/operators/ptr_eq.rs
View File

@ -53,7 +53,7 @@ fn expr_as_cast_to_usize<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>
// If the given expression is a cast to a `*const` pointer, return the lhs of the cast
// E.g., `foo as *const _` returns `foo`.
fn expr_as_cast_to_raw_pointer<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
if cx.typeck_results().expr_ty(cast_expr).is_unsafe_ptr() {
if cx.typeck_results().expr_ty(cast_expr).is_raw_ptr() {
if let ExprKind::Cast(expr, _) = cast_expr.kind {
return Some(expr);
}

6
src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
View File

@ -179,10 +179,10 @@ impl PassByRefOrValue {
&& let hir::TyKind::Ref(_, MutTy { ty: decl_ty, .. }) = input.kind
{
if let Some(typeck) = cx.maybe_typeck_results() {
// Don't lint if an unsafe pointer is created.
// TODO: Limit the check only to unsafe pointers to the argument (or part of the argument)
// Don't lint if a raw pointer is created.
// TODO: Limit the check only to raw pointers to the argument (or part of the argument)
// which escape the current function.
if typeck.node_types().items().any(|(_, &ty)| ty.is_unsafe_ptr())
if typeck.node_types().items().any(|(_, &ty)| ty.is_raw_ptr())
|| typeck
.adjustments()
.items()

2
src/tools/clippy/clippy_lints/src/ptr_offset_with_cast.rs
View File

@ -111,7 +111,7 @@ fn is_expr_ty_usize(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
// Is the type of the expression a raw pointer?
fn is_expr_ty_raw_ptr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
cx.typeck_results().expr_ty(expr).is_unsafe_ptr()
cx.typeck_results().expr_ty(expr).is_raw_ptr()
}
fn build_suggestion(

2
src/tools/clippy/clippy_lints/src/swap_ptr_to_ref.rs
View File

@ -76,7 +76,7 @@ impl LateLintPass<'_> for SwapPtrToRef {
fn is_ptr_to_ref(cx: &LateContext<'_>, e: &Expr<'_>, ctxt: SyntaxContext) -> (bool, Option<Span>) {
if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, borrowed_expr) = e.kind
&& let ExprKind::Unary(UnOp::Deref, derefed_expr) = borrowed_expr.kind
&& cx.typeck_results().expr_ty(derefed_expr).is_unsafe_ptr()
&& cx.typeck_results().expr_ty(derefed_expr).is_raw_ptr()
{
(
true,

2
src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
View File

@ -217,7 +217,7 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
self.eagerness |= NoChange;
},
// Dereferences should be cheap, but dereferencing a raw pointer earlier may not be safe.
ExprKind::Unary(UnOp::Deref, e) if !self.cx.typeck_results().expr_ty(e).is_unsafe_ptr() => (),
ExprKind::Unary(UnOp::Deref, e) if !self.cx.typeck_results().expr_ty(e).is_raw_ptr() => (),
ExprKind::Unary(UnOp::Deref, _) => self.eagerness |= NoChange,
ExprKind::Unary(_, e)
if matches!(

2
src/tools/clippy/clippy_utils/src/visitors.rs
View File

@ -417,7 +417,7 @@ pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
}
fn visit_expr(&mut self, e: &'tcx Expr<'_>) -> Self::Result {
match e.kind {
ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_unsafe_ptr() => {
ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_raw_ptr() => {
ControlFlow::Break(())
},
ExprKind::MethodCall(..)

2
src/tools/miri/src/intrinsics/atomic.rs
View File

@ -189,7 +189,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
let place = this.deref_pointer(place)?;
let rhs = this.read_immediate(rhs)?;
if !place.layout.ty.is_integral() && !place.layout.ty.is_unsafe_ptr() {
if !place.layout.ty.is_integral() && !place.layout.ty.is_raw_ptr() {
span_bug!(
this.cur_span(),
"atomic arithmetic operations only work on integer and raw pointer types",

4
src/tools/miri/src/operator.rs
View File

@ -52,8 +52,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
// Some more operations are possible with atomics.
// The return value always has the provenance of the *left* operand.
Add | Sub | BitOr | BitAnd | BitXor => {
assert!(left.layout.ty.is_unsafe_ptr());
assert!(right.layout.ty.is_unsafe_ptr());
assert!(left.layout.ty.is_raw_ptr());
assert!(right.layout.ty.is_raw_ptr());
let ptr = left.to_scalar().to_pointer(this)?;
// We do the actual operation with usize-typed scalars.
let left = ImmTy::from_uint(ptr.addr().bytes(), this.machine.layouts.usize);

2
src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
View File

@ -373,7 +373,7 @@ impl InferenceTable<'_> {
// Check that the types which they point at are compatible.
let from_raw = TyKind::Raw(to_mt, from_inner.clone()).intern(Interner);
// Although references and unsafe ptrs have the same
// Although references and raw ptrs have the same
// representation, we still register an Adjust::DerefRef so that
// regionck knows that the region for `a` must be valid here.
if is_ref {

2
tests/ui/kindck/kindck-copy.rs
View File

@ -45,7 +45,7 @@ fn test<'a,T,U:Copy>(_: &'a isize) {
// mutable object types are not ok
assert_copy::<&'a mut (dyn Dummy + Send)>(); //~ ERROR : Copy` is not satisfied
// unsafe ptrs are ok
// raw ptrs are ok
assert_copy::<*const isize>();
assert_copy::<*const &'a mut isize>();