bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #87029 - JohnTitor:rollup-0yapv7z, r=JohnTitor

Browse source 
Rollup of 5 pull requests

Successful merges:

 - #87006 (Revert the revert of renaming traits::VTable to ImplSource)
 - #87011 (avoid reentrant lock acquire when ThreadIds run out)
 - #87013 (Fix several ICEs related to malformed `#[repr(...)]` attributes)
 - #87020 (remove const_raw_ptr_to_usize_cast feature)
 - #87028 (Fix type: `'satic` -> `'static`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2021-07-10 16:41:26 +00:00
commit a31431fce7
44 changed files with 305 additions and 346 deletions
Download patch file Download diff file Expand all files Collapse all files

104
compiler/rustc_attr/src/builtin.rs
View file

@ -870,6 +870,23 @@ pub fn find_repr_attrs(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
sym::simd => Some(ReprSimd),
sym::transparent => Some(ReprTransparent),
sym::no_niche => Some(ReprNoNiche),
sym::align => {
let mut err = struct_span_err!(
diagnostic,
item.span(),
E0589,
"invalid `repr(align)` attribute: `align` needs an argument"
);
err.span_suggestion(
item.span(),
"supply an argument here",
"align(...)".to_string(),
Applicability::HasPlaceholders,
);
err.emit();
recognised = true;
None
}
name => int_type_of_word(name).map(ReprInt),
};
@ -891,33 +908,47 @@ pub fn find_repr_attrs(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
Ok(literal) => acc.push(ReprPacked(literal)),
Err(message) => literal_error = Some(message),
};
} else if matches!(name, sym::C | sym::simd | sym::transparent | sym::no_niche)
|| int_type_of_word(name).is_some()
{
recognised = true;
struct_span_err!(
diagnostic,
item.span(),
E0552,
"invalid representation hint: `{}` does not take a parenthesized argument list",
name.to_ident_string(),
).emit();
}
if let Some(literal_error) = literal_error {
struct_span_err!(
diagnostic,
item.span(),
E0589,
"invalid `repr(align)` attribute: {}",
"invalid `repr({})` attribute: {}",
name.to_ident_string(),
literal_error
)
.emit();
}
} else if let Some(meta_item) = item.meta_item() {
if meta_item.has_name(sym::align) {
if let MetaItemKind::NameValue(ref value) = meta_item.kind {
if let MetaItemKind::NameValue(ref value) = meta_item.kind {
if meta_item.has_name(sym::align) || meta_item.has_name(sym::packed) {
let name = meta_item.name_or_empty().to_ident_string();
recognised = true;
let mut err = struct_span_err!(
diagnostic,
item.span(),
E0693,
"incorrect `repr(align)` attribute format"
"incorrect `repr({})` attribute format",
name,
);
match value.kind {
ast::LitKind::Int(int, ast::LitIntType::Unsuffixed) => {
err.span_suggestion(
item.span(),
"use parentheses instead",
format!("align({})", int),
format!("{}({})", name, int),
Applicability::MachineApplicable,
);
}
@ -925,19 +956,76 @@ pub fn find_repr_attrs(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
err.span_suggestion(
item.span(),
"use parentheses instead",
format!("align({})", s),
format!("{}({})", name, s),
Applicability::MachineApplicable,
);
}
_ => {}
}
err.emit();
} else {
if matches!(
meta_item.name_or_empty(),
sym::C | sym::simd | sym::transparent | sym::no_niche
) || int_type_of_word(meta_item.name_or_empty()).is_some()
{
recognised = true;
struct_span_err!(
diagnostic,
meta_item.span,
E0552,
"invalid representation hint: `{}` does not take a value",
meta_item.name_or_empty().to_ident_string(),
)
.emit();
}
}
} else if let MetaItemKind::List(_) = meta_item.kind {
if meta_item.has_name(sym::align) {
recognised = true;
struct_span_err!(
diagnostic,
meta_item.span,
E0693,
"incorrect `repr(align)` attribute format: \
`align` takes exactly one argument in parentheses"
)
.emit();
} else if meta_item.has_name(sym::packed) {
recognised = true;
struct_span_err!(
diagnostic,
meta_item.span,
E0552,
"incorrect `repr(packed)` attribute format: \
`packed` takes exactly one parenthesized argument, \
or no parentheses at all"
)
.emit();
} else if matches!(
meta_item.name_or_empty(),
sym::C | sym::simd | sym::transparent | sym::no_niche
) || int_type_of_word(meta_item.name_or_empty()).is_some()
{
recognised = true;
struct_span_err!(
diagnostic,
meta_item.span,
E0552,
"invalid representation hint: `{}` does not take a parenthesized argument list",
meta_item.name_or_empty().to_ident_string(),
).emit();
}
}
}
if !recognised {
// Not a word we recognize
diagnostic.delay_span_bug(item.span(), "unrecognized representation hint");
// Not a word we recognize. This will be caught and reported by
// the `check_mod_attrs` pass, but this pass doesn't always run
// (e.g. if we only pretty-print the source), so we have to gate
// the `delay_span_bug` call as follows:
if sess.opts.pretty.map_or(true, |pp| pp.needs_analysis()) {
diagnostic.delay_span_bug(item.span(), "unrecognized representation hint");
}
}
}
}

3
compiler/rustc_feature/src/active.rs
View file

@ -416,9 +416,6 @@ declare_features! (
/// Allows accessing fields of unions inside `const` functions.
(active, const_fn_union, "1.27.0", Some(51909), None),
/// Allows casting raw pointers to `usize` during const eval.
(active, const_raw_ptr_to_usize_cast, "1.27.0", Some(51910), None),
/// Allows dereferencing raw pointers during const eval.
(active, const_raw_ptr_deref, "1.27.0", Some(51911), None),

4
compiler/rustc_feature/src/removed.rs
View file

@ -144,6 +144,10 @@ declare_features! (
(removed, external_doc, "1.54.0", Some(44732), None,
Some("use #[doc = include_str!(\"filename\")] instead, which handles macro invocations")),
/// Allows casting raw pointers to `usize` during const eval.
(removed, const_raw_ptr_to_usize_cast, "1.55.0", Some(51910), None,
Some("at compile-time, pointers do not have an integer value, so these casts cannot be properly supported")),
// -------------------------------------------------------------------------
// feature-group-end: removed features
// -------------------------------------------------------------------------

6
compiler/rustc_middle/src/traits/mod.rs
View file

@ -426,10 +426,10 @@ pub type SelectionResult<'tcx, T> = Result<Option<T>, SelectionError<'tcx>>;
/// impl Clone for i32 { ... } // Impl_3
///
/// fn foo<T: Clone>(concrete: Option<Box<i32>>, param: T, mixed: Option<T>) {
/// // Case A: Vtable points at a specific impl. Only possible when
/// // Case A: ImplSource points at a specific impl. Only possible when
/// // type is concretely known. If the impl itself has bounded
/// // type parameters, Vtable will carry resolutions for those as well:
/// concrete.clone(); // Vtable(Impl_1, [Vtable(Impl_2, [Vtable(Impl_3)])])
/// // type parameters, ImplSource will carry resolutions for those as well:
/// concrete.clone(); // ImpleSource(Impl_1, [ImplSource(Impl_2, [ImplSource(Impl_3)])])
///
/// // Case A: ImplSource points at a specific impl. Only possible when
/// // type is concretely known. If the impl itself has bounded

25
compiler/rustc_mir/src/transform/check_consts/ops.rs
View file

@ -397,6 +397,9 @@ impl NonConstOp for PanicNonStr {
}
}
/// Comparing raw pointers for equality.
/// Not currently intended to ever be allowed, even behind a feature gate: operation depends on
/// allocation base addresses that are not known at compile-time.
#[derive(Debug)]
pub struct RawPtrComparison;
impl NonConstOp for RawPtrComparison {
@ -430,20 +433,22 @@ impl NonConstOp for RawPtrDeref {
}
}
/// Casting raw pointer or function pointer to an integer.
/// Not currently intended to ever be allowed, even behind a feature gate: operation depends on
/// allocation base addresses that are not known at compile-time.
#[derive(Debug)]
pub struct RawPtrToIntCast;
impl NonConstOp for RawPtrToIntCast {
fn status_in_item(&self, _: &ConstCx<'_, '_>) -> Status {
Status::Unstable(sym::const_raw_ptr_to_usize_cast)
}
fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
feature_err(
&ccx.tcx.sess.parse_sess,
sym::const_raw_ptr_to_usize_cast,
span,
&format!("casting pointers to integers in {}s is unstable", ccx.const_kind(),),
)
let mut err = ccx
.tcx
.sess
.struct_span_err(span, "pointers cannot be cast to integers during const eval.");
err.note("at compile-time, pointers do not have an integer value");
err.note(
"avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior",
);
err
}
}

31
compiler/rustc_mir/src/transform/check_unsafety.rs
View file

@ -7,7 +7,6 @@ use rustc_hir::intravisit;
use rustc_hir::Node;
use rustc_middle::mir::visit::{MutatingUseContext, PlaceContext, Visitor};
use rustc_middle::mir::*;
use rustc_middle::ty::cast::CastTy;
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::{self, TyCtxt};
use rustc_session::lint::builtin::{UNSAFE_OP_IN_UNSAFE_FN, UNUSED_UNSAFE};
@ -18,7 +17,6 @@ use std::ops::Bound;
pub struct UnsafetyChecker<'a, 'tcx> {
body: &'a Body<'tcx>,
body_did: LocalDefId,
const_context: bool,
violations: Vec<UnsafetyViolation>,
source_info: SourceInfo,
tcx: TyCtxt<'tcx>,
@ -30,7 +28,6 @@ pub struct UnsafetyChecker<'a, 'tcx> {
impl<'a, 'tcx> UnsafetyChecker<'a, 'tcx> {
fn new(
const_context: bool,
body: &'a Body<'tcx>,
body_did: LocalDefId,
tcx: TyCtxt<'tcx>,
@ -39,7 +36,6 @@ impl<'a, 'tcx> UnsafetyChecker<'a, 'tcx> {
Self {
body,
body_did,
const_context,
violations: vec![],
source_info: SourceInfo::outermost(body.span),
tcx,
@ -136,25 +132,6 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
self.register_violations(&violations, &unsafe_blocks);
}
},
// casting pointers to ints is unsafe in const fn because the const evaluator cannot
// possibly know what the result of various operations like `address / 2` would be
// pointers during const evaluation have no integral address, only an abstract one
Rvalue::Cast(CastKind::Misc, ref operand, cast_ty)
if self.const_context && self.tcx.features().const_raw_ptr_to_usize_cast =>
{
let operand_ty = operand.ty(self.body, self.tcx);
let cast_in = CastTy::from_ty(operand_ty).expect("bad input type for cast");
let cast_out = CastTy::from_ty(cast_ty).expect("bad output type for cast");
match (cast_in, cast_out) {
(CastTy::Ptr(_) | CastTy::FnPtr, CastTy::Int(_)) => {
self.require_unsafe(
UnsafetyViolationKind::General,
UnsafetyViolationDetails::CastOfPointerToInt,
);
}
_ => {}
}
}
_ => {}
}
self.super_rvalue(rvalue, location);
@ -469,13 +446,7 @@ fn unsafety_check_result<'tcx>(
let param_env = tcx.param_env(def.did);
let id = tcx.hir().local_def_id_to_hir_id(def.did);
let const_context = match tcx.hir().body_owner_kind(id) {
hir::BodyOwnerKind::Closure => false,
hir::BodyOwnerKind::Fn => tcx.is_const_fn_raw(def.did.to_def_id()),
hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) => true,
};
let mut checker = UnsafetyChecker::new(const_context, body, def.did, tcx, param_env);
let mut checker = UnsafetyChecker::new(body, def.did, tcx, param_env);
checker.visit_body(&body);
check_unused_unsafe(tcx, def.did, &checker.used_unsafe, &mut checker.inherited_blocks);

2
compiler/rustc_mir/src/transform/inline.rs
View file

@ -284,7 +284,7 @@ impl Inliner<'tcx> {
&self,
callsite: &CallSite<'tcx>,
callee_attrs: &CodegenFnAttrs,
) -> Result<(), &'satic str> {
) -> Result<(), &'static str> {
if let InlineAttr::Never = callee_attrs.inline {
return Err("never inline hint");
}

21
compiler/rustc_mir_build/src/check_unsafety.rs
View file

@ -25,7 +25,6 @@ struct UnsafetyVisitor<'a, 'tcx> {
/// The `#[target_feature]` attributes of the body. Used for checking
/// calls to functions with `#[target_feature]` (RFC 2396).
body_target_features: &'tcx Vec<Symbol>,
is_const: bool,
in_possible_lhs_union_assign: bool,
in_union_destructure: bool,
}
@ -315,16 +314,6 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
(Bound::Unbounded, Bound::Unbounded) => {}
_ => self.requires_unsafe(expr.span, InitializingTypeWith),
},
ExprKind::Cast { source } => {
let source = &self.thir[source];
if self.tcx.features().const_raw_ptr_to_usize_cast
&& self.is_const
&& (source.ty.is_unsafe_ptr() || source.ty.is_fn_ptr())
&& expr.ty.is_integral()
{
self.requires_unsafe(expr.span, CastOfPointerToInt);
}
}
ExprKind::Closure {
closure_id,
substs: _,
@ -413,7 +402,6 @@ enum UnsafeOpKind {
CallToUnsafeFunction,
UseOfInlineAssembly,
InitializingTypeWith,
CastOfPointerToInt,
UseOfMutableStatic,
UseOfExternStatic,
DerefOfRawPointer,
@ -446,9 +434,6 @@ impl UnsafeOpKind {
"initializing a layout restricted type's field with a value outside the valid \
range is undefined behavior",
),
CastOfPointerToInt => {
("cast of pointer to int", "casting pointers to integers in constants")
}
UseOfMutableStatic => (
"use of mutable static",
"mutable statics can be mutated by multiple threads: aliasing violations or data \
@ -526,11 +511,6 @@ pub fn check_unsafety<'tcx>(tcx: TyCtxt<'tcx>, def: ty::WithOptConstParam<LocalD
let body_target_features = &tcx.codegen_fn_attrs(def.did).target_features;
let safety_context =
if body_unsafety.is_unsafe() { SafetyContext::UnsafeFn } else { SafetyContext::Safe };
let is_const = match tcx.hir().body_owner_kind(hir_id) {
hir::BodyOwnerKind::Closure => false,
hir::BodyOwnerKind::Fn => tcx.is_const_fn_raw(def.did.to_def_id()),
hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) => true,
};
let mut visitor = UnsafetyVisitor {
tcx,
thir,
@ -538,7 +518,6 @@ pub fn check_unsafety<'tcx>(tcx: TyCtxt<'tcx>, def: ty::WithOptConstParam<LocalD
hir_context: hir_id,
body_unsafety,
body_target_features,
is_const,
in_possible_lhs_union_assign: false,
in_union_destructure: false,
};

3
library/std/src/thread/mod.rs
View file

@ -999,11 +999,12 @@ impl ThreadId {
static mut COUNTER: u64 = 1;
unsafe {
let _guard = GUARD.lock();
let guard = GUARD.lock();
// If we somehow use up all our bits, panic so that we're not
// covering up subtle bugs of IDs being reused.
if COUNTER == u64::MAX {
drop(guard); // in case the panic handler ends up calling `ThreadId::new()`, avoid reentrant lock acquire.
panic!("failed to generate unique thread ID: bitspace exhausted");
}

4
src/test/ui/attributes/nonterminal-expansion.rs
View file

@ -2,7 +2,9 @@
macro_rules! pass_nonterminal {
($n:expr) => {
#[repr(align($n))] //~ ERROR expected unsuffixed literal or identifier, found `n!()`
#[repr(align($n))]
//~^ ERROR expected unsuffixed literal or identifier, found `n!()`
//~| ERROR incorrect `repr(align)` attribute format
struct S;
};
}

14
src/test/ui/attributes/nonterminal-expansion.stderr
View file

@ -9,5 +9,17 @@ LL | pass_nonterminal!(n!());
|
= note: this error originates in the macro `pass_nonterminal` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error
error[E0693]: incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
--> $DIR/nonterminal-expansion.rs:5:16
|
LL | #[repr(align($n))]
| ^^^^^^^^^
...
LL | pass_nonterminal!(n!());
| ------------------------ in this macro invocation
|
= note: this error originates in the macro `pass_nonterminal` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0693`.

19
src/test/ui/cast/cast-ptr-to-int-const.mir.stderr
View file

@ -1,19 +0,0 @@
error[E0133]: cast of pointer to int is unsafe and requires unsafe function or block
--> $DIR/cast-ptr-to-int-const.rs:10:9
|
LL | &Y as *const u32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cast of pointer to int
|
= note: casting pointers to integers in constants
error[E0133]: cast of pointer to int is unsafe and requires unsafe function or block
--> $DIR/cast-ptr-to-int-const.rs:17:5
|
LL | &0 as *const i32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cast of pointer to int
|
= note: casting pointers to integers in constants
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0133`.

19
src/test/ui/cast/cast-ptr-to-int-const.rs
View file

@ -1,19 +0,0 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![feature(const_raw_ptr_to_usize_cast)]
fn main() {
const Y: u32 = 0;
// Cast in `const` without `unsafe` block
const SAFE: usize = {
&Y as *const u32 as usize
//~^ ERROR cast of pointer to int is unsafe and requires unsafe
};
}
// Cast in `const fn` without `unsafe` block
const fn test() -> usize {
&0 as *const i32 as usize
//~^ ERROR cast of pointer to int is unsafe and requires unsafe
}

19
src/test/ui/cast/cast-ptr-to-int-const.thir.stderr
View file

@ -1,19 +0,0 @@
error[E0133]: cast of pointer to int is unsafe and requires unsafe function or block
--> $DIR/cast-ptr-to-int-const.rs:10:9
|
LL | &Y as *const u32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cast of pointer to int
|
= note: casting pointers to integers in constants
error[E0133]: cast of pointer to int is unsafe and requires unsafe function or block
--> $DIR/cast-ptr-to-int-const.rs:17:5
|
LL | &0 as *const i32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cast of pointer to int
|
= note: casting pointers to integers in constants
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0133`.

13
src/test/ui/cast/feature-gate-const_raw_ptr_to_usize_cast.rs
View file

@ -1,13 +0,0 @@
fn main() {
const X: usize = unsafe {
main as usize //~ ERROR casting pointers to integers in constants is unstable
};
const Y: u32 = 0;
const Z: usize = unsafe {
&Y as *const u32 as usize //~ ERROR is unstable
};
}
const fn test() -> usize {
&0 as *const i32 as usize //~ ERROR is unstable
}

30
src/test/ui/cast/feature-gate-const_raw_ptr_to_usize_cast.stderr
View file

@ -1,30 +0,0 @@
error[E0658]: casting pointers to integers in constants is unstable
--> $DIR/feature-gate-const_raw_ptr_to_usize_cast.rs:3:9
|
LL | main as usize
| ^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
error[E0658]: casting pointers to integers in constants is unstable
--> $DIR/feature-gate-const_raw_ptr_to_usize_cast.rs:7:9
|
LL | &Y as *const u32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
error[E0658]: casting pointers to integers in constant functions is unstable
--> $DIR/feature-gate-const_raw_ptr_to_usize_cast.rs:12:5
|
LL | &0 as *const i32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0658`.

13
src/test/ui/const-ptr/ptr_to_usize_cast.rs
View file

@ -1,13 +0,0 @@
#![feature(const_raw_ptr_to_usize_cast)]
fn main() {
const OK: usize = unsafe { 0 as *const i32 as usize };
const _ERROR: usize = unsafe { &0 as *const i32 as usize };
//~^ ERROR [const_err]
//~| NOTE cannot cast pointer to integer because it was not created by cast from integer
//~| NOTE
//~| NOTE `#[deny(const_err)]` on by default
//~| WARN this was previously accepted by the compiler but is being phased out
//~| NOTE see issue #71800
}

14
src/test/ui/const-ptr/ptr_to_usize_cast.stderr
View file

@ -1,14 +0,0 @@
error: any use of this value will cause an error
--> $DIR/ptr_to_usize_cast.rs:6:36
|
LL | const _ERROR: usize = unsafe { &0 as *const i32 as usize };
| -------------------------------^^^^^^^^^^^^^^^^^^^^^^^^^---
| |
| cannot cast pointer to integer because it was not created by cast from integer
|
= note: `#[deny(const_err)]` on by default
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error: aborting due to previous error

12
src/test/ui/consts/const-eval/const_raw_ptr_ops2.rs
View file

@ -1,15 +1,11 @@
#![feature(const_raw_ptr_to_usize_cast, const_raw_ptr_deref)]
#![feature(const_raw_ptr_deref)]
fn main() {}
// unconst and fine
const Y: usize = unsafe { 42usize as *const i32 as usize + 1 };
// unconst and bad, will thus error in miri
const Y2: usize = unsafe { &1 as *const i32 as usize + 1 }; //~ ERROR any use of this
//~| WARN this was previously accepted by the compiler but is being phased out
// unconst and fine
// fine
const Z: i32 = unsafe { *(&1 as *const i32) };
// unconst and bad, will thus error in miri
// bad, will thus error in miri
const Z2: i32 = unsafe { *(42 as *const i32) }; //~ ERROR any use of this value will cause
//~| WARN this was previously accepted by the compiler but is being phased out
const Z3: i32 = unsafe { *(44 as *const i32) }; //~ ERROR any use of this value will cause

19
src/test/ui/consts/const-eval/const_raw_ptr_ops2.stderr
View file

@ -1,28 +1,17 @@
error: any use of this value will cause an error
--> $DIR/const_raw_ptr_ops2.rs:8:28
|
LL | const Y2: usize = unsafe { &1 as *const i32 as usize + 1 };
| ---------------------------^^^^^^^^^^^^^^^^^^^^^^^^^-------
| |
| cannot cast pointer to integer because it was not created by cast from integer
|
= note: `#[deny(const_err)]` on by default
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error: any use of this value will cause an error
--> $DIR/const_raw_ptr_ops2.rs:13:26
--> $DIR/const_raw_ptr_ops2.rs:9:26
|
LL | const Z2: i32 = unsafe { *(42 as *const i32) };
| -------------------------^^^^^^^^^^^^^^^^^^^---
| |
| unable to turn bytes into a pointer
|
= note: `#[deny(const_err)]` on by default
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error: any use of this value will cause an error
--> $DIR/const_raw_ptr_ops2.rs:15:26
--> $DIR/const_raw_ptr_ops2.rs:11:26
|
LL | const Z3: i32 = unsafe { *(44 as *const i32) };
| -------------------------^^^^^^^^^^^^^^^^^^^---
@ -32,5 +21,5 @@ LL | const Z3: i32 = unsafe { *(44 as *const i32) };
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error: aborting due to 3 previous errors
error: aborting due to 2 previous errors

4
src/test/ui/consts/const-eval/issue-52442.rs
View file

@ -1,4 +0,0 @@
fn main() {
[(); { &loop { break } as *const _ as usize } ];
//~^ ERROR casting pointers to integers in constants is unstable
}

12
src/test/ui/consts/const-eval/issue-52442.stderr
View file

@ -1,12 +0,0 @@
error[E0658]: casting pointers to integers in constants is unstable
--> $DIR/issue-52442.rs:2:13
|
LL | [(); { &loop { break } as *const _ as usize } ];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

2
src/test/ui/consts/const-eval/match-test-ptr-null.rs
View file

@ -4,7 +4,7 @@ fn main() {
// bytes.
let _: [u8; 0] = [4; {
match &1 as *const i32 as usize {
//~^ ERROR casting pointers to integers in constants
//~^ ERROR pointers cannot be cast to integers during const eval
0 => 42,
n => n,
}

7
src/test/ui/consts/const-eval/match-test-ptr-null.stderr
View file

@ -1,12 +1,11 @@
error[E0658]: casting pointers to integers in constants is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/match-test-ptr-null.rs:6:15
|
LL | match &1 as *const i32 as usize {
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

2
src/test/ui/consts/const-eval/promoted_raw_ptr_ops.rs
View file

@ -1,4 +1,4 @@
#![feature(const_raw_ptr_to_usize_cast, const_raw_ptr_deref)]
#![feature(const_raw_ptr_deref)]
fn main() {
let x: &'static bool = &(42 as *const i32 == 43 as *const i32);

2
src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs
View file

@ -7,7 +7,7 @@ const unsafe extern "C" fn closure() -> fn() { || {} }
const unsafe extern "C" fn use_float() { 1.0 + 1.0; }
//~^ ERROR floating point arithmetic
const extern "C" fn ptr_cast(val: *const u8) { val as usize; }
//~^ ERROR casting pointers to integers
//~^ ERROR pointers cannot be cast to integers
fn main() {}

6
src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
View file

@ -25,14 +25,14 @@ LL | const unsafe extern "C" fn use_float() { 1.0 + 1.0; }
= note: see issue #57241 <https://github.com/rust-lang/rust/issues/57241> for more information
= help: add `#![feature(const_fn_floating_point_arithmetic)]` to the crate attributes to enable
error[E0658]: casting pointers to integers in constant functions is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/const-extern-fn-min-const-fn.rs:9:48
|
LL | const extern "C" fn ptr_cast(val: *const u8) { val as usize; }
| ^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error: aborting due to 4 previous errors

2
src/test/ui/consts/issue-17458.rs
View file

@ -1,5 +1,5 @@
static X: usize = unsafe { core::ptr::null::<usize>() as usize };
//~^ ERROR: casting pointers to integers in statics is unstable
//~^ ERROR: pointers cannot be cast to integers during const eval
fn main() {
assert_eq!(X, 0);

7
src/test/ui/consts/issue-17458.stderr
View file

@ -1,12 +1,11 @@
error[E0658]: casting pointers to integers in statics is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/issue-17458.rs:1:28
|
LL | static X: usize = unsafe { core::ptr::null::<usize>() as usize };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

8
src/test/ui/consts/issue-51559.rs
View file

@ -1,8 +0,0 @@
#![feature(const_raw_ptr_to_usize_cast)]
const BAR: *mut () = ((|| 3) as fn() -> i32) as *mut ();
pub const FOO: usize = unsafe { BAR as usize };
//~^ ERROR any use of this value will cause an error
//~| WARN this was previously accepted by the compiler but is being phased out
fn main() {}

14
src/test/ui/consts/issue-51559.stderr
View file

@ -1,14 +0,0 @@
error: any use of this value will cause an error
--> $DIR/issue-51559.rs:4:33
|
LL | pub const FOO: usize = unsafe { BAR as usize };
| --------------------------------^^^^^^^^^^^^---
| |
| cannot cast pointer to integer because it was not created by cast from integer
|
= note: `#[deny(const_err)]` on by default
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error: aborting due to previous error

2
src/test/ui/consts/issue-52023-array-size-pointer-cast.rs
View file

@ -1,3 +1,3 @@
fn main() {
let _ = [0; (&0 as *const i32) as usize]; //~ ERROR casting pointers to integers in constants
let _ = [0; (&0 as *const i32) as usize]; //~ ERROR pointers cannot be cast to integers during const eval
}

7
src/test/ui/consts/issue-52023-array-size-pointer-cast.stderr
View file

@ -1,12 +1,11 @@
error[E0658]: casting pointers to integers in constants is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/issue-52023-array-size-pointer-cast.rs:2:17
|
LL | let _ = [0; (&0 as *const i32) as usize];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

10
src/test/ui/consts/issue-52432.rs
View file

@ -1,10 +0,0 @@
#![feature(const_raw_ptr_to_usize_cast)]
fn main() {
[(); &(static |x| {}) as *const _ as usize];
//~^ ERROR: closures cannot be static
//~| ERROR: type annotations needed
[(); &(static || {}) as *const _ as usize];
//~^ ERROR: closures cannot be static
//~| ERROR evaluation of constant value failed
}

28
src/test/ui/consts/issue-52432.stderr
View file

@ -1,28 +0,0 @@
error[E0697]: closures cannot be static
--> $DIR/issue-52432.rs:4:12
|
LL | [(); &(static |x| {}) as *const _ as usize];
| ^^^^^^^^^^
error[E0697]: closures cannot be static
--> $DIR/issue-52432.rs:7:12
|
LL | [(); &(static || {}) as *const _ as usize];
| ^^^^^^^^^
error[E0282]: type annotations needed
--> $DIR/issue-52432.rs:4:20
|
LL | [(); &(static |x| {}) as *const _ as usize];
| ^ consider giving this closure parameter a type
error[E0080]: evaluation of constant value failed
--> $DIR/issue-52432.rs:7:10
|
LL | [(); &(static || {}) as *const _ as usize];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot cast pointer to integer because it was not created by cast from integer
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0080, E0282, E0697.
For more information about an error, try `rustc --explain E0080`.

8
src/test/ui/consts/min_const_fn/min_const_fn.rs
View file

@ -90,13 +90,13 @@ static BAR: u32 = 42;
const fn foo25() -> u32 { BAR } //~ ERROR cannot refer to statics
const fn foo26() -> &'static u32 { &BAR } //~ ERROR cannot refer to statics
const fn foo30(x: *const u32) -> usize { x as usize }
//~^ ERROR casting pointers to integers
//~^ ERROR pointers cannot be cast to integers
const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize } }
//~^ ERROR casting pointers to integers
//~^ ERROR pointers cannot be cast to integers
const fn foo30_2(x: *mut u32) -> usize { x as usize }
//~^ ERROR casting pointers to integers
//~^ ERROR pointers cannot be cast to integers
const fn foo30_2_with_unsafe(x: *mut u32) -> usize { unsafe { x as usize } }
//~^ ERROR casting pointers to integers
//~^ ERROR pointers cannot be cast to integers
const fn foo30_6() -> bool { let x = true; x }
const fn inc(x: &mut i32) { *x += 1 }
//~^ ERROR mutable references

24
src/test/ui/consts/min_const_fn/min_const_fn.stderr
View file

@ -164,41 +164,41 @@ LL | const fn foo26() -> &'static u32 { &BAR }
|
= help: consider extracting the value of the `static` to a `const`, and referring to that
error[E0658]: casting pointers to integers in constant functions is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/min_const_fn.rs:92:42
|
LL | const fn foo30(x: *const u32) -> usize { x as usize }
| ^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error[E0658]: casting pointers to integers in constant functions is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/min_const_fn.rs:94:63
|
LL | const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize } }
| ^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error[E0658]: casting pointers to integers in constant functions is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/min_const_fn.rs:96:42
|
LL | const fn foo30_2(x: *mut u32) -> usize { x as usize }
| ^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error[E0658]: casting pointers to integers in constant functions is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/min_const_fn.rs:98:63
|
LL | const fn foo30_2_with_unsafe(x: *mut u32) -> usize { unsafe { x as usize } }
| ^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error[E0658]: mutable references are not allowed in constant functions
--> $DIR/min_const_fn.rs:101:14

2
src/test/ui/issues/issue-18294.rs
View file

@ -1,5 +1,5 @@
fn main() {
const X: u32 = 1;
const Y: usize = unsafe { &X as *const u32 as usize }; //~ ERROR is unstable
const Y: usize = unsafe { &X as *const u32 as usize }; //~ ERROR pointers cannot be cast to integers
println!("{}", Y);
}

7
src/test/ui/issues/issue-18294.stderr
View file

@ -1,12 +1,11 @@
error[E0658]: casting pointers to integers in constants is unstable
error: pointers cannot be cast to integers during const eval.
--> $DIR/issue-18294.rs:3:31
|
LL | const Y: usize = unsafe { &X as *const u32 as usize };
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

34
src/test/ui/repr/issue-83921-ice.rs Normal file
View file

@ -0,0 +1,34 @@
// Regression test for various ICEs inspired by
// https://github.com/rust-lang/rust/issues/83921#issuecomment-814640734
// compile-flags: -Zdeduplicate-diagnostics=yes
#[repr(packed())]
//~^ ERROR: incorrect `repr(packed)` attribute format
struct S1;
#[repr(align)]
//~^ ERROR: invalid `repr(align)` attribute
struct S2;
#[repr(align(2, 4))]
//~^ ERROR: incorrect `repr(align)` attribute format
struct S3;
#[repr(align())]
//~^ ERROR: incorrect `repr(align)` attribute format
struct S4;
#[repr(i8())]
//~^ ERROR: invalid representation hint
enum E1 { A, B }
#[repr(u32(42))]
//~^ ERROR: invalid representation hint
enum E2 { A, B }
#[repr(i64 = 2)]
//~^ ERROR: invalid representation hint
enum E3 { A, B }
fn main() {}

46
src/test/ui/repr/issue-83921-ice.stderr Normal file
View file

@ -0,0 +1,46 @@
error[E0552]: incorrect `repr(packed)` attribute format: `packed` takes exactly one parenthesized argument, or no parentheses at all
--> $DIR/issue-83921-ice.rs:6:8
|
LL | #[repr(packed())]
| ^^^^^^^^
error[E0589]: invalid `repr(align)` attribute: `align` needs an argument
--> $DIR/issue-83921-ice.rs:10:8
|
LL | #[repr(align)]
| ^^^^^ help: supply an argument here: `align(...)`
error[E0693]: incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
--> $DIR/issue-83921-ice.rs:14:8
|
LL | #[repr(align(2, 4))]
| ^^^^^^^^^^^
error[E0693]: incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
--> $DIR/issue-83921-ice.rs:18:8
|
LL | #[repr(align())]
| ^^^^^^^
error[E0552]: invalid representation hint: `i8` does not take a parenthesized argument list
--> $DIR/issue-83921-ice.rs:22:8
|
LL | #[repr(i8())]
| ^^^^
error[E0552]: invalid representation hint: `u32` does not take a parenthesized argument list
--> $DIR/issue-83921-ice.rs:26:8
|
LL | #[repr(u32(42))]
| ^^^^^^^
error[E0552]: invalid representation hint: `i64` does not take a value
--> $DIR/issue-83921-ice.rs:30:8
|
LL | #[repr(i64 = 2)]
| ^^^^^^^
error: aborting due to 7 previous errors
Some errors have detailed explanations: E0552, E0589, E0693.
For more information about an error, try `rustc --explain E0552`.

9
src/test/ui/repr/issue-83921-pretty.normal.stderr Normal file
View file

@ -0,0 +1,9 @@
error[E0565]: meta item in `repr` must be an identifier
--> $DIR/issue-83921-pretty.rs:10:8
|
LL | #[repr("C")]
| ^^^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0565`.

19
src/test/ui/repr/issue-83921-pretty.pretty.stdout Normal file
View file

@ -0,0 +1,19 @@
#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use ::std::prelude::rust_2015::*;
#[macro_use]
extern crate std;
// Regression test for #83921. A `delay_span_bug()` call was issued, but the
// error was never reported because the pass responsible for detecting and
// reporting the error does not run in certain modes of pretty-printing.
// Make sure the error is reported if we do not just pretty-print:
// revisions: pretty normal
// [pretty]compile-flags: -Zunpretty=everybody_loops
// [pretty]check-pass
#[repr("C")]
struct A {
}
fn main() { loop { } }

14
src/test/ui/repr/issue-83921-pretty.rs Normal file
View file

@ -0,0 +1,14 @@
// Regression test for #83921. A `delay_span_bug()` call was issued, but the
// error was never reported because the pass responsible for detecting and
// reporting the error does not run in certain modes of pretty-printing.
// Make sure the error is reported if we do not just pretty-print:
// revisions: pretty normal
// [pretty]compile-flags: -Zunpretty=everybody_loops
// [pretty]check-pass
#[repr("C")]
//[normal]~^ ERROR: meta item in `repr` must be an identifier [E0565]
struct A {}
fn main() {}