Update rustc

Author: Nadrieril

cli/driver/src/driver.rs

@@ -1,6 +1,5 @@
 #![feature(rustc_private)]
 #![feature(box_patterns)]
-#![feature(concat_idents)]
 #![feature(trait_alias)]
 #![allow(unused_imports)]
 #![allow(unused_variables)]

engine/lib/import_thir.ml

@@ -1513,7 +1513,7 @@ and c_item_unwrapped ~ident ~type_only (item : Thir.item) : item list =
   in
   (* TODO: things might be unnamed (e.g. constants) *)
   match (item.kind : Thir.item_kind) with
-  | Const (_, _, generics, body) ->
+  | Const (_, generics, _, body) ->
       mk
       @@ Fn
            {
@@ -1523,14 +1523,14 @@ and c_item_unwrapped ~ident ~type_only (item : Thir.item) : item list =
              params = [];
              safety = Safe;
            }
-  | Static (_, _, true, _) ->
+  | Static (true, _, _, _) ->
       unimplemented ~issue_id:1343 [ item.span ]
         "Mutable static items are not supported."
-  | Static (_, _ty, false, body) ->
+  | Static (false, _, _ty, body) ->
       let name = Concrete_ident.of_def_id ~value:true (assert_item_def_id ()) in
       let generics = { params = []; constraints = [] } in
       mk (Fn { name; generics; body = c_body body; params = []; safety = Safe })
-  | TyAlias (_, ty, generics) ->
+  | TyAlias (_, generics, ty) ->
       mk
       @@ TyAlias
            {
@@ -1549,13 +1549,13 @@ and c_item_unwrapped ~ident ~type_only (item : Thir.item) : item list =
              params = c_fn_params item.span params;
              safety = c_header_safety safety;
            }
-  | (Enum (_, _, generics, _) | Struct (_, _, generics)) when erased ->
+  | (Enum (_, generics, _, _) | Struct (_, generics, _)) when erased ->
       let generics = c_generics generics in
       let is_struct = match item.kind with Struct _ -> true | _ -> false in
       let def_id = assert_item_def_id () in
       let name = Concrete_ident.of_def_id ~value:false def_id in
       mk @@ Type { name; generics; variants = []; is_struct }
-  | Enum (_, variants, generics, repr) ->
+  | Enum (_, generics, variants, repr) ->
       let def_id = assert_item_def_id () in
       let generics = c_generics generics in
       let is_struct = false in
@@ -1613,7 +1613,7 @@ and c_item_unwrapped ~ident ~type_only (item : Thir.item) : item list =
         mk_one (Type { name; generics; variants; is_struct }) :: discs
       in
       if is_primitive then cast_fun :: result else result
-  | Struct (_, v, generics) ->
+  | Struct (_, generics, v) ->
       let generics = c_generics generics in
       let def_id = assert_item_def_id () in
       let is_struct = true in
@@ -1808,7 +1808,9 @@ and c_item_unwrapped ~ident ~type_only (item : Thir.item) : item list =
           {
             path = List.map ~f:(fun x -> fst x.ident) segments;
             is_external =
-              List.exists ~f:(function Err -> true | _ -> false) res;
+              List.exists
+                ~f:(function None | Some Err -> true | _ -> false)
+                res;
             (* TODO: this should represent local/external? *)
             rename;
           }

flake.lock

@@ -154,7 +154,7 @@ impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, ConstantExpr> for ty::Const<'tcx>
         let span = self.default_span(s.base().tcx);
         match self.kind() {
             ty::ConstKind::Param(p) => {
-                let ty = p.find_ty_from_env(s.param_env());
+                let ty = p.find_const_ty_from_env(s.param_env());
                 let kind = ConstantExprKind::ConstRef { id: p.sinto(s) };
                 kind.decorate(ty.sinto(s), span.sinto(s))
             }
@@ -279,7 +279,7 @@ fn op_to_const<'tcx, S: UnderOwnerState<'tcx>>(
     // Helper for struct-likes.
     let read_fields = |of: rustc_const_eval::interpret::OpTy<'tcx>, field_count| {
         (0..field_count).map(move |i| {
-            let field_op = ecx.project_field(&of, i)?;
+            let field_op = ecx.project_field(&of, rustc_abi::FieldIdx::from_usize(i))?;
             op_to_const(s, span, &ecx, field_op)
         })
     };

frontend/exporter/src/constant_utils/uneval.rs

@@ -1,9 +1,9 @@
 #![allow(rustdoc::private_intra_doc_links)]
-#![cfg_attr(feature = "rustc", feature(concat_idents))]
 #![cfg_attr(feature = "rustc", feature(if_let_guard))]
 #![cfg_attr(feature = "rustc", feature(let_chains))]
 #![cfg_attr(feature = "rustc", feature(macro_metavar_expr))]
 #![cfg_attr(feature = "rustc", feature(rustc_private))]
+#![cfg_attr(feature = "rustc", feature(sized_hierarchy))]
 #![cfg_attr(feature = "rustc", feature(trait_alias))]
 #![cfg_attr(feature = "rustc", feature(type_changing_struct_update))]
 

frontend/exporter/src/lib.rs

@@ -1,9 +1,15 @@
 use crate::prelude::{derive_group, JsonSchema};
 
+#[cfg(not(feature = "rustc"))]
 pub trait SInto<S, To> {
     fn sinto(&self, s: &S) -> To;
 }
 
+#[cfg(feature = "rustc")]
+pub trait SInto<S, To>: std::marker::PointeeSized {
+    fn sinto(&self, s: &S) -> To;
+}
+
 #[macro_export]
 macro_rules! sinto_todo {
     ($($mod:ident)::+, $type:ident$(<$($lts:lifetime),*$(,)?>)? as $renamed:ident) => {

frontend/exporter/src/sinto.rs

@@ -677,7 +677,7 @@ pub fn shallow_resolve_trait_ref<'tcx>(
     use rustc_middle::traits::CodegenObligationError;
     use rustc_middle::ty::TypeVisitableExt;
     use rustc_trait_selection::traits::{
-        Obligation, ObligationCause, ObligationCtxt, SelectionContext, Unimplemented,
+        Obligation, ObligationCause, ObligationCtxt, SelectionContext, SelectionError,
     };
     // Do the initial selection for the obligation. This yields the
     // shallow result we are looking for -- that is, what specific impl.
@@ -693,7 +693,7 @@ pub fn shallow_resolve_trait_ref<'tcx>(
     let selection = match selcx.poly_select(&obligation) {
         Ok(Some(selection)) => selection,
         Ok(None) => return Err(CodegenObligationError::Ambiguity),
-        Err(Unimplemented) => return Err(CodegenObligationError::Unimplemented),
+        Err(SelectionError::Unimplemented) => return Err(CodegenObligationError::Unimplemented),
         Err(_) => return Err(CodegenObligationError::Ambiguity),
     };
 

frontend/exporter/src/traits/resolution.rs

@@ -535,7 +535,7 @@ pub struct Variant<Body: IsBody> {
 pub struct UsePath {
     pub span: Span,
     #[map(x.iter().map(|res| res.sinto(s)).collect())]
-    pub res: Vec<Res>,
+    pub res: Vec<Option<Res>>,
     pub segments: Vec<PathSegment>,
     #[value(self.segments.iter().last().and_then(|segment| {
             match s.base().tcx.hir_node_by_def_id(segment.hir_id.owner.def_id) {
@@ -620,8 +620,8 @@ pub struct PathSegment {
 pub enum ItemKind<Body: IsBody> {
     ExternCrate(Option<Symbol>, Ident),
     Use(UsePath, UseKind),
-    Static(Ident, Ty, Mutability, Body),
-    Const(Ident, Ty, Generics<Body>, Body),
+    Static(Mutability, Ident, Ty, Body),
+    Const(Ident, Generics<Body>, Ty, Body),
     #[custom_arm(
         hir::ItemKind::Fn{ ident, sig, generics, body, .. } => {
             ItemKind::Fn {
@@ -648,6 +648,7 @@ pub enum ItemKind<Body: IsBody> {
     },
     TyAlias(
         Ident,
+        Generics<Body>,
         #[map({
             let s = &State {
                 base: Base {ty_alias_mode: true, ..s.base()},
@@ -659,20 +660,19 @@ pub enum ItemKind<Body: IsBody> {
             x.sinto(s)
         })]
         Ty,
-        Generics<Body>,
     ),
     Enum(
         Ident,
-        EnumDef<Body>,
         Generics<Body>,
+        EnumDef<Body>,
         #[value({
             let tcx = s.base().tcx;
             tcx.repr_options_of_def(s.owner_id().expect_local()).sinto(s)
         })]
         ReprOptions,
     ),
-    Struct(Ident, VariantData, Generics<Body>),
-    Union(Ident, VariantData, Generics<Body>),
+    Struct(Ident, Generics<Body>, VariantData),
+    Union(Ident, Generics<Body>, VariantData),
     Trait(
         IsAuto,
         Safety,
@@ -916,7 +916,7 @@ impl<'tcx, S: BaseState<'tcx>, Body: IsBody> SInto<S, Item<Body>> for hir::Item<
         let name = match self.kind {
             ExternCrate(_, i)
             | Use(_, hir::UseKind::Single(i))
-            | Static(i, ..)
+            | Static(_, i, ..)
             | Const(i, ..)
             | Fn { ident: i, .. }
             | Macro(i, ..)

frontend/exporter/src/types/hir.rs

@@ -217,7 +217,7 @@ pub enum FullDefKind<Body> {
         /// `Some` if the item is in the local crate.
         #[value(s.base().tcx.hir_get_if_local(s.owner_id()).map(|node| {
             let rustc_hir::Node::Item(item) = node else { unreachable!() };
-            let rustc_hir::ItemKind::TyAlias(_, ty, _generics) = &item.kind else { unreachable!() };
+            let rustc_hir::ItemKind::TyAlias(_, _generics, ty) = &item.kind else { unreachable!() };
             let mut s = State::from_under_owner(s);
             s.base.ty_alias_mode = true;
             ty.sinto(&s)
@@ -981,7 +981,8 @@ fn closure_once_shim<'tcx>(
 
 #[cfg(feature = "rustc")]
 fn drop_glue_shim<'tcx>(tcx: ty::TyCtxt<'tcx>, def_id: RDefId) -> Option<mir::Body<'tcx>> {
-    let drop_in_place = tcx.require_lang_item(rustc_hir::LangItem::DropInPlace, None);
+    let drop_in_place =
+        tcx.require_lang_item(rustc_hir::LangItem::DropInPlace, rustc_span::DUMMY_SP);
     if !tcx.generics_of(def_id).is_empty() {
         // Hack: layout code panics if it can't fully normalize types, which can happen e.g. with a
         // trait associated type. For now we only translate the glue for monomorphic types.

frontend/exporter/src/types/new/full_def.rs

@@ -544,14 +544,14 @@ impl std::ops::Deref for ItemRef {
 #[cfg(feature = "rustc")]
 impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, GenericArg> for ty::GenericArg<'tcx> {
     fn sinto(&self, s: &S) -> GenericArg {
-        self.unpack().sinto(s)
+        self.kind().sinto(s)
     }
 }
 
 #[cfg(feature = "rustc")]
 impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, Vec<GenericArg>> for ty::GenericArgsRef<'tcx> {
     fn sinto(&self, s: &S) -> Vec<GenericArg> {
-        self.iter().map(|v| v.unpack().sinto(s)).collect()
+        self.iter().map(|v| v.kind().sinto(s)).collect()
     }
 }
 
@@ -1169,7 +1169,7 @@ pub enum Term {
 impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, Term> for ty::Term<'tcx> {
     fn sinto(&self, s: &S) -> Term {
         use ty::TermKind;
-        match self.unpack() {
+        match self.kind() {
             TermKind::Ty(ty) => Term::Ty(ty.sinto(s)),
             TermKind::Const(c) => Term::Const(c.sinto(s)),
         }