mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-26 00:34:06 +00:00
Auto merge of #118996 - matthiaskrgr:rollup-n6x2lc7, r=matthiaskrgr
Rollup of 7 pull requests Successful merges: - #117824 (Stabilize `ptr::{from_ref, from_mut}`) - #118234 (Stabilize `type_name_of_val`) - #118944 (Move type relations into submodule `relate` in rustc_infer, and notify when it has changed) - #118977 (Simplify `src-script.js` code) - #118985 (Remove `@JohnTitor` from diagnostics pings) - #118986 (Simplify JS code a little bit) - #118988 (rustdoc: add regression test for JS data file loading) r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
bors
commit
a96d57bdb6
@ -5,7 +5,7 @@ pub use self::BoundRegionConversionTime::*;
|
||||
pub use self::RegionVariableOrigin::*;
|
||||
pub use self::SubregionOrigin::*;
|
||||
pub use self::ValuePairs::*;
|
||||
pub use combine::ObligationEmittingRelation;
|
||||
pub use relate::combine::ObligationEmittingRelation;
|
||||
use rustc_data_structures::captures::Captures;
|
||||
use rustc_data_structures::undo_log::UndoLogs;
|
||||
use rustc_middle::infer::unify_key::{ConstVidKey, EffectVidKey};
|
||||
@ -43,7 +43,6 @@ use rustc_span::{Span, DUMMY_SP};
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::fmt;
|
||||
|
||||
use self::combine::CombineFields;
|
||||
use self::error_reporting::TypeErrCtxt;
|
||||
use self::free_regions::RegionRelations;
|
||||
use self::lexical_region_resolve::LexicalRegionResolutions;
|
||||
@ -51,29 +50,23 @@ use self::region_constraints::{GenericKind, VarInfos, VerifyBound};
|
||||
use self::region_constraints::{
|
||||
RegionConstraintCollector, RegionConstraintStorage, RegionSnapshot,
|
||||
};
|
||||
pub use self::relate::combine::CombineFields;
|
||||
pub use self::relate::nll as nll_relate;
|
||||
use self::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
|
||||
|
||||
pub mod at;
|
||||
pub mod canonical;
|
||||
mod combine;
|
||||
mod equate;
|
||||
pub mod error_reporting;
|
||||
pub mod free_regions;
|
||||
mod freshen;
|
||||
mod fudge;
|
||||
mod generalize;
|
||||
mod glb;
|
||||
mod higher_ranked;
|
||||
pub mod lattice;
|
||||
mod lexical_region_resolve;
|
||||
mod lub;
|
||||
pub mod nll_relate;
|
||||
pub mod opaque_types;
|
||||
pub mod outlives;
|
||||
mod projection;
|
||||
pub mod region_constraints;
|
||||
mod relate;
|
||||
pub mod resolve;
|
||||
mod sub;
|
||||
pub mod type_variable;
|
||||
mod undo_log;
|
||||
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
//! combining two instances of various things and yielding a new instance.
|
||||
//! These combiner methods always yield a `Result<T>`. To relate two
|
||||
//! types, you can use `infcx.at(cause, param_env)` which then allows
|
||||
//! you to use the relevant methods of [At](super::at::At).
|
||||
//! you to use the relevant methods of [At](crate::infer::at::At).
|
||||
//!
|
||||
//! Combiners mostly do their specific behavior and then hand off the
|
||||
//! bulk of the work to [InferCtxt::super_combine_tys] and
|
||||
@ -23,11 +23,11 @@
|
||||
//! this should be correctly updated.
|
||||
|
||||
use super::equate::Equate;
|
||||
use super::generalize::{self, CombineDelegate, Generalization};
|
||||
use super::glb::Glb;
|
||||
use super::lub::Lub;
|
||||
use super::sub::Sub;
|
||||
use super::{DefineOpaqueTypes, InferCtxt, TypeTrace};
|
||||
use crate::infer::generalize::{self, CombineDelegate, Generalization};
|
||||
use crate::infer::{DefineOpaqueTypes, InferCtxt, TypeTrace};
|
||||
use crate::traits::{Obligation, PredicateObligations};
|
||||
use rustc_middle::infer::canonical::OriginalQueryValues;
|
||||
use rustc_middle::infer::unify_key::{ConstVarValue, ConstVariableValue, EffectVarValue};
|
||||
@ -1,8 +1,6 @@
|
||||
use crate::infer::DefineOpaqueTypes;
|
||||
use crate::traits::PredicateObligations;
|
||||
|
||||
use super::combine::{CombineFields, ObligationEmittingRelation};
|
||||
use super::Subtype;
|
||||
use crate::infer::{DefineOpaqueTypes, SubregionOrigin};
|
||||
use crate::traits::PredicateObligations;
|
||||
|
||||
use rustc_middle::ty::relate::{self, Relate, RelateResult, TypeRelation};
|
||||
use rustc_middle::ty::GenericArgsRef;
|
||||
@ -133,7 +131,7 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {
|
||||
b: ty::Region<'tcx>,
|
||||
) -> RelateResult<'tcx, ty::Region<'tcx>> {
|
||||
debug!("{}.regions({:?}, {:?})", self.tag(), a, b);
|
||||
let origin = Subtype(Box::new(self.fields.trace.clone()));
|
||||
let origin = SubregionOrigin::Subtype(Box::new(self.fields.trace.clone()));
|
||||
self.fields
|
||||
.infcx
|
||||
.inner
|
||||
@ -16,7 +16,7 @@ use crate::infer::{InferCtxt, RegionVariableOrigin};
|
||||
/// Attempts to generalize `term` for the type variable `for_vid`.
|
||||
/// This checks for cycles -- that is, whether the type `term`
|
||||
/// references `for_vid`.
|
||||
pub(super) fn generalize<'tcx, D: GeneralizerDelegate<'tcx>, T: Into<Term<'tcx>> + Relate<'tcx>>(
|
||||
pub fn generalize<'tcx, D: GeneralizerDelegate<'tcx>, T: Into<Term<'tcx>> + Relate<'tcx>>(
|
||||
infcx: &InferCtxt<'tcx>,
|
||||
delegate: &mut D,
|
||||
term: T,
|
||||
@ -54,7 +54,7 @@ pub(super) fn generalize<'tcx, D: GeneralizerDelegate<'tcx>, T: Into<Term<'tcx>>
|
||||
|
||||
/// Abstracts the handling of region vars between HIR and MIR/NLL typechecking
|
||||
/// in the generalizer code.
|
||||
pub(super) trait GeneralizerDelegate<'tcx> {
|
||||
pub trait GeneralizerDelegate<'tcx> {
|
||||
fn param_env(&self) -> ty::ParamEnv<'tcx>;
|
||||
|
||||
fn forbid_inference_vars() -> bool;
|
||||
@ -64,7 +64,7 @@ pub(super) trait GeneralizerDelegate<'tcx> {
|
||||
fn generalize_region(&mut self, universe: ty::UniverseIndex) -> ty::Region<'tcx>;
|
||||
}
|
||||
|
||||
pub(super) struct CombineDelegate<'cx, 'tcx> {
|
||||
pub struct CombineDelegate<'cx, 'tcx> {
|
||||
pub infcx: &'cx InferCtxt<'tcx>,
|
||||
pub param_env: ty::ParamEnv<'tcx>,
|
||||
pub span: Span,
|
||||
@ -515,7 +515,7 @@ where
|
||||
/// not only the generalized type, but also a bool flag
|
||||
/// indicating whether further WF checks are needed.
|
||||
#[derive(Debug)]
|
||||
pub(super) struct Generalization<T> {
|
||||
pub struct Generalization<T> {
|
||||
/// When generalizing `<?0 as Trait>::Assoc` or
|
||||
/// `<T as Bar<<?0 as Foo>::Assoc>>::Assoc`
|
||||
/// for `?0` generalization returns an inference
|
||||
@ -524,7 +524,7 @@ pub(super) struct Generalization<T> {
|
||||
/// This has to be handled wotj care as it can
|
||||
/// otherwise very easily result in infinite
|
||||
/// recursion.
|
||||
pub(super) value_may_be_infer: T,
|
||||
pub value_may_be_infer: T,
|
||||
|
||||
/// If true, then the generalized type may not be well-formed,
|
||||
/// even if the source type is well-formed, so we should add an
|
||||
@ -551,5 +551,5 @@ pub(super) struct Generalization<T> {
|
||||
/// will force the calling code to check that `WF(Foo<?C, ?D>)`
|
||||
/// holds, which in turn implies that `?C::Item == ?D`. So once
|
||||
/// `?C` is constrained, that should suffice to restrict `?D`.
|
||||
pub(super) needs_wf: bool,
|
||||
pub needs_wf: bool,
|
||||
}
|
||||
@ -1,13 +1,12 @@
|
||||
//! Greatest lower bound. See [`lattice`].
|
||||
|
||||
use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
|
||||
use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
|
||||
|
||||
use super::combine::{CombineFields, ObligationEmittingRelation};
|
||||
use super::lattice::{self, LatticeDir};
|
||||
use super::Subtype;
|
||||
use super::{DefineOpaqueTypes, InferCtxt};
|
||||
|
||||
use crate::infer::{DefineOpaqueTypes, InferCtxt, SubregionOrigin};
|
||||
use crate::traits::{ObligationCause, PredicateObligations};
|
||||
use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
|
||||
use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
|
||||
|
||||
/// "Greatest lower bound" (common subtype)
|
||||
pub struct Glb<'combine, 'infcx, 'tcx> {
|
||||
@ -68,7 +67,7 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
|
||||
) -> RelateResult<'tcx, ty::Region<'tcx>> {
|
||||
debug!("{}.regions({:?}, {:?})", self.tag(), a, b);
|
||||
|
||||
let origin = Subtype(Box::new(self.fields.trace.clone()));
|
||||
let origin = SubregionOrigin::Subtype(Box::new(self.fields.trace.clone()));
|
||||
// GLB(&'static u8, &'a u8) == &RegionLUB('static, 'a) u8 == &'static u8
|
||||
Ok(self.fields.infcx.inner.borrow_mut().unwrap_region_constraints().lub_regions(
|
||||
self.tcx(),
|
||||
@ -2,8 +2,8 @@
|
||||
//! the end of the file for details.
|
||||
|
||||
use super::combine::CombineFields;
|
||||
use super::{HigherRankedType, InferCtxt};
|
||||
use crate::infer::CombinedSnapshot;
|
||||
use crate::infer::{HigherRankedType, InferCtxt};
|
||||
use rustc_middle::ty::fold::FnMutDelegate;
|
||||
use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
|
||||
use rustc_middle::ty::{self, Binder, Ty, TyCtxt, TypeFoldable};
|
||||
@ -18,10 +18,10 @@
|
||||
//! [lattices]: https://en.wikipedia.org/wiki/Lattice_(order)
|
||||
|
||||
use super::combine::ObligationEmittingRelation;
|
||||
use super::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
|
||||
use super::{DefineOpaqueTypes, InferCtxt};
|
||||
|
||||
use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
|
||||
use crate::infer::{DefineOpaqueTypes, InferCtxt};
|
||||
use crate::traits::ObligationCause;
|
||||
|
||||
use rustc_middle::ty::relate::RelateResult;
|
||||
use rustc_middle::ty::TyVar;
|
||||
use rustc_middle::ty::{self, Ty};
|
||||
@ -2,10 +2,9 @@
|
||||
|
||||
use super::combine::{CombineFields, ObligationEmittingRelation};
|
||||
use super::lattice::{self, LatticeDir};
|
||||
use super::Subtype;
|
||||
use super::{DefineOpaqueTypes, InferCtxt};
|
||||
|
||||
use crate::infer::{DefineOpaqueTypes, InferCtxt, SubregionOrigin};
|
||||
use crate::traits::{ObligationCause, PredicateObligations};
|
||||
|
||||
use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
|
||||
use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
|
||||
|
||||
@ -68,7 +67,7 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
|
||||
) -> RelateResult<'tcx, ty::Region<'tcx>> {
|
||||
debug!("{}.regions({:?}, {:?})", self.tag(), a, b);
|
||||
|
||||
let origin = Subtype(Box::new(self.fields.trace.clone()));
|
||||
let origin = SubregionOrigin::Subtype(Box::new(self.fields.trace.clone()));
|
||||
// LUB(&'static u8, &'a u8) == &RegionGLB('static, 'a) u8 == &'a u8
|
||||
Ok(self.fields.infcx.inner.borrow_mut().unwrap_region_constraints().glb_regions(
|
||||
self.tcx(),
|
||||
12
compiler/rustc_infer/src/infer/relate/mod.rs
Normal file
12
compiler/rustc_infer/src/infer/relate/mod.rs
Normal file
@ -0,0 +1,12 @@
|
||||
//! This module contains the definitions of most `TypeRelation`s in the type system
|
||||
//! (except for some relations used for diagnostics and heuristics in the compiler).
|
||||
|
||||
pub(super) mod combine;
|
||||
mod equate;
|
||||
pub(super) mod generalize;
|
||||
mod glb;
|
||||
mod higher_ranked;
|
||||
mod lattice;
|
||||
mod lub;
|
||||
pub mod nll;
|
||||
mod sub;
|
||||
@ -30,8 +30,8 @@ use rustc_middle::ty::{self, InferConst, Ty, TyCtxt};
|
||||
use rustc_span::{Span, Symbol};
|
||||
use std::fmt::Debug;
|
||||
|
||||
use crate::infer::combine::ObligationEmittingRelation;
|
||||
use crate::infer::generalize::{self, Generalization};
|
||||
use super::combine::ObligationEmittingRelation;
|
||||
use super::generalize::{self, Generalization};
|
||||
use crate::infer::InferCtxt;
|
||||
use crate::infer::{TypeVariableOrigin, TypeVariableOriginKind};
|
||||
use crate::traits::{Obligation, PredicateObligations};
|
||||
@ -1,7 +1,7 @@
|
||||
use super::combine::CombineFields;
|
||||
use super::{DefineOpaqueTypes, ObligationEmittingRelation, SubregionOrigin};
|
||||
|
||||
use crate::infer::{DefineOpaqueTypes, ObligationEmittingRelation, SubregionOrigin};
|
||||
use crate::traits::{Obligation, PredicateObligations};
|
||||
|
||||
use rustc_middle::ty::relate::{Cause, Relate, RelateResult, TypeRelation};
|
||||
use rustc_middle::ty::visit::TypeVisitableExt;
|
||||
use rustc_middle::ty::TyVar;
|
||||
@ -695,44 +695,41 @@ pub const fn type_name<T: ?Sized>() -> &'static str {
|
||||
intrinsics::type_name::<T>()
|
||||
}
|
||||
|
||||
/// Returns the name of the type of the pointed-to value as a string slice.
|
||||
/// Returns the type name of the pointed-to value as a string slice.
|
||||
///
|
||||
/// This is the same as `type_name::<T>()`, but can be used where the type of a
|
||||
/// variable is not easily available.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This is intended for diagnostic use. The exact contents and format of the
|
||||
/// string are not specified, other than being a best-effort description of the
|
||||
/// type. For example, `type_name_of_val::<Option<String>>(None)` could return
|
||||
/// `"Option<String>"` or `"std::option::Option<std::string::String>"`, but not
|
||||
/// `"foobar"`. In addition, the output may change between versions of the
|
||||
/// compiler.
|
||||
/// Like [`type_name`], this is intended for diagnostic use and the exact output is not
|
||||
/// guaranteed. It provides a best-effort description, but the output may change between
|
||||
/// versions of the compiler.
|
||||
///
|
||||
/// This function does not resolve trait objects,
|
||||
/// meaning that `type_name_of_val(&7u32 as &dyn Debug)`
|
||||
/// may return `"dyn Debug"`, but not `"u32"`.
|
||||
/// In short: use this for debugging, avoid using the output to affect program behavior. More
|
||||
/// information is available at [`type_name`].
|
||||
///
|
||||
/// The type name should not be considered a unique identifier of a type;
|
||||
/// multiple types may share the same type name.
|
||||
///
|
||||
/// The current implementation uses the same infrastructure as compiler
|
||||
/// diagnostics and debuginfo, but this is not guaranteed.
|
||||
/// Additionally, this function does not resolve trait objects. This means that
|
||||
/// `type_name_of_val(&7u32 as &dyn Debug)` may return `"dyn Debug"`, but will not return `"u32"`
|
||||
/// at this time.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Prints the default integer and float types.
|
||||
///
|
||||
/// ```rust
|
||||
/// #![feature(type_name_of_val)]
|
||||
/// use std::any::type_name_of_val;
|
||||
///
|
||||
/// let x = 1;
|
||||
/// println!("{}", type_name_of_val(&x));
|
||||
/// let y = 1.0;
|
||||
/// println!("{}", type_name_of_val(&y));
|
||||
/// let s = "foo";
|
||||
/// let x: i32 = 1;
|
||||
/// let y: f32 = 1.0;
|
||||
///
|
||||
/// assert!(type_name_of_val(&s).contains("str"));
|
||||
/// assert!(type_name_of_val(&x).contains("i32"));
|
||||
/// assert!(type_name_of_val(&y).contains("f32"));
|
||||
/// ```
|
||||
#[must_use]
|
||||
#[unstable(feature = "type_name_of_val", issue = "66359")]
|
||||
#[stable(feature = "type_name_of_val", since = "CURRENT_RUSTC_VERSION")]
|
||||
#[rustc_const_unstable(feature = "const_type_name", issue = "63084")]
|
||||
pub const fn type_name_of_val<T: ?Sized>(_val: &T) -> &'static str {
|
||||
type_name::<T>()
|
||||
|
||||
@ -720,7 +720,8 @@ where
|
||||
/// type or mutability, in particular if the code is refactored.
|
||||
#[inline(always)]
|
||||
#[must_use]
|
||||
#[unstable(feature = "ptr_from_ref", issue = "106116")]
|
||||
#[stable(feature = "ptr_from_ref", since = "CURRENT_RUSTC_VERSION")]
|
||||
#[rustc_const_stable(feature = "ptr_from_ref", since = "CURRENT_RUSTC_VERSION")]
|
||||
#[rustc_never_returns_null_ptr]
|
||||
#[rustc_diagnostic_item = "ptr_from_ref"]
|
||||
pub const fn from_ref<T: ?Sized>(r: &T) -> *const T {
|
||||
@ -733,7 +734,9 @@ pub const fn from_ref<T: ?Sized>(r: &T) -> *const T {
|
||||
/// type or mutability, in particular if the code is refactored.
|
||||
#[inline(always)]
|
||||
#[must_use]
|
||||
#[unstable(feature = "ptr_from_ref", issue = "106116")]
|
||||
#[stable(feature = "ptr_from_ref", since = "CURRENT_RUSTC_VERSION")]
|
||||
#[rustc_const_stable(feature = "ptr_from_ref", since = "CURRENT_RUSTC_VERSION")]
|
||||
#[rustc_allow_const_fn_unstable(const_mut_refs)]
|
||||
#[rustc_never_returns_null_ptr]
|
||||
pub const fn from_mut<T: ?Sized>(r: &mut T) -> *mut T {
|
||||
r
|
||||
|
||||
@ -338,7 +338,6 @@
|
||||
#![feature(portable_simd)]
|
||||
#![feature(prelude_2024)]
|
||||
#![feature(ptr_as_uninit)]
|
||||
#![feature(ptr_from_ref)]
|
||||
#![feature(raw_os_nonzero)]
|
||||
#![feature(round_ties_even)]
|
||||
#![feature(slice_internals)]
|
||||
|
||||
@ -328,8 +328,8 @@ pub(super) fn write_shared(
|
||||
v.push_str(
|
||||
r#"\
|
||||
]'));
|
||||
if (typeof window !== 'undefined' && window.initSearch) {window.initSearch(searchIndex)};
|
||||
if (typeof exports !== 'undefined') {exports.searchIndex = searchIndex};
|
||||
if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
|
||||
else if (window.initSearch) window.initSearch(searchIndex);
|
||||
"#,
|
||||
);
|
||||
Ok(v.into_bytes())
|
||||
|
||||
@ -146,12 +146,8 @@ function createSrcSidebar() {
|
||||
}
|
||||
}
|
||||
|
||||
const lineNumbersRegex = /^#?(\d+)(?:-(\d+))?$/;
|
||||
|
||||
function highlightSrcLines(match) {
|
||||
if (typeof match === "undefined") {
|
||||
match = window.location.hash.match(lineNumbersRegex);
|
||||
}
|
||||
function highlightSrcLines() {
|
||||
const match = window.location.hash.match(/^#?(\d+)(?:-(\d+))?$/);
|
||||
if (!match) {
|
||||
return;
|
||||
}
|
||||
@ -233,12 +229,7 @@ const handleSrcHighlight = (function() {
|
||||
};
|
||||
}());
|
||||
|
||||
window.addEventListener("hashchange", () => {
|
||||
const match = window.location.hash.match(lineNumbersRegex);
|
||||
if (match) {
|
||||
return highlightSrcLines(match);
|
||||
}
|
||||
});
|
||||
window.addEventListener("hashchange", highlightSrcLines);
|
||||
|
||||
onEachLazy(document.getElementsByClassName("src-line-numbers"), el => {
|
||||
el.addEventListener("click", handleSrcHighlight);
|
||||
|
||||
24
tests/rustdoc-gui/globals.goml
Normal file
24
tests/rustdoc-gui/globals.goml
Normal file
@ -0,0 +1,24 @@
|
||||
// Make sure search stores its data in `window`
|
||||
// It needs to use a global to avoid racing on search-index.js and search.js
|
||||
// https://github.com/rust-lang/rust/pull/118961
|
||||
|
||||
// URL query
|
||||
go-to: "file://" + |DOC_PATH| + "/test_docs/index.html?search=sa'%3Bda'%3Bds"
|
||||
wait-for: "#search-tabs"
|
||||
assert-window-property-false: {"searchIndex": null}
|
||||
assert-window-property: {"srcIndex": null}
|
||||
|
||||
// Form input
|
||||
go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
|
||||
write: (".search-input", "Foo")
|
||||
press-key: 'Enter'
|
||||
wait-for: "#search-tabs"
|
||||
assert-window-property-false: {"searchIndex": null}
|
||||
assert-window-property: {"srcIndex": null}
|
||||
|
||||
// source sidebar
|
||||
go-to: "file://" + |DOC_PATH| + "/src/test_docs/lib.rs.html"
|
||||
click: "#src-sidebar-toggle"
|
||||
wait-for: "#src-sidebar details"
|
||||
assert-window-property-false: {"srcIndex": null}
|
||||
assert-window-property: {"searchIndex": null}
|
||||
@ -1,11 +1,11 @@
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!2_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!2_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!2_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!2_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!2_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!2_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!2_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!2_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
error[E0119]: conflicting implementations of trait `Overlap<for<'a> fn(&'a (), ())>` for type `for<'a> fn(&'a (), ())`
|
||||
--> $DIR/associated-type.rs:31:1
|
||||
|
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!3_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!3_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!3_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!3_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!3_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!3_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!3_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Projection, AliasTy { args: [*const ?1t, RePlaceholder(!3_BoundRegion { var: 0, kind: BrNamed(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), 'a) })], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) })
|
||||
error[E0119]: conflicting implementations of trait `Overlap<for<'a> fn(&'a (), _)>` for type `for<'a> fn(&'a (), _)`
|
||||
--> $DIR/associated-type.rs:31:1
|
||||
|
|
||||
|
||||
@ -6,7 +6,6 @@
|
||||
// check-pass
|
||||
// aux-build:use_by_macro.rs
|
||||
|
||||
#![feature(type_name_of_val)]
|
||||
extern crate use_by_macro;
|
||||
|
||||
use use_by_macro::*;
|
||||
|
||||
@ -1,7 +1,5 @@
|
||||
// check-pass
|
||||
|
||||
#![feature(ptr_from_ref)]
|
||||
|
||||
use std::ptr;
|
||||
|
||||
extern "C" fn c_fn() {}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:14:8
|
||||
--> $DIR/ptr_null_checks.rs:12:8
|
||||
|
|
||||
LL | if (fn_ptr as *mut ()).is_null() {}
|
||||
| ^------^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -10,7 +10,7 @@ LL | if (fn_ptr as *mut ()).is_null() {}
|
||||
= note: `#[warn(useless_ptr_null_checks)]` on by default
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:16:8
|
||||
--> $DIR/ptr_null_checks.rs:14:8
|
||||
|
|
||||
LL | if (fn_ptr as *const u8).is_null() {}
|
||||
| ^------^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -20,7 +20,7 @@ LL | if (fn_ptr as *const u8).is_null() {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:18:8
|
||||
--> $DIR/ptr_null_checks.rs:16:8
|
||||
|
|
||||
LL | if (fn_ptr as *const ()) == std::ptr::null() {}
|
||||
| ^------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -30,7 +30,7 @@ LL | if (fn_ptr as *const ()) == std::ptr::null() {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:20:8
|
||||
--> $DIR/ptr_null_checks.rs:18:8
|
||||
|
|
||||
LL | if (fn_ptr as *mut ()) == std::ptr::null_mut() {}
|
||||
| ^------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -40,7 +40,7 @@ LL | if (fn_ptr as *mut ()) == std::ptr::null_mut() {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:22:8
|
||||
--> $DIR/ptr_null_checks.rs:20:8
|
||||
|
|
||||
LL | if (fn_ptr as *const ()) == (0 as *const ()) {}
|
||||
| ^------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -50,7 +50,7 @@ LL | if (fn_ptr as *const ()) == (0 as *const ()) {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:24:8
|
||||
--> $DIR/ptr_null_checks.rs:22:8
|
||||
|
|
||||
LL | if <*const _>::is_null(fn_ptr as *const ()) {}
|
||||
| ^^^^^^^^^^^^^^^^^^^^------^^^^^^^^^^^^^^
|
||||
@ -60,7 +60,7 @@ LL | if <*const _>::is_null(fn_ptr as *const ()) {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:26:8
|
||||
--> $DIR/ptr_null_checks.rs:24:8
|
||||
|
|
||||
LL | if (fn_ptr as *mut fn() as *const fn() as *const ()).is_null() {}
|
||||
| ^------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -70,7 +70,7 @@ LL | if (fn_ptr as *mut fn() as *const fn() as *const ()).is_null() {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:28:8
|
||||
--> $DIR/ptr_null_checks.rs:26:8
|
||||
|
|
||||
LL | if (fn_ptr as *mut fn() as *const fn()).cast_mut().is_null() {}
|
||||
| ^------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -80,7 +80,7 @@ LL | if (fn_ptr as *mut fn() as *const fn()).cast_mut().is_null() {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:30:8
|
||||
--> $DIR/ptr_null_checks.rs:28:8
|
||||
|
|
||||
LL | if ((fn_ptr as *mut fn()).cast() as *const fn()).cast_mut().is_null() {}
|
||||
| ^^------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -90,7 +90,7 @@ LL | if ((fn_ptr as *mut fn()).cast() as *const fn()).cast_mut().is_null() {
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:32:8
|
||||
--> $DIR/ptr_null_checks.rs:30:8
|
||||
|
|
||||
LL | if (fn_ptr as fn() as *const ()).is_null() {}
|
||||
| ^--------------^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -100,7 +100,7 @@ LL | if (fn_ptr as fn() as *const ()).is_null() {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: function pointers are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:34:8
|
||||
--> $DIR/ptr_null_checks.rs:32:8
|
||||
|
|
||||
LL | if (c_fn as *const fn()).is_null() {}
|
||||
| ^----^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -110,7 +110,7 @@ LL | if (c_fn as *const fn()).is_null() {}
|
||||
= help: wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:38:8
|
||||
--> $DIR/ptr_null_checks.rs:36:8
|
||||
|
|
||||
LL | if (&mut 8 as *mut i32).is_null() {}
|
||||
| ^------^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -118,13 +118,13 @@ LL | if (&mut 8 as *mut i32).is_null() {}
|
||||
| expression has type `&mut i32`
|
||||
|
||||
warning: returned pointer of `from_mut` call is never null, so checking it for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:40:8
|
||||
--> $DIR/ptr_null_checks.rs:38:8
|
||||
|
|
||||
LL | if ptr::from_mut(&mut 8).is_null() {}
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:42:8
|
||||
--> $DIR/ptr_null_checks.rs:40:8
|
||||
|
|
||||
LL | if (&8 as *const i32).is_null() {}
|
||||
| ^--^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -132,25 +132,25 @@ LL | if (&8 as *const i32).is_null() {}
|
||||
| expression has type `&i32`
|
||||
|
||||
warning: returned pointer of `from_ref` call is never null, so checking it for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:44:8
|
||||
--> $DIR/ptr_null_checks.rs:42:8
|
||||
|
|
||||
LL | if ptr::from_ref(&8).is_null() {}
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
warning: returned pointer of `from_ref` call is never null, so checking it for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:46:8
|
||||
--> $DIR/ptr_null_checks.rs:44:8
|
||||
|
|
||||
LL | if ptr::from_ref(&8).cast_mut().is_null() {}
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
warning: returned pointer of `from_ref` call is never null, so checking it for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:48:8
|
||||
--> $DIR/ptr_null_checks.rs:46:8
|
||||
|
|
||||
LL | if (ptr::from_ref(&8).cast_mut() as *mut i32).is_null() {}
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:50:8
|
||||
--> $DIR/ptr_null_checks.rs:48:8
|
||||
|
|
||||
LL | if (&8 as *const i32) == std::ptr::null() {}
|
||||
| ^--^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -158,7 +158,7 @@ LL | if (&8 as *const i32) == std::ptr::null() {}
|
||||
| expression has type `&i32`
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:53:8
|
||||
--> $DIR/ptr_null_checks.rs:51:8
|
||||
|
|
||||
LL | if (ref_num as *const i32) == std::ptr::null() {}
|
||||
| ^-------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -166,7 +166,7 @@ LL | if (ref_num as *const i32) == std::ptr::null() {}
|
||||
| expression has type `&i32`
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:55:8
|
||||
--> $DIR/ptr_null_checks.rs:53:8
|
||||
|
|
||||
LL | if (b"\0" as *const u8).is_null() {}
|
||||
| ^-----^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -174,7 +174,7 @@ LL | if (b"\0" as *const u8).is_null() {}
|
||||
| expression has type `&[u8; 1]`
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:57:8
|
||||
--> $DIR/ptr_null_checks.rs:55:8
|
||||
|
|
||||
LL | if ("aa" as *const str).is_null() {}
|
||||
| ^----^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -182,7 +182,7 @@ LL | if ("aa" as *const str).is_null() {}
|
||||
| expression has type `&str`
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:59:8
|
||||
--> $DIR/ptr_null_checks.rs:57:8
|
||||
|
|
||||
LL | if (&[1, 2] as *const i32).is_null() {}
|
||||
| ^-------^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -190,7 +190,7 @@ LL | if (&[1, 2] as *const i32).is_null() {}
|
||||
| expression has type `&[i32; 2]`
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:61:8
|
||||
--> $DIR/ptr_null_checks.rs:59:8
|
||||
|
|
||||
LL | if (&mut [1, 2] as *mut i32) == std::ptr::null_mut() {}
|
||||
| ^-----------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -198,7 +198,7 @@ LL | if (&mut [1, 2] as *mut i32) == std::ptr::null_mut() {}
|
||||
| expression has type `&mut [i32; 2]`
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:63:8
|
||||
--> $DIR/ptr_null_checks.rs:61:8
|
||||
|
|
||||
LL | if (static_i32() as *const i32).is_null() {}
|
||||
| ^------------^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -206,7 +206,7 @@ LL | if (static_i32() as *const i32).is_null() {}
|
||||
| expression has type `&i32`
|
||||
|
||||
warning: references are not nullable, so checking them for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:65:8
|
||||
--> $DIR/ptr_null_checks.rs:63:8
|
||||
|
|
||||
LL | if (&*{ static_i32() } as *const i32).is_null() {}
|
||||
| ^------------------^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -214,13 +214,13 @@ LL | if (&*{ static_i32() } as *const i32).is_null() {}
|
||||
| expression has type `&i32`
|
||||
|
||||
warning: returned pointer of `as_ptr` call is never null, so checking it for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:69:8
|
||||
--> $DIR/ptr_null_checks.rs:67:8
|
||||
|
|
||||
LL | if ptr::NonNull::new(&mut 8).unwrap().as_ptr().is_null() {}
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
warning: returned pointer of `as_ptr` call is never null, so checking it for null will always return false
|
||||
--> $DIR/ptr_null_checks.rs:71:8
|
||||
--> $DIR/ptr_null_checks.rs:69:8
|
||||
|
|
||||
LL | if ptr::NonNull::<u8>::dangling().as_ptr().is_null() {}
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
@ -1,7 +1,5 @@
|
||||
// check-fail
|
||||
|
||||
#![feature(ptr_from_ref)]
|
||||
|
||||
extern "C" {
|
||||
// N.B., mutability can be easily incorrect in FFI calls -- as
|
||||
// in C, the default is mutable pointers.
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:19:16
|
||||
--> $DIR/reference_casting.rs:17:16
|
||||
|
|
||||
LL | let _num = &mut *(num as *const i32 as *mut i32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -8,7 +8,7 @@ LL | let _num = &mut *(num as *const i32 as *mut i32);
|
||||
= note: `#[deny(invalid_reference_casting)]` on by default
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:21:16
|
||||
--> $DIR/reference_casting.rs:19:16
|
||||
|
|
||||
LL | let _num = &mut *(num as *const i32).cast_mut();
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -16,7 +16,7 @@ LL | let _num = &mut *(num as *const i32).cast_mut();
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:23:16
|
||||
--> $DIR/reference_casting.rs:21:16
|
||||
|
|
||||
LL | let _num = &mut *std::ptr::from_ref(num).cast_mut();
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -24,7 +24,7 @@ LL | let _num = &mut *std::ptr::from_ref(num).cast_mut();
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:25:16
|
||||
--> $DIR/reference_casting.rs:23:16
|
||||
|
|
||||
LL | let _num = &mut *std::ptr::from_ref({ num }).cast_mut();
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -32,7 +32,7 @@ LL | let _num = &mut *std::ptr::from_ref({ num }).cast_mut();
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:27:16
|
||||
--> $DIR/reference_casting.rs:25:16
|
||||
|
|
||||
LL | let _num = &mut *{ std::ptr::from_ref(num) }.cast_mut();
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -40,7 +40,7 @@ LL | let _num = &mut *{ std::ptr::from_ref(num) }.cast_mut();
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:29:16
|
||||
--> $DIR/reference_casting.rs:27:16
|
||||
|
|
||||
LL | let _num = &mut *(std::ptr::from_ref({ num }) as *mut i32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -48,7 +48,7 @@ LL | let _num = &mut *(std::ptr::from_ref({ num }) as *mut i32);
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:31:16
|
||||
--> $DIR/reference_casting.rs:29:16
|
||||
|
|
||||
LL | let _num = &mut *(num as *const i32).cast::<i32>().cast_mut();
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -56,7 +56,7 @@ LL | let _num = &mut *(num as *const i32).cast::<i32>().cast_mut();
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:33:16
|
||||
--> $DIR/reference_casting.rs:31:16
|
||||
|
|
||||
LL | let _num = &mut *(num as *const i32).cast::<i32>().cast_mut().cast_const().cast_mut();
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -64,7 +64,7 @@ LL | let _num = &mut *(num as *const i32).cast::<i32>().cast_mut().cast_cons
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:35:16
|
||||
--> $DIR/reference_casting.rs:33:16
|
||||
|
|
||||
LL | let _num = &mut *(std::ptr::from_ref(static_u8()) as *mut i32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -72,7 +72,7 @@ LL | let _num = &mut *(std::ptr::from_ref(static_u8()) as *mut i32);
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:37:16
|
||||
--> $DIR/reference_casting.rs:35:16
|
||||
|
|
||||
LL | let _num = &mut *std::mem::transmute::<_, *mut i32>(num);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -80,7 +80,7 @@ LL | let _num = &mut *std::mem::transmute::<_, *mut i32>(num);
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:39:16
|
||||
--> $DIR/reference_casting.rs:37:16
|
||||
|
|
||||
LL | let _num = &mut *(std::mem::transmute::<_, *mut i32>(num) as *mut i32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -88,7 +88,7 @@ LL | let _num = &mut *(std::mem::transmute::<_, *mut i32>(num) as *mut i32);
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:41:16
|
||||
--> $DIR/reference_casting.rs:39:16
|
||||
|
|
||||
LL | let _num = &mut *std::cell::UnsafeCell::raw_get(
|
||||
| ________________^
|
||||
@ -100,7 +100,7 @@ LL | | );
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:47:16
|
||||
--> $DIR/reference_casting.rs:45:16
|
||||
|
|
||||
LL | let deferred = num as *const i32 as *mut i32;
|
||||
| ----------------------------- casting happend here
|
||||
@ -110,7 +110,7 @@ LL | let _num = &mut *deferred;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:50:16
|
||||
--> $DIR/reference_casting.rs:48:16
|
||||
|
|
||||
LL | let deferred = (std::ptr::from_ref(num) as *const i32 as *const i32).cast_mut() as *mut i32;
|
||||
| ---------------------------------------------------------------------------- casting happend here
|
||||
@ -120,7 +120,7 @@ LL | let _num = &mut *deferred;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:53:16
|
||||
--> $DIR/reference_casting.rs:51:16
|
||||
|
|
||||
LL | let deferred = (std::ptr::from_ref(num) as *const i32 as *const i32).cast_mut() as *mut i32;
|
||||
| ---------------------------------------------------------------------------- casting happend here
|
||||
@ -131,7 +131,7 @@ LL | let _num = &mut *deferred_rebind;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:55:16
|
||||
--> $DIR/reference_casting.rs:53:16
|
||||
|
|
||||
LL | let _num = &mut *(num as *const _ as usize as *mut i32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -139,7 +139,7 @@ LL | let _num = &mut *(num as *const _ as usize as *mut i32);
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:57:16
|
||||
--> $DIR/reference_casting.rs:55:16
|
||||
|
|
||||
LL | let _num = &mut *(std::mem::transmute::<_, *mut _>(num as *const i32) as *mut i32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -147,7 +147,7 @@ LL | let _num = &mut *(std::mem::transmute::<_, *mut _>(num as *const i32) a
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:64:16
|
||||
--> $DIR/reference_casting.rs:62:16
|
||||
|
|
||||
LL | let num = NUM as *const i32 as *mut i32;
|
||||
| ----------------------------- casting happend here
|
||||
@ -158,7 +158,7 @@ LL | let _num = &mut *num;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:68:16
|
||||
--> $DIR/reference_casting.rs:66:16
|
||||
|
|
||||
LL | let _num = &mut *(cell as *const _ as *mut i32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -167,7 +167,7 @@ LL | let _num = &mut *(cell as *const _ as *mut i32);
|
||||
= note: even for types with interior mutability, the only legal way to obtain a mutable pointer from a shared reference is through `UnsafeCell::get`
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:72:9
|
||||
--> $DIR/reference_casting.rs:70:9
|
||||
|
|
||||
LL | &mut *((this as *const _) as *mut _)
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -175,7 +175,7 @@ LL | &mut *((this as *const _) as *mut _)
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:77:18
|
||||
--> $DIR/reference_casting.rs:75:18
|
||||
|
|
||||
LL | unsafe { &mut *std::cell::UnsafeCell::raw_get(x as *const _ as *const _) }
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -183,7 +183,7 @@ LL | unsafe { &mut *std::cell::UnsafeCell::raw_get(x as *const _ as *con
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:82:18
|
||||
--> $DIR/reference_casting.rs:80:18
|
||||
|
|
||||
LL | unsafe { &mut *std::cell::UnsafeCell::raw_get(x as *const _ as *const _) }
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -191,7 +191,7 @@ LL | unsafe { &mut *std::cell::UnsafeCell::raw_get(x as *const _ as *con
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:92:5
|
||||
--> $DIR/reference_casting.rs:90:5
|
||||
|
|
||||
LL | *(a as *const _ as *mut _) = String::from("Replaced");
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -199,7 +199,7 @@ LL | *(a as *const _ as *mut _) = String::from("Replaced");
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:94:5
|
||||
--> $DIR/reference_casting.rs:92:5
|
||||
|
|
||||
LL | *(a as *const _ as *mut String) += " world";
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -207,7 +207,7 @@ LL | *(a as *const _ as *mut String) += " world";
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:96:5
|
||||
--> $DIR/reference_casting.rs:94:5
|
||||
|
|
||||
LL | *std::ptr::from_ref(num).cast_mut() += 1;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -215,7 +215,7 @@ LL | *std::ptr::from_ref(num).cast_mut() += 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:98:5
|
||||
--> $DIR/reference_casting.rs:96:5
|
||||
|
|
||||
LL | *std::ptr::from_ref({ num }).cast_mut() += 1;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -223,7 +223,7 @@ LL | *std::ptr::from_ref({ num }).cast_mut() += 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:100:5
|
||||
--> $DIR/reference_casting.rs:98:5
|
||||
|
|
||||
LL | *{ std::ptr::from_ref(num) }.cast_mut() += 1;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -231,7 +231,7 @@ LL | *{ std::ptr::from_ref(num) }.cast_mut() += 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:102:5
|
||||
--> $DIR/reference_casting.rs:100:5
|
||||
|
|
||||
LL | *(std::ptr::from_ref({ num }) as *mut i32) += 1;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -239,7 +239,7 @@ LL | *(std::ptr::from_ref({ num }) as *mut i32) += 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:104:5
|
||||
--> $DIR/reference_casting.rs:102:5
|
||||
|
|
||||
LL | *std::mem::transmute::<_, *mut i32>(num) += 1;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -247,7 +247,7 @@ LL | *std::mem::transmute::<_, *mut i32>(num) += 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:106:5
|
||||
--> $DIR/reference_casting.rs:104:5
|
||||
|
|
||||
LL | *(std::mem::transmute::<_, *mut i32>(num) as *mut i32) += 1;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -255,7 +255,7 @@ LL | *(std::mem::transmute::<_, *mut i32>(num) as *mut i32) += 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:108:5
|
||||
--> $DIR/reference_casting.rs:106:5
|
||||
|
|
||||
LL | / std::ptr::write(
|
||||
LL | |
|
||||
@ -267,7 +267,7 @@ LL | | );
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:113:5
|
||||
--> $DIR/reference_casting.rs:111:5
|
||||
|
|
||||
LL | *((&std::cell::UnsafeCell::new(0)) as *const _ as *mut i32) = 5;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -276,7 +276,7 @@ LL | *((&std::cell::UnsafeCell::new(0)) as *const _ as *mut i32) = 5;
|
||||
= note: even for types with interior mutability, the only legal way to obtain a mutable pointer from a shared reference is through `UnsafeCell::get`
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:117:5
|
||||
--> $DIR/reference_casting.rs:115:5
|
||||
|
|
||||
LL | let value = num as *const i32 as *mut i32;
|
||||
| ----------------------------- casting happend here
|
||||
@ -286,7 +286,7 @@ LL | *value = 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:121:5
|
||||
--> $DIR/reference_casting.rs:119:5
|
||||
|
|
||||
LL | let value = value as *mut i32;
|
||||
| ----------------- casting happend here
|
||||
@ -296,7 +296,7 @@ LL | *value = 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:124:5
|
||||
--> $DIR/reference_casting.rs:122:5
|
||||
|
|
||||
LL | let value = num as *const i32 as *mut i32;
|
||||
| ----------------------------- casting happend here
|
||||
@ -306,7 +306,7 @@ LL | *value = 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:127:5
|
||||
--> $DIR/reference_casting.rs:125:5
|
||||
|
|
||||
LL | let value = num as *const i32 as *mut i32;
|
||||
| ----------------------------- casting happend here
|
||||
@ -317,7 +317,7 @@ LL | *value_rebind = 1;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:129:5
|
||||
--> $DIR/reference_casting.rs:127:5
|
||||
|
|
||||
LL | *(num as *const i32).cast::<i32>().cast_mut() = 2;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -325,7 +325,7 @@ LL | *(num as *const i32).cast::<i32>().cast_mut() = 2;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:131:5
|
||||
--> $DIR/reference_casting.rs:129:5
|
||||
|
|
||||
LL | *(num as *const _ as usize as *mut i32) = 2;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
@ -333,7 +333,7 @@ LL | *(num as *const _ as usize as *mut i32) = 2;
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:133:5
|
||||
--> $DIR/reference_casting.rs:131:5
|
||||
|
|
||||
LL | let value = num as *const i32 as *mut i32;
|
||||
| ----------------------------- casting happend here
|
||||
@ -344,7 +344,7 @@ LL | std::ptr::write(value, 2);
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:135:5
|
||||
--> $DIR/reference_casting.rs:133:5
|
||||
|
|
||||
LL | let value = num as *const i32 as *mut i32;
|
||||
| ----------------------------- casting happend here
|
||||
@ -355,7 +355,7 @@ LL | std::ptr::write_unaligned(value, 2);
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:137:5
|
||||
--> $DIR/reference_casting.rs:135:5
|
||||
|
|
||||
LL | let value = num as *const i32 as *mut i32;
|
||||
| ----------------------------- casting happend here
|
||||
@ -366,7 +366,7 @@ LL | std::ptr::write_volatile(value, 2);
|
||||
= note: for more information, visit <https://doc.rust-lang.org/book/ch15-05-interior-mutability.html>
|
||||
|
||||
error: assigning to `&T` is undefined behavior, consider using an `UnsafeCell`
|
||||
--> $DIR/reference_casting.rs:141:9
|
||||
--> $DIR/reference_casting.rs:139:9
|
||||
|
|
||||
LL | *(this as *const _ as *mut _) = a;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
#![allow(dead_code)]
|
||||
#![feature(never_type)]
|
||||
#![feature(pointer_is_aligned)]
|
||||
#![feature(ptr_from_ref)]
|
||||
#![feature(strict_provenance)]
|
||||
|
||||
use std::mem::size_of;
|
||||
|
||||
@ -13,14 +13,14 @@ LL | #![feature(lazy_type_alias)]
|
||||
= note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
|
||||
= note: `#[warn(incomplete_features)]` on by default
|
||||
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [RePlaceholder(!1_BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [RePlaceholder(!1_BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [RePlaceholder(!1_BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [RePlaceholder(!1_BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [RePlaceholder(!1_BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [RePlaceholder(!1_BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [RePlaceholder(!1_BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [ReBound(DebruijnIndex(0), BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: Alias(Weak, AliasTy { args: [RePlaceholder(!1_BoundRegion { var: 0, kind: BrNamed(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), 'a) }), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) })
|
||||
error[E0119]: conflicting implementations of trait `Overlap<fn(_)>` for type `fn(_)`
|
||||
--> $DIR/issue-118950-root-region.rs:18:1
|
||||
|
|
||||
|
||||
@ -441,6 +441,14 @@ cc = ["@rust-lang/miri"]
|
||||
message = "Some changes occurred in need_type_info.rs"
|
||||
cc = ["@lcnr"]
|
||||
|
||||
[mentions."compiler/rustc_middle/src/ty/relate.rs"]
|
||||
message = "Type relation code was changed"
|
||||
cc = ["@compiler-errors", "@lcnr"]
|
||||
|
||||
[mentions."compiler/rustc_infer/src/infer/relate"]
|
||||
message = "Type relation code was changed"
|
||||
cc = ["@compiler-errors", "@lcnr"]
|
||||
|
||||
[mentions."compiler/rustc_middle/src/mir/interpret"]
|
||||
message = "Some changes occurred to the CTFE / Miri engine"
|
||||
cc = ["@rust-lang/miri"]
|
||||
@ -555,15 +563,15 @@ cc = ["@oli-obk", "@RalfJung", "@JakobDegen", "@davidtwco", "@celinval", "@vakar
|
||||
|
||||
[mentions."compiler/rustc_error_messages"]
|
||||
message = "`rustc_error_messages` was changed"
|
||||
cc = ["@davidtwco", "@compiler-errors", "@JohnTitor", "@TaKO8Ki"]
|
||||
cc = ["@davidtwco", "@compiler-errors", "@TaKO8Ki"]
|
||||
|
||||
[mentions."compiler/rustc_errors/src/translation.rs"]
|
||||
message = "`rustc_errors::translation` was changed"
|
||||
cc = ["@davidtwco", "@compiler-errors", "@JohnTitor", "@TaKO8Ki"]
|
||||
cc = ["@davidtwco", "@compiler-errors", "@TaKO8Ki"]
|
||||
|
||||
[mentions."compiler/rustc_macros/src/diagnostics"]
|
||||
message = "`rustc_macros::diagnostics` was changed"
|
||||
cc = ["@davidtwco", "@compiler-errors", "@JohnTitor", "@TaKO8Ki"]
|
||||
cc = ["@davidtwco", "@compiler-errors", "@TaKO8Ki"]
|
||||
|
||||
[mentions."compiler/stable_mir"]
|
||||
message = "This PR changes Stable MIR"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user