Merge ref \'733108b6d4ac\' from rust-lang/rust\n\nPull recent changes from https://github.com/rust-lang/rust via Josh.\n\nUpstream ref: 733108b6d4acaa93fe26ae281ea305aacd6aac4e\nFiltered ref: f3289ac\nUpstream diff: https://github.com/rust-lang/rust/compare/...733108b6d4acaa93fe26ae281ea305aacd6aac4e\n\nThis merge was created using https://github.com/rust-lang/josh-sync.\n

Author: makai410

rustc_public/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly-2023-06-14"
+components = [ "rustfmt", "rustc-dev" ]

rustc_public/src/compiler_interface.rs

@@ -8,10 +8,7 @@
 
 #![allow(rustc::usage_of_ty_tykind)]
 #![cfg_attr(not(feature = "rustc-build"), feature(rustc_private))]
-#![doc(
-    html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/",
-    test(attr(allow(unused_variables), deny(warnings)))
-)]
+#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
 #![feature(sized_hierarchy)]
 //!
 //! This crate shall contain all type definitions and APIs that we expect third-party tools to invoke to

rustc_public/src/lib.rs

@@ -478,7 +478,6 @@ pub enum StatementKind {
     Assign(Place, Rvalue),
     FakeRead(FakeReadCause, Place),
     SetDiscriminant { place: Place, variant_index: VariantIdx },
-    Deinit(Place),
     StorageLive(Local),
     StorageDead(Local),
     Retag(RetagKind, Place),
@@ -642,11 +641,8 @@ impl Rvalue {
                     .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::NullaryOp(NullOp::ContractChecks, _)
-            | Rvalue::NullaryOp(NullOp::UbChecks, _) => Ok(Ty::bool_ty()),
+            Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => Ok(Ty::usize_ty()),
+            Rvalue::NullaryOp(NullOp::RuntimeChecks(_), _) => Ok(Ty::bool_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(
@@ -836,14 +832,6 @@ pub enum ProjectionElem {
     /// Like an explicit cast from an opaque type to a concrete type, but without
     /// requiring an intermediate variable.
     OpaqueCast(Ty),
-
-    /// A `Subtype(T)` projection is applied to any `StatementKind::Assign` where
-    /// type of lvalue doesn't match the type of rvalue, the primary goal is making subtyping
-    /// explicit during optimizations and codegen.
-    ///
-    /// This projection doesn't impact the runtime behavior of the program except for potentially changing
-    /// some type metadata of the interpreter or codegen backend.
-    Subtype(Ty),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
@@ -1028,20 +1016,25 @@ pub enum CastKind {
     PtrToPtr,
     FnPtrToPtr,
     Transmute,
+    Subtype,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
 pub enum NullOp {
-    /// Returns the size of a value of that type.
-    SizeOf,
-    /// Returns the minimum alignment of a type.
-    AlignOf,
     /// Returns the offset of a field.
     OffsetOf(Vec<(VariantIdx, FieldIdx)>),
+    /// Codegen conditions for runtime checks.
+    RuntimeChecks(RuntimeChecks),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
+pub enum RuntimeChecks {
     /// cfg!(ub_checks), but at codegen time
     UbChecks,
     /// cfg!(contract_checks), but at codegen time
     ContractChecks,
+    /// cfg!(overflow_checks), but at codegen time
+    OverflowChecks,
 }
 
 impl Operand {
@@ -1089,7 +1082,7 @@ impl ProjectionElem {
                 Self::subslice_ty(ty, *from, *to, *from_end)
             }
             ProjectionElem::Downcast(_) => Ok(ty),
-            ProjectionElem::OpaqueCast(ty) | ProjectionElem::Subtype(ty) => Ok(*ty),
+            ProjectionElem::OpaqueCast(ty) => Ok(*ty),
         }
     }
 

rustc_public/src/mir/body.rs

@@ -183,6 +183,7 @@ macro_rules! make_mir_visitor {
                     }
                     StatementKind::Coverage(coverage) => visit_opaque(coverage),
                     StatementKind::Intrinsic(intrisic) => match intrisic {
+                    StatementKind::Intrinsic(intrinsic) => match intrinsic {
                         NonDivergingIntrinsic::Assume(operand) => {
                             self.visit_operand(operand, location);
                         }

rustc_public/src/mir/visit.rs

@@ -12,6 +12,15 @@ use rustc_span::def_id::CrateNum;
 use scoped_tls::scoped_thread_local;
 
 use crate::Error;
+use std::cell::RefCell;
+
+use rustc_middle::ty::TyCtxt;
+use rustc_public_bridge::Tables;
+use rustc_public_bridge::context::CompilerCtxt;
+use rustc_span::def_id::CrateNum;
+
+use crate::Error;
+use crate::compiler_interface::{BridgeTys, CompilerInterface, with};
 use crate::unstable::{RustcInternal, Stable};
 
 pub mod pretty;
@@ -29,6 +38,7 @@ pub mod pretty;
 /// This function will panic if rustc_public has not been properly initialized.
 pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T {
     with_container(|tables, cx| item.stable(tables, cx))
+    with_bridge(|tables, cx| item.stable(tables, cx))
 }
 
 /// Convert a stable item into its internal Rust compiler counterpart, if one exists.
@@ -50,6 +60,7 @@ where
     // See https://github.com/rust-lang/rust/pull/120128/commits/9aace6723572438a94378451793ca37deb768e72
     // for more details.
     with_container(|tables, _| item.internal(tables, tcx))
+    with_bridge(|tables, _| item.internal(tables, tcx))
 }
 
 pub fn crate_num(item: &crate::Crate) -> CrateNum {
@@ -81,6 +92,14 @@ pub(crate) fn with_container<R, B: Bridge>(
         let container = ptr as *const Container<'_, B>;
         let mut tables = unsafe { (*container).tables.borrow_mut() };
         let cx = unsafe { (*container).cx.borrow() };
+/// Loads the current context and calls a function with it.
+/// Do not nest these, as that will ICE.
+pub(crate) fn with_bridge<R>(
+    f: impl for<'tcx> FnOnce(&mut Tables<'tcx, BridgeTys>, &CompilerCtxt<'tcx, BridgeTys>) -> R,
+) -> R {
+    with(|compiler| {
+        let mut tables = compiler.tables.borrow_mut();
+        let cx = compiler.cx.borrow();
         f(&mut *tables, &*cx)
     })
 }
@@ -93,6 +112,10 @@ where
     let container = Container { tables: RefCell::new(Tables::default()), cx: compiler_cx };
 
     crate::compiler_interface::run(&container, || init(&container, f))
+    let compiler_interface =
+        CompilerInterface { tables: RefCell::new(Tables::default()), cx: compiler_cx };
+
+    crate::compiler_interface::run(&compiler_interface, || f())
 }
 
 /// Instantiate and run the compiler with the provided arguments and callback.

rustc_public/src/rustc_internal/mod.rs

@@ -334,6 +334,7 @@ impl TyKind {
     #[inline]
     pub fn is_trait(&self) -> bool {
         matches!(self, TyKind::RigidTy(RigidTy::Dynamic(_, _, DynKind::Dyn)))
+        matches!(self, TyKind::RigidTy(RigidTy::Dynamic(_, _)))
     }
 
     #[inline]
@@ -473,6 +474,7 @@ impl TyKind {
 
     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 }) =
                 predicates.first()
             {
@@ -563,6 +565,7 @@ pub enum RigidTy {
     Coroutine(CoroutineDef, GenericArgs),
     CoroutineClosure(CoroutineClosureDef, GenericArgs),
     Dynamic(Vec<Binder<ExistentialPredicate>>, Region, DynKind),
+    Dynamic(Vec<Binder<ExistentialPredicate>>, Region),
     Never,
     Tuple(Vec<Ty>),
     CoroutineWitness(CoroutineWitnessDef, GenericArgs),
@@ -1617,6 +1620,7 @@ pub struct AssocItem {
     /// If this is an item in an impl of a trait then this is the `DefId` of
     /// the associated item on the trait that this implements.
     pub trait_item_def_id: Option<AssocDef>,
+    pub container: AssocContainer,
 }
 
 #[derive(Clone, PartialEq, Debug, Eq, Serialize)]
@@ -1639,6 +1643,11 @@ pub enum AssocKind {
 pub enum AssocItemContainer {
     Trait,
     Impl,
+pub enum AssocContainer {
+    InherentImpl,
+    /// The `AssocDef` points to the trait item being implemented.
+    TraitImpl(AssocDef),
+    Trait,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]

rustc_public/src/ty.rs

@@ -15,6 +15,7 @@ use crate::mir::mono::{Instance, MonoItem, StaticDef};
 use crate::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp};
 use crate::ty::{
     Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, DynKind,
+    Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind,
     ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
     GenericArgKind, GenericArgs, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span,
     TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx,
@@ -192,6 +193,9 @@ impl RustcInternal for RigidTy {
                 tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)),
                 region.internal(tables, tcx),
                 dyn_kind.internal(tables, tcx),
+            RigidTy::Dynamic(predicate, region) => rustc_ty::TyKind::Dynamic(
+                tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)),
+                region.internal(tables, tcx),
             ),
             RigidTy::Tuple(tys) => {
                 rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx)))

rustc_public/src/unstable/convert/internal.rs

@@ -334,6 +334,16 @@ impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> {
             ),
             UbChecks => crate::mir::NullOp::UbChecks,
             ContractChecks => crate::mir::NullOp::ContractChecks,
+        use rustc_middle::mir::RuntimeChecks::*;
+        match self {
+            OffsetOf(indices) => crate::mir::NullOp::OffsetOf(
+                indices.iter().map(|idx| idx.stable(tables, cx)).collect(),
+            ),
+            RuntimeChecks(op) => crate::mir::NullOp::RuntimeChecks(match op {
+                UbChecks => crate::mir::RuntimeChecks::UbChecks,
+                ContractChecks => crate::mir::RuntimeChecks::ContractChecks,
+                OverflowChecks => crate::mir::RuntimeChecks::OverflowChecks,
+            }),
         }
     }
 }
@@ -357,6 +367,7 @@ impl<'tcx> Stable<'tcx> for mir::CastKind {
             PtrToPtr => crate::mir::CastKind::PtrToPtr,
             FnPtrToPtr => crate::mir::CastKind::FnPtrToPtr,
             Transmute => crate::mir::CastKind::Transmute,
+            Subtype => crate::mir::CastKind::Subtype,
         }
     }
 }

rustc_public/src/unstable/convert/stable/mir.rs

@@ -449,6 +449,13 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
                     dyn_kind.stable(tables, cx),
                 ))
             }
+            ty::Dynamic(existential_predicates, region) => TyKind::RigidTy(RigidTy::Dynamic(
+                existential_predicates
+                    .iter()
+                    .map(|existential_predicate| existential_predicate.stable(tables, cx))
+                    .collect(),
+                region.stable(tables, cx),
+            )),
             ty::Closure(def_id, generic_args) => TyKind::RigidTy(RigidTy::Closure(
                 tables.closure_def(*def_id),
                 generic_args.stable(tables, cx),
@@ -467,6 +474,10 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
             }
             ty::Param(param_ty) => TyKind::Param(param_ty.stable(tables, cx)),
             ty::Bound(debruijn_idx, bound_ty) => {
+            ty::Bound(ty::BoundVarIndexKind::Canonical, _) => {
+                unreachable!()
+            }
+            ty::Bound(ty::BoundVarIndexKind::Bound(debruijn_idx), bound_ty) => {
                 TyKind::Bound(debruijn_idx.as_usize(), bound_ty.stable(tables, cx))
             }
             ty::CoroutineWitness(def_id, args) => TyKind::RigidTy(RigidTy::CoroutineWitness(
@@ -495,6 +506,7 @@ impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> {
                 end: Some(end.stable(tables, cx)),
                 include_end: true,
             },
+            ty::PatternKind::NotNull => todo!(),
             ty::PatternKind::Or(_) => todo!(),
         }
     }
@@ -663,6 +675,13 @@ impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind {
             }
             ty::GenericParamDefKind::Const { has_default, synthetic: _ } => {
                 GenericParamDefKind::Const { has_default: *has_default }
+        match *self {
+            ty::GenericParamDefKind::Lifetime => GenericParamDefKind::Lifetime,
+            ty::GenericParamDefKind::Type { has_default, synthetic } => {
+                GenericParamDefKind::Type { has_default, synthetic }
+            }
+            ty::GenericParamDefKind::Const { has_default } => {
+                GenericParamDefKind::Const { has_default }
             }
         }
     }
@@ -921,6 +940,7 @@ impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> {
                 name: early_reg.name.to_string(),
             }),
             ty::ReBound(db_index, bound_reg) => RegionKind::ReBound(
+            ty::ReBound(ty::BoundVarIndexKind::Bound(db_index), bound_reg) => RegionKind::ReBound(
                 db_index.as_u32(),
                 BoundRegion {
                     var: bound_reg.var.as_u32(),
@@ -1084,6 +1104,21 @@ impl<'tcx> Stable<'tcx> for ty::AssocItemContainer {
         match self {
             ty::AssocItemContainer::Trait => AssocItemContainer::Trait,
             ty::AssocItemContainer::Impl => AssocItemContainer::Impl,
+impl<'tcx> Stable<'tcx> for ty::AssocContainer {
+    type T = crate::ty::AssocContainer;
+
+    fn stable(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        _: &CompilerCtxt<'_, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::AssocContainer;
+        match self {
+            ty::AssocContainer::Trait => AssocContainer::Trait,
+            ty::AssocContainer::InherentImpl => AssocContainer::InherentImpl,
+            ty::AssocContainer::TraitImpl(trait_item_id) => {
+                AssocContainer::TraitImpl(tables.assoc_def(trait_item_id.unwrap()))
+            }
         }
     }
 }