Update rustc pin

Author: Nadrieril

engine/lib/concrete_ident/concrete_ident.ml

@@ -702,7 +702,7 @@ let map_path_strings ~(f : string -> string) (did : t) : t =
     |> List.map ~f:(fun (chunk : Types.disambiguated_def_path_item) ->
            let data =
              match chunk.data with
-             | TypeNs s -> Types.TypeNs (Option.map ~f s)
+             | TypeNs s -> Types.TypeNs (f s)
              | ValueNs s -> ValueNs (f s)
              | MacroNs s -> MacroNs (f s)
              | LifetimeNs s -> LifetimeNs (f s)
@@ -726,8 +726,7 @@ let matches_namespace (ns : Types.namespace) (did : t) : bool =
     @ List.map
         ~f:(fun (chunk : Types.disambiguated_def_path_item) ->
           match chunk.data with
-          | TypeNs s -> s
-          | ValueNs s | MacroNs s | LifetimeNs s -> Some s
+          | TypeNs s | ValueNs s | MacroNs s | LifetimeNs s -> Some s
           | _ -> None)
         did.path
   in

engine/lib/concrete_ident/concrete_ident_view.ml

@@ -21,7 +21,7 @@ module Assert = struct
   let type_ns (did : Explicit_def_id.t) =
     match List.last (Explicit_def_id.to_def_id did).path with
     (* This can be `None` for the anonymous types generated for `-> impl Trait` in traits. *)
-    | Some { data = TypeNs (Some data); disambiguator } ->
+    | Some { data = TypeNs data; disambiguator } ->
         DisambiguatedString.{ data; disambiguator }
     | _ -> broken_invariant "last path chunk to exist and be of type TypeNs" did
 
@@ -191,7 +191,7 @@ let of_def_id (did : Explicit_def_id.t) : t =
     :: List.map
          ~f:(fun (m : Explicit_def_id.t) ->
            match (Explicit_def_id.to_def_id m).path |> List.last_exn with
-           | Types.{ disambiguator; data = TypeNs (Some data) } ->
+           | Types.{ disambiguator; data = TypeNs data } ->
                DisambiguatedString.{ data; disambiguator }
            | _ ->
                broken_invariant

engine/lib/import_thir.ml

@@ -353,6 +353,18 @@ end) : EXPR = struct
     in
     U.call' (`Concrete name) [ lhs; rhs ] span typ
 
+  let binop_of_assignop : Thir.assign_op -> Thir.bin_op = function
+    | AddAssign -> Add
+    | SubAssign -> Sub
+    | MulAssign -> Mul
+    | DivAssign -> Div
+    | RemAssign -> Rem
+    | BitXorAssign -> BitXor
+    | BitAndAssign -> BitAnd
+    | BitOrAssign -> BitOr
+    | ShlAssign -> Shl
+    | ShrAssign -> Shr
+
   let rec c_expr (e : Thir.decorated_for__expr_kind) : expr =
     try c_expr_unwrapped e
     with Diagnostics.SpanFreeError.Exn (Data (ctx, kind)) ->
@@ -596,7 +608,8 @@ end) : EXPR = struct
           c_expr_assign lhs rhs
       | AssignOp { lhs; op; rhs } ->
           let lhs = c_expr lhs in
-          c_expr_assign lhs @@ c_binop op lhs (c_expr rhs) span lhs.typ
+          c_expr_assign lhs
+          @@ c_binop (binop_of_assignop op) lhs (c_expr rhs) span lhs.typ
       | VarRef { id } -> LocalVar (local_ident Expr id)
       | Field { lhs; field } ->
           let lhs = c_expr lhs in
@@ -876,7 +889,7 @@ end) : EXPR = struct
     let typ = c_ty pat.span pat.ty in
     let v =
       match pat.contents with
-      | Wild -> PWild
+      | Wild | Missing -> PWild
       | AscribeUserType { ascription = { annotation; _ }; subpattern } ->
           let typ, typ_span = c_canonical_user_type_annotation annotation in
           let pat = c_pat subpattern in
@@ -1045,8 +1058,8 @@ end) : EXPR = struct
         TOpaque (Concrete_ident.of_def_id ~value:false def_id)
     | Alias { kind = Inherent; _ } ->
         assertion_failure [ span ] "Ty::Alias with AliasTyKind::Inherent"
-    | Alias { kind = Weak; _ } ->
-        assertion_failure [ span ] "Ty::Alias with AliasTyKind::Weak"
+    | Alias { kind = Free; _ } ->
+        assertion_failure [ span ] "Ty::Alias with AliasTyKind::Free"
     | Param { index; name } ->
         (* TODO: [id] might not unique *)
         TParam

engine/names/extract/build.rs

@@ -55,7 +55,7 @@ fn disambiguator_to_str(disambiguator: u32) -> String {
 
 fn def_path_item_to_str(path_item: DefPathItem) -> String {
     match path_item {
-        DefPathItem::TypeNs(Some(s))
+        DefPathItem::TypeNs(s)
         | DefPathItem::ValueNs(s)
         | DefPathItem::MacroNs(s)
         | DefPathItem::LifetimeNs(s) => s,
@@ -68,7 +68,11 @@ fn def_path_item_to_str(path_item: DefPathItem) -> String {
         DefPathItem::Ctor => "Ctor".into(),
         DefPathItem::AnonConst => "AnonConst".into(),
         DefPathItem::PromotedConst => "PromotedConst".into(),
-        DefPathItem::TypeNs(None) | DefPathItem::OpaqueTy => "OpaqueTy".into(),
+        DefPathItem::OpaqueTy => "OpaqueTy".into(),
+        DefPathItem::OpaqueLifetime(..) => "OpaqueLifetime".into(),
+        DefPathItem::AnonAssocTy(..) => "AnonAssocTy".into(),
+        DefPathItem::SyntheticCoroutineBody => "SyntheticCoroutineBody".into(),
+        DefPathItem::NestedStatic => "NestedStatic".into(),
     }
 }
 

flake.lock

@@ -113,7 +113,7 @@ pub fn translate_constant_reference<'tcx>(
     let kind = if let Some(assoc) = s.base().tcx.opt_associated_item(ucv.def) {
         if assoc.trait_item_def_id.is_some() || assoc.container == ty::AssocItemContainer::Trait {
             // This is an associated constant in a trait.
-            let name = assoc.name.to_string();
+            let name = assoc.name().to_string();
             let impl_expr = self_clause_for_item(s, ucv.def, ucv.args).unwrap();
             ConstantExprKind::TraitConst { impl_expr, name }
         } else {

frontend/exporter/src/constant_utils/uneval.rs

@@ -429,7 +429,7 @@ impl<'tcx> PredicateSearcher<'tcx> {
                 let types = tcx
                     .associated_items(trait_def_id)
                     .in_definition_order()
-                    .filter(|assoc| matches!(assoc.kind, AssocKind::Type))
+                    .filter(|assoc| matches!(assoc.kind, AssocKind::Type { .. }))
                     .filter_map(|assoc| {
                         let ty =
                             Ty::new_projection(tcx, assoc.def_id, erased_tref.skip_binder().args);

frontend/exporter/src/traits/resolution.rs

@@ -343,10 +343,10 @@ impl std::convert::From<DefId> for Path {
     fn from(v: DefId) -> Vec<String> {
         std::iter::once(&v.krate)
             .chain(v.path.iter().filter_map(|item| match &item.data {
-                DefPathItem::TypeNs(s) => s.as_ref(),
-                DefPathItem::ValueNs(s) | DefPathItem::MacroNs(s) | DefPathItem::LifetimeNs(s) => {
-                    Some(s)
-                }
+                DefPathItem::TypeNs(s)
+                | DefPathItem::ValueNs(s)
+                | DefPathItem::MacroNs(s)
+                | DefPathItem::LifetimeNs(s) => Some(s),
                 _ => None,
             }))
             .cloned()
@@ -378,7 +378,7 @@ pub enum DefPathItem {
     ForeignMod,
     Use,
     GlobalAsm,
-    TypeNs(Option<Symbol>),
+    TypeNs(Symbol),
     ValueNs(Symbol),
     MacroNs(Symbol),
     LifetimeNs(Symbol),
@@ -388,6 +388,10 @@ pub enum DefPathItem {
     #[cfg_attr(not(feature = "extract_names_mode"), disable_mapping)]
     PromotedConst,
     OpaqueTy,
+    OpaqueLifetime(Symbol),
+    AnonAssocTy(Symbol),
+    SyntheticCoroutineBody,
+    NestedStatic,
 }
 
 #[derive_group(Serializers)]

frontend/exporter/src/types/def_id.rs

@@ -981,7 +981,7 @@ make_idx_wrapper!(rustc_abi, FieldIdx);
 /// Reflects [`rustc_middle::mir::UnOp`]
 #[derive_group(Serializers)]
 #[derive(AdtInto, Copy, Clone, Debug, JsonSchema)]
-#[args(<'slt, S: UnderOwnerState<'slt>>, from: rustc_middle::mir::UnOp, state: S as _s)]
+#[args(<'slt, S: UnderOwnerState<'slt>>, from: mir::UnOp, state: S as _s)]
 pub enum UnOp {
     Not,
     Neg,
@@ -991,7 +991,7 @@ pub enum UnOp {
 /// Reflects [`rustc_middle::mir::BinOp`]
 #[derive_group(Serializers)]
 #[derive(AdtInto, Copy, Clone, Debug, JsonSchema)]
-#[args(<'slt, S: UnderOwnerState<'slt>>, from: rustc_middle::mir::BinOp, state: S as _s)]
+#[args(<'slt, S: UnderOwnerState<'slt>>, from: mir::BinOp, state: S as _s)]
 pub enum BinOp {
     // We merge the checked and unchecked variants because in either case overflow is failure.
     #[custom_arm(
@@ -1032,9 +1032,26 @@ pub enum BinOp {
     Offset,
 }
 
+/// Reflects [`rustc_middle::mir::AssignOp`]
+#[derive_group(Serializers)]
+#[derive(AdtInto, Copy, Clone, Debug, JsonSchema)]
+#[args(<'tcx, S: BaseState<'tcx>>, from: mir::AssignOp, state: S as _s)]
+pub enum AssignOp {
+    AddAssign,
+    SubAssign,
+    MulAssign,
+    DivAssign,
+    RemAssign,
+    BitXorAssign,
+    BitAndAssign,
+    BitOrAssign,
+    ShlAssign,
+    ShrAssign,
+}
+
 /// Reflects [`rustc_middle::mir::BorrowKind`]
 #[derive(AdtInto)]
-#[args(<S>, from: rustc_middle::mir::BorrowKind, state: S as gstate)]
+#[args(<S>, from: mir::BorrowKind, state: S as gstate)]
 #[derive_group(Serializers)]
 #[derive(Copy, Clone, Debug, JsonSchema, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub enum BorrowKind {

frontend/exporter/src/types/mir.rs

@@ -476,7 +476,8 @@ pub enum FullDefKind<Body> {
 #[derive_group(Serializers)]
 #[derive(Clone, Debug, JsonSchema)]
 pub struct ImplAssocItem<Body> {
-    pub name: Symbol,
+    /// This is `None` for RPTITs.
+    pub name: Option<Symbol>,
     /// The definition of the item from the trait declaration. This is `AssocTy`, `AssocFn` or
     /// `AssocConst`.
     pub decl_def: Arc<FullDef<Body>>,
@@ -571,11 +572,11 @@ impl<Body> FullDef<Body> {
                 .collect(),
             FullDefKind::InherentImpl { items, .. } | FullDefKind::Trait { items, .. } => items
                 .iter()
-                .map(|(item, _)| (item.name.clone(), item.def_id.clone()))
+                .filter_map(|(item, _)| Some((item.name.clone()?, item.def_id.clone())))
                 .collect(),
             FullDefKind::TraitImpl { items, .. } => items
                 .iter()
-                .map(|item| (item.name.clone(), item.def().def_id.clone()))
+                .filter_map(|item| Some((item.name.clone()?, item.def().def_id.clone())))
                 .collect(),
             _ => vec![],
         };
@@ -586,7 +587,7 @@ impl<Body> FullDef<Body> {
                 children.extend(
                     tcx.associated_items(impl_def_id)
                         .in_definition_order()
-                        .map(|assoc| (assoc.name, assoc.def_id).sinto(s)),
+                        .filter_map(|assoc| Some((assoc.opt_name()?, assoc.def_id).sinto(s))),
                 );
             }
         }
@@ -605,11 +606,17 @@ impl<Body> ImplAssocItem<Body> {
     }
 
     /// The kind of item this is.
-    pub fn assoc_kind(&self) -> AssocKind {
+    pub fn assoc_kind(&self) -> &AssocKind {
         match self.def().kind() {
-            FullDefKind::AssocTy { .. } => AssocKind::Type,
-            FullDefKind::AssocFn { .. } => AssocKind::Fn,
-            FullDefKind::AssocConst { .. } => AssocKind::Const,
+            FullDefKind::AssocTy {
+                associated_item, ..
+            }
+            | FullDefKind::AssocFn {
+                associated_item, ..
+            }
+            | FullDefKind::AssocConst {
+                associated_item, ..
+            } => &associated_item.kind,
             _ => unreachable!(),
         }
     }
@@ -804,21 +811,23 @@ where
                                 vec![]
                             };
                             match decl_assoc.kind {
-                                ty::AssocKind::Type => {
+                                ty::AssocKind::Type { .. } => {
                                     let ty = tcx
                                         .type_of(decl_def_id)
                                         .instantiate(tcx, trait_ref.args)
                                         .sinto(s);
                                     ImplAssocItemValue::DefaultedTy { ty }
                                 }
-                                ty::AssocKind::Fn => ImplAssocItemValue::DefaultedFn {},
-                                ty::AssocKind::Const => ImplAssocItemValue::DefaultedConst {},
+                                ty::AssocKind::Fn { .. } => ImplAssocItemValue::DefaultedFn {},
+                                ty::AssocKind::Const { .. } => {
+                                    ImplAssocItemValue::DefaultedConst {}
+                                }
                             }
                         }
                     };
 
                     ImplAssocItem {
-                        name: decl_assoc.name.sinto(s),
+                        name: decl_assoc.opt_name().sinto(s),
                         value,
                         required_impl_exprs,
                         decl_def,