mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #118723 - matthiaskrgr:rollup-409e9u1, r=matthiaskrgr

Browse source 
Rollup of 6 pull requests

Successful merges:

 - #116420 (discard invalid spans in external blocks)
 - #118686 (Only check principal trait ref for object safety)
 - #118688 (Add method to get type of an Rvalue in StableMIR)
 - #118707 (Ping GuillaumeGomez for changes in rustc_codegen_gcc)
 - #118712 (targets: remove not-added {i386,i486}-unknown-linux-gnu)
 - #118719 (CFI: Add char to CFI integer normalization)

Failed merges:

 - #117586 (Uplift the (new solver) canonicalizer into `rustc_next_trait_solver`)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2023-12-07 22:30:24 +00:00
commit 370c91100c
15 changed files with 310 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_parse/src/errors.rs
View file

@ -1733,7 +1733,7 @@ pub(crate) struct ExternItemCannotBeConst {
#[primary_span] #[primary_span]
pub ident_span: Span, pub ident_span: Span,
#[suggestion(code = "static ", applicability = "machine-applicable")] #[suggestion(code = "static ", applicability = "machine-applicable")]
pub const_span: Span, pub const_span: Option<Span>,
} }
#[derive(Diagnostic)] #[derive(Diagnostic)]

4
compiler/rustc_parse/src/parser/item.rs
View file

@ -1139,9 +1139,11 @@ impl<'a> Parser<'a> {
Ok(kind) => kind, Ok(kind) => kind,
Err(kind) => match kind { Err(kind) => match kind {
ItemKind::Const(box ConstItem { ty, expr, .. }) => { ItemKind::Const(box ConstItem { ty, expr, .. }) => {
let const_span = Some(span.with_hi(ident.span.lo()))
.filter(|span| span.can_be_used_for_suggestions());
self.sess.emit_err(errors::ExternItemCannotBeConst { self.sess.emit_err(errors::ExternItemCannotBeConst {
ident_span: ident.span, ident_span: ident.span,
const_span: span.with_hi(ident.span.lo()), const_span,
}); });
ForeignItemKind::Static(ty, Mutability::Not, expr) ForeignItemKind::Static(ty, Mutability::Not, expr)
} }

18
compiler/rustc_smir/src/rustc_smir/context.rs
View file

@ -250,6 +250,13 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
tables.tcx.mk_ty_from_kind(internal_kind).stable(&mut *tables) tables.tcx.mk_ty_from_kind(internal_kind).stable(&mut *tables)
} }
#[allow(rustc::usage_of_qualified_ty)]
fn new_box_ty(&self, ty: stable_mir::ty::Ty) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut();
let inner = ty.internal(&mut *tables);
ty::Ty::new_box(tables.tcx, inner).stable(&mut *tables)
}
fn def_ty(&self, item: stable_mir::DefId) -> stable_mir::ty::Ty { fn def_ty(&self, item: stable_mir::DefId) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
tables.tcx.type_of(item.internal(&mut *tables)).instantiate_identity().stable(&mut *tables) tables.tcx.type_of(item.internal(&mut *tables)).instantiate_identity().stable(&mut *tables)
@ -276,6 +283,13 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
tables.types[ty].kind().stable(&mut *tables) tables.types[ty].kind().stable(&mut *tables)
} }
fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut();
let internal_kind = ty.internal(&mut *tables);
let internal_ty = tables.tcx.mk_ty_from_kind(internal_kind);
internal_ty.discriminant_ty(tables.tcx).stable(&mut *tables)
}
fn instance_body(&self, def: InstanceDef) -> Option<Body> { fn instance_body(&self, def: InstanceDef) -> Option<Body> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let instance = tables.instances[def]; let instance = tables.instances[def];
@ -308,9 +322,9 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
matches!(instance.def, ty::InstanceDef::DropGlue(_, None)) matches!(instance.def, ty::InstanceDef::DropGlue(_, None))
} }
fn mono_instance(&self, item: stable_mir::CrateItem) -> stable_mir::mir::mono::Instance { fn mono_instance(&self, def_id: stable_mir::DefId) -> stable_mir::mir::mono::Instance {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let def_id = tables[item.0]; let def_id = tables[def_id];
Instance::mono(tables.tcx, def_id).stable(&mut *tables) Instance::mono(tables.tcx, def_id).stable(&mut *tables)
} }

15
compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs
View file

@ -773,12 +773,7 @@ fn transform_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, options: TransformTyOptio
let mut ty = ty; let mut ty = ty;
match ty.kind() { match ty.kind() {
ty::Float(..) ty::Float(..) | ty::Str | ty::Never | ty::Foreign(..) | ty::CoroutineWitness(..) => {}
| ty::Char
| ty::Str
| ty::Never
| ty::Foreign(..)
| ty::CoroutineWitness(..) => {}
ty::Bool => { ty::Bool => {
if options.contains(EncodeTyOptions::NORMALIZE_INTEGERS) { if options.contains(EncodeTyOptions::NORMALIZE_INTEGERS) {
@ -792,6 +787,14 @@ fn transform_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, options: TransformTyOptio
} }
} }
ty::Char => {
if options.contains(EncodeTyOptions::NORMALIZE_INTEGERS) {
// Since #118032, char is guaranteed to have the same size, alignment, and function
// call ABI as u32 on all platforms.
ty = tcx.types.u32;
}
}
ty::Int(..) | ty::Uint(..) => { ty::Int(..) | ty::Uint(..) => {
if options.contains(EncodeTyOptions::NORMALIZE_INTEGERS) { if options.contains(EncodeTyOptions::NORMALIZE_INTEGERS) {
// Note: C99 7.18.2.4 requires uintptr_t and intptr_t to be at least 16-bit wide. // Note: C99 7.18.2.4 requires uintptr_t and intptr_t to be at least 16-bit wide.

8
compiler/rustc_target/src/spec/targets/i386_unknown_linux_gnu.rs
View file

@ -1,8 +0,0 @@
use crate::spec::Target;
pub fn target() -> Target {
let mut base = super::i686_unknown_linux_gnu::target();
base.cpu = "i386".into();
base.llvm_target = "i386-unknown-linux-gnu".into();
base
}

8
compiler/rustc_target/src/spec/targets/i486_unknown_linux_gnu.rs
View file

@ -1,8 +0,0 @@
use crate::spec::Target;
pub fn target() -> Target {
let mut base = super::i686_unknown_linux_gnu::target();
base.cpu = "i486".into();
base.llvm_target = "i486-unknown-linux-gnu".into();
base
}

17
compiler/rustc_trait_selection/src/traits/wf.rs
View file

@ -761,18 +761,15 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
let defer_to_coercion = self.tcx().features().object_safe_for_dispatch; let defer_to_coercion = self.tcx().features().object_safe_for_dispatch;
if !defer_to_coercion { if !defer_to_coercion {
let cause = self.cause(traits::WellFormed(None)); if let Some(principal) = data.principal_def_id() {
let component_traits = data.auto_traits().chain(data.principal_def_id()); self.out.push(traits::Obligation::with_depth(
let tcx = self.tcx(); self.tcx(),
self.out.extend(component_traits.map(|did| { self.cause(traits::WellFormed(None)),
traits::Obligation::with_depth(
tcx,
cause.clone(),
depth, depth,
param_env, param_env,
ty::Binder::dummy(ty::PredicateKind::ObjectSafe(did)), ty::Binder::dummy(ty::PredicateKind::ObjectSafe(principal)),
) ));
})); }
} }
} }

8
compiler/stable_mir/src/compiler_interface.rs
View file

@ -87,6 +87,9 @@ pub trait Context {
/// Create a new type from the given kind. /// Create a new type from the given kind.
fn new_rigid_ty(&self, kind: RigidTy) -> Ty; fn new_rigid_ty(&self, kind: RigidTy) -> Ty;
/// Create a new box type, `Box<T>`, for the given inner type `T`.
fn new_box_ty(&self, ty: Ty) -> Ty;
/// Returns the type of given crate item. /// Returns the type of given crate item.
fn def_ty(&self, item: DefId) -> Ty; fn def_ty(&self, item: DefId) -> Ty;
@ -102,6 +105,9 @@ pub trait Context {
/// Obtain the representation of a type. /// Obtain the representation of a type.
fn ty_kind(&self, ty: Ty) -> TyKind; fn ty_kind(&self, ty: Ty) -> TyKind;
// Get the discriminant Ty for this Ty if there's one.
fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty;
/// Get the body of an Instance which is already monomorphized. /// Get the body of an Instance which is already monomorphized.
fn instance_body(&self, instance: InstanceDef) -> Option<Body>; fn instance_body(&self, instance: InstanceDef) -> Option<Body>;
@ -119,7 +125,7 @@ pub trait Context {
/// Convert a non-generic crate item into an instance. /// Convert a non-generic crate item into an instance.
/// This function will panic if the item is generic. /// This function will panic if the item is generic.
fn mono_instance(&self, item: CrateItem) -> Instance; fn mono_instance(&self, def_id: DefId) -> Instance;
/// Item requires monomorphization. /// Item requires monomorphization.
fn requires_monomorphization(&self, def_id: DefId) -> bool; fn requires_monomorphization(&self, def_id: DefId) -> bool;

100
compiler/stable_mir/src/mir/body.rs
View file

@ -274,6 +274,38 @@ pub enum BinOp {
Offset, Offset,
} }
impl BinOp {
/// Return the type of this operation for the given input Ty.
/// This function does not perform type checking, and it currently doesn't handle SIMD.
pub fn ty(&self, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
assert!(lhs_ty.kind().is_primitive());
assert!(rhs_ty.kind().is_primitive());
match self {
BinOp::Add
| BinOp::AddUnchecked
| BinOp::Sub
| BinOp::SubUnchecked
| BinOp::Mul
| BinOp::MulUnchecked
| BinOp::Div
| BinOp::Rem
| BinOp::BitXor
| BinOp::BitAnd
| BinOp::BitOr => {
assert_eq!(lhs_ty, rhs_ty);
lhs_ty
}
BinOp::Shl | BinOp::ShlUnchecked | BinOp::Shr | BinOp::ShrUnchecked | BinOp::Offset => {
lhs_ty
}
BinOp::Eq | BinOp::Lt | BinOp::Le | BinOp::Ne | BinOp::Ge | BinOp::Gt => {
assert_eq!(lhs_ty, rhs_ty);
Ty::bool_ty()
}
}
}
}
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
pub enum UnOp { pub enum UnOp {
Not, Not,
@ -475,6 +507,63 @@ pub enum Rvalue {
Use(Operand), Use(Operand),
} }
impl Rvalue {
pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
match self {
Rvalue::Use(operand) => operand.ty(locals),
Rvalue::Repeat(operand, count) => {
Ok(Ty::new_array_with_const_len(operand.ty(locals)?, count.clone()))
}
Rvalue::ThreadLocalRef(did) => Ok(did.ty()),
Rvalue::Ref(reg, bk, place) => {
let place_ty = place.ty(locals)?;
Ok(Ty::new_ref(reg.clone(), place_ty, bk.to_mutable_lossy()))
}
Rvalue::AddressOf(mutability, place) => {
let place_ty = place.ty(locals)?;
Ok(Ty::new_ptr(place_ty, *mutability))
}
Rvalue::Len(..) => Ok(Ty::usize_ty()),
Rvalue::Cast(.., ty) => Ok(*ty),
Rvalue::BinaryOp(op, lhs, rhs) => {
let lhs_ty = lhs.ty(locals)?;
let rhs_ty = rhs.ty(locals)?;
Ok(op.ty(lhs_ty, rhs_ty))
}
Rvalue::CheckedBinaryOp(op, lhs, rhs) => {
let lhs_ty = lhs.ty(locals)?;
let rhs_ty = rhs.ty(locals)?;
let ty = op.ty(lhs_ty, rhs_ty);
Ok(Ty::new_tuple(&[ty, Ty::bool_ty()]))
}
Rvalue::UnaryOp(UnOp::Not | UnOp::Neg, operand) => operand.ty(locals),
Rvalue::Discriminant(place) => {
let place_ty = place.ty(locals)?;
place_ty
.kind()
.discriminant_ty()
.ok_or_else(|| error!("Expected a `RigidTy` but found: {place_ty:?}"))
}
Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
Ok(Ty::usize_ty())
}
Rvalue::Aggregate(ak, ops) => match *ak {
AggregateKind::Array(ty) => Ty::try_new_array(ty, ops.len() as u64),
AggregateKind::Tuple => Ok(Ty::new_tuple(
&ops.iter().map(|op| op.ty(locals)).collect::<Result<Vec<_>, _>>()?,
)),
AggregateKind::Adt(def, _, ref args, _, _) => Ok(def.ty_with_args(args)),
AggregateKind::Closure(def, ref args) => Ok(Ty::new_closure(def, args.clone())),
AggregateKind::Coroutine(def, ref args, mov) => {
Ok(Ty::new_coroutine(def, args.clone(), mov))
}
},
Rvalue::ShallowInitBox(_, ty) => Ok(Ty::new_box(*ty)),
Rvalue::CopyForDeref(place) => place.ty(locals),
}
}
}
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
pub enum AggregateKind { pub enum AggregateKind {
Array(Ty), Array(Ty),
@ -725,6 +814,17 @@ pub enum BorrowKind {
}, },
} }
impl BorrowKind {
pub fn to_mutable_lossy(self) -> Mutability {
match self {
BorrowKind::Mut { .. } => Mutability::Mut,
BorrowKind::Shared => Mutability::Not,
// FIXME: There's no type corresponding to a shallow borrow, so use `&` as an approximation.
BorrowKind::Fake => Mutability::Not,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum MutBorrowKind { pub enum MutBorrowKind {
Default, Default,

20
compiler/stable_mir/src/mir/mono.rs
View file

@ -150,8 +150,9 @@ impl TryFrom<CrateItem> for Instance {
fn try_from(item: CrateItem) -> Result<Self, Self::Error> { fn try_from(item: CrateItem) -> Result<Self, Self::Error> {
with(|context| { with(|context| {
if !context.requires_monomorphization(item.0) { let def_id = item.def_id();
Ok(context.mono_instance(item)) if !context.requires_monomorphization(def_id) {
Ok(context.mono_instance(def_id))
} else { } else {
Err(Error::new("Item requires monomorphization".to_string())) Err(Error::new("Item requires monomorphization".to_string()))
} }
@ -219,6 +220,21 @@ impl TryFrom<CrateItem> for StaticDef {
} }
} }
impl TryFrom<Instance> for StaticDef {
type Error = crate::Error;
fn try_from(value: Instance) -> Result<Self, Self::Error> {
StaticDef::try_from(CrateItem::try_from(value)?)
}
}
impl From<StaticDef> for Instance {
fn from(value: StaticDef) -> Self {
// A static definition should always be convertible to an instance.
with(|cx| cx.mono_instance(value.def_id()))
}
}
impl StaticDef { impl StaticDef {
/// Return the type of this static definition. /// Return the type of this static definition.
pub fn ty(&self) -> Ty { pub fn ty(&self) -> Ty {

61
compiler/stable_mir/src/ty.rs
View file

@ -31,15 +31,50 @@ impl Ty {
Ok(Ty::from_rigid_kind(RigidTy::Array(elem_ty, Const::try_from_target_usize(size)?))) Ok(Ty::from_rigid_kind(RigidTy::Array(elem_ty, Const::try_from_target_usize(size)?)))
} }
/// Create a new array type from Const length.
pub fn new_array_with_const_len(elem_ty: Ty, len: Const) -> Ty {
Ty::from_rigid_kind(RigidTy::Array(elem_ty, len))
}
/// Create a new pointer type. /// Create a new pointer type.
pub fn new_ptr(pointee_ty: Ty, mutability: Mutability) -> Ty { pub fn new_ptr(pointee_ty: Ty, mutability: Mutability) -> Ty {
Ty::from_rigid_kind(RigidTy::RawPtr(pointee_ty, mutability)) Ty::from_rigid_kind(RigidTy::RawPtr(pointee_ty, mutability))
} }
/// Create a new reference type.
pub fn new_ref(reg: Region, pointee_ty: Ty, mutability: Mutability) -> Ty {
Ty::from_rigid_kind(RigidTy::Ref(reg, pointee_ty, mutability))
}
/// Create a new pointer type.
pub fn new_tuple(tys: &[Ty]) -> Ty {
Ty::from_rigid_kind(RigidTy::Tuple(Vec::from(tys)))
}
/// Create a new closure type.
pub fn new_closure(def: ClosureDef, args: GenericArgs) -> Ty {
Ty::from_rigid_kind(RigidTy::Closure(def, args))
}
/// Create a new coroutine type.
pub fn new_coroutine(def: CoroutineDef, args: GenericArgs, mov: Movability) -> Ty {
Ty::from_rigid_kind(RigidTy::Coroutine(def, args, mov))
}
/// Create a new box type that represents `Box<T>`, for the given inner type `T`.
pub fn new_box(inner_ty: Ty) -> Ty {
with(|cx| cx.new_box_ty(inner_ty))
}
/// Create a type representing `usize`. /// Create a type representing `usize`.
pub fn usize_ty() -> Ty { pub fn usize_ty() -> Ty {
Ty::from_rigid_kind(RigidTy::Uint(UintTy::Usize)) Ty::from_rigid_kind(RigidTy::Uint(UintTy::Usize))
} }
/// Create a type representing `bool`.
pub fn bool_ty() -> Ty {
Ty::from_rigid_kind(RigidTy::Bool)
}
} }
impl Ty { impl Ty {
@ -209,6 +244,19 @@ impl TyKind {
matches!(self, TyKind::RigidTy(RigidTy::FnPtr(..))) matches!(self, TyKind::RigidTy(RigidTy::FnPtr(..)))
} }
pub fn is_primitive(&self) -> bool {
matches!(
self,
TyKind::RigidTy(
RigidTy::Bool
| RigidTy::Char
| RigidTy::Int(_)
| RigidTy::Uint(_)
| RigidTy::Float(_)
)
)
}
pub fn trait_principal(&self) -> Option<Binder<ExistentialTraitRef>> { pub fn trait_principal(&self) -> Option<Binder<ExistentialTraitRef>> {
if let TyKind::RigidTy(RigidTy::Dynamic(predicates, _, _)) = self { if let TyKind::RigidTy(RigidTy::Dynamic(predicates, _, _)) = self {
if let Some(Binder { value: ExistentialPredicate::Trait(trait_ref), bound_vars }) = if let Some(Binder { value: ExistentialPredicate::Trait(trait_ref), bound_vars }) =
@ -251,6 +299,7 @@ impl TyKind {
} }
/// Get the function signature for function like types (Fn, FnPtr, Closure, Coroutine) /// Get the function signature for function like types (Fn, FnPtr, Closure, Coroutine)
/// FIXME(closure)
pub fn fn_sig(&self) -> Option<PolyFnSig> { pub fn fn_sig(&self) -> Option<PolyFnSig> {
match self { match self {
TyKind::RigidTy(RigidTy::FnDef(def, args)) => Some(with(|cx| cx.fn_sig(*def, args))), TyKind::RigidTy(RigidTy::FnDef(def, args)) => Some(with(|cx| cx.fn_sig(*def, args))),
@ -258,6 +307,11 @@ impl TyKind {
_ => None, _ => None,
} }
} }
/// Get the discriminant type for this type.
pub fn discriminant_ty(&self) -> Option<Ty> {
self.rigid().map(|ty| with(|cx| cx.rigid_ty_discriminant_ty(ty)))
}
} }
pub struct TypeAndMut { pub struct TypeAndMut {
@ -289,6 +343,13 @@ pub enum RigidTy {
CoroutineWitness(CoroutineWitnessDef, GenericArgs), CoroutineWitness(CoroutineWitnessDef, GenericArgs),
} }
impl RigidTy {
/// Get the discriminant type for this type.
pub fn discriminant_ty(&self) -> Ty {
with(|cx| cx.rigid_ty_discriminant_ty(self))
}
}
impl From<RigidTy> for TyKind { impl From<RigidTy> for TyKind {
fn from(value: RigidTy) -> Self { fn from(value: RigidTy) -> Self {
TyKind::RigidTy(value) TyKind::RigidTy(value)

77
tests/codegen/sanitizer/cfi-normalize-integers.rs
View file

@ -6,78 +6,41 @@
#![crate_type="lib"] #![crate_type="lib"]
extern crate core; extern crate core;
use core::ffi::*;
pub fn foo0(_: bool) { } pub fn foo0(_: bool) { }
// CHECK: define{{.*}}foo0{{.*}}!type ![[TYPE0:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo0{{.*}}!type ![[TYPE0:[0-9]+]] !type !{{[0-9]+}}
pub fn foo1(_: bool, _: c_uchar) { } pub fn foo1(_: bool, _: bool) { }
// CHECK: define{{.*}}foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}}
pub fn foo2(_: bool, _: c_uchar, _: c_uchar) { } pub fn foo2(_: bool, _: bool, _: bool) { }
// CHECK: define{{.*}}foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}}
pub fn foo3(_: isize) { } pub fn foo3(_: char) { }
// CHECK: define{{.*}}foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}}
pub fn foo4(_: isize, _: c_long) { } pub fn foo4(_: char, _: char) { }
// CHECK: define{{.*}}foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}}
pub fn foo5(_: isize, _: c_long, _: c_longlong) { } pub fn foo5(_: char, _: char, _: char) { }
// CHECK: define{{.*}}foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}}
pub fn foo6(_: usize) { } pub fn foo6(_: isize) { }
// CHECK: define{{.*}}foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}}
pub fn foo7(_: usize, _: c_ulong) { } pub fn foo7(_: isize, _: isize) { }
// CHECK: define{{.*}}foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}}
pub fn foo8(_: usize, _: c_ulong, _: c_ulonglong) { } pub fn foo8(_: isize, _: isize, _: isize) { }
// CHECK: define{{.*}}foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}}
pub fn foo9(_: c_schar) { } pub fn foo9(_: (), _: usize) { }
// CHECK: define{{.*}}foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}}
pub fn foo10(_: c_char, _: c_schar) { } pub fn foo10(_: (), _: usize, _: usize) { }
// CHECK: define{{.*}}foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}}
pub fn foo11(_: c_char, _: c_schar, _: c_schar) { } pub fn foo11(_: (), _: usize, _: usize, _: usize) { }
// CHECK: define{{.*}}foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} // CHECK: define{{.*}}foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}}
pub fn foo12(_: c_int) { }
// CHECK: define{{.*}}foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}}
pub fn foo13(_: c_int, _: c_int) { }
// CHECK: define{{.*}}foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}}
pub fn foo14(_: c_int, _: c_int, _: c_int) { }
// CHECK: define{{.*}}foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}}
pub fn foo15(_: c_short) { }
// CHECK: define{{.*}}foo15{{.*}}!type ![[TYPE15:[0-9]+]] !type !{{[0-9]+}}
pub fn foo16(_: c_short, _: c_short) { }
// CHECK: define{{.*}}foo16{{.*}}!type ![[TYPE16:[0-9]+]] !type !{{[0-9]+}}
pub fn foo17(_: c_short, _: c_short, _: c_short) { }
// CHECK: define{{.*}}foo17{{.*}}!type ![[TYPE17:[0-9]+]] !type !{{[0-9]+}}
pub fn foo18(_: c_uint) { }
// CHECK: define{{.*}}foo18{{.*}}!type ![[TYPE18:[0-9]+]] !type !{{[0-9]+}}
pub fn foo19(_: c_uint, _: c_uint) { }
// CHECK: define{{.*}}foo19{{.*}}!type ![[TYPE19:[0-9]+]] !type !{{[0-9]+}}
pub fn foo20(_: c_uint, _: c_uint, _: c_uint) { }
// CHECK: define{{.*}}foo20{{.*}}!type ![[TYPE20:[0-9]+]] !type !{{[0-9]+}}
pub fn foo21(_: c_ushort) { }
// CHECK: define{{.*}}foo21{{.*}}!type ![[TYPE21:[0-9]+]] !type !{{[0-9]+}}
pub fn foo22(_: c_ushort, _: c_ushort) { }
// CHECK: define{{.*}}foo22{{.*}}!type ![[TYPE22:[0-9]+]] !type !{{[0-9]+}}
pub fn foo23(_: c_ushort, _: c_ushort, _: c_ushort) { }
// CHECK: define{{.*}}foo23{{.*}}!type ![[TYPE23:[0-9]+]] !type !{{[0-9]+}}
// CHECK: ![[TYPE0]] = !{i64 0, !"_ZTSFvu2u8E.normalized"} // CHECK: ![[TYPE0]] = !{i64 0, !"_ZTSFvu2u8E.normalized"}
// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu2u8S_E.normalized"} // CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu2u8S_E.normalized"}
// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu2u8S_S_E.normalized"} // CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu2u8S_S_E.normalized"}
// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64}}E.normalized"} // CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3u32E.normalized"}
// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64}}{{u3i32|u3i64|S_}}E.normalized"} // CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3u32S_E.normalized"}
// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64}}{{u3i32|u3i64|S_}}{{u3i64|S_|S0_}}E.normalized"} // CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3u32S_S_E.normalized"}
// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64}}E.normalized"} // CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}E.normalized"}
// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64}}{{u3u32|u3u64|S_}}E.normalized"} // CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}S_E.normalized"}
// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64}}{{u3u32|u3u64|S_}}{{u3u64|S_|S0_}}E.normalized"} // CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}S_S_E.normalized"}
// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu2i8E.normalized"} // CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvv{{u3u16|u3u32|u3u64|u4u128}}E.normalized"}
// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFv{{u2i8S_|u2u8u2i8}}E.normalized"} // CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvv{{u3u16|u3u32|u3u64|u4u128}}S_E.normalized"}
// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFv{{u2i8S_S_|u2u8u2i8S0_}}E.normalized"} // CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvv{{u3u16|u3u32|u3u64|u4u128}}S_S_E.normalized"}
// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64}}E.normalized"}
// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64}}S_E.normalized"}
// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64}}S_S_E.normalized"}
// CHECK: ![[TYPE15]] = !{i64 0, !"_ZTSFvu3i16E.normalized"}
// CHECK: ![[TYPE16]] = !{i64 0, !"_ZTSFvu3i16S_E.normalized"}
// CHECK: ![[TYPE17]] = !{i64 0, !"_ZTSFvu3i16S_S_E.normalized"}
// CHECK: ![[TYPE18]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64}}E.normalized"}
// CHECK: ![[TYPE19]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64}}S_E.normalized"}
// CHECK: ![[TYPE20]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64}}S_S_E.normalized"}
// CHECK: ![[TYPE21]] = !{i64 0, !"_ZTSFvu3u16E.normalized"}
// CHECK: ![[TYPE22]] = !{i64 0, !"_ZTSFvu3u16S_E.normalized"}
// CHECK: ![[TYPE23]] = !{i64 0, !"_ZTSFvu3u16S_S_E.normalized"}

21
tests/ui/extern/issue-116203.rs vendored Normal file
View file

@ -0,0 +1,21 @@
extern "C" {
thread_local! {
static FOO: u32 = 0;
//~^ error: extern items cannot be `const`
//~| error: incorrect `static` inside `extern` block
}
}
macro_rules! hello {
($name:ident) => {
const $name: () = ();
};
}
extern "C" {
hello! { yes }
//~^ error: extern items cannot be `const`
//~| error: incorrect `static` inside `extern` block
}
fn main() {}

46
tests/ui/extern/issue-116203.stderr vendored Normal file
View file

@ -0,0 +1,46 @@
error: extern items cannot be `const`
--> $DIR/issue-116203.rs:3:14
|
LL | static FOO: u32 = 0;
| ^^^
|
= note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
error: extern items cannot be `const`
--> $DIR/issue-116203.rs:16:14
|
LL | hello! { yes }
| ^^^
|
= note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
error: incorrect `static` inside `extern` block
--> $DIR/issue-116203.rs:3:14
|
LL | extern "C" {
| ---------- `extern` blocks define existing foreign statics and statics inside of them cannot have a body
LL | / thread_local! {
LL | | static FOO: u32 = 0;
| | ^^^ cannot have a body
LL | |
LL | |
LL | | }
| |_____- the invalid body
|
= note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
error: incorrect `static` inside `extern` block
--> $DIR/issue-116203.rs:16:14
|
LL | const $name: () = ();
| -- the invalid body
...
LL | extern "C" {
| ---------- `extern` blocks define existing foreign statics and statics inside of them cannot have a body
LL | hello! { yes }
| ^^^ cannot have a body
|
= note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
error: aborting due to 4 previous errors

2
triagebot.toml
View file

@ -431,7 +431,7 @@ changelog-branch = "master"
cc = ["@bjorn3"] cc = ["@bjorn3"]
[mentions."compiler/rustc_codegen_gcc"] [mentions."compiler/rustc_codegen_gcc"]
cc = ["@antoyo"] cc = ["@antoyo", "@GuillaumeGomez"]
[mentions."compiler/rustc_const_eval/src/interpret"] [mentions."compiler/rustc_const_eval/src/interpret"]
message = "Some changes occurred to the CTFE / Miri engine" message = "Some changes occurred to the CTFE / Miri engine"