Auto merge of rust-lang#136094 - davidv1992:upgrade-elsa, r=oli-obk

Upgrade elsa to the newest version.

This was locked to 1.7.1 because of an error in the elsa release process that has since been fixed. Upgrading has the advantage that the elsa code runs properly in miri, at least with tree borrows.

This was spawned from rust-lang#135870 (comment)

Author: bors

Diff for: Cargo.lock

@@ -1098,9 +1098,9 @@ dependencies = [
 
 [[package]]
 name = "elsa"
-version = "1.7.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "848fe615fbb0a74d9ae68dcaa510106d32e37d9416207bbea4bd008bd89c47ed"
+checksum = "2343daaeabe09879d4ea058bb4f1e63da3fc07dadc6634e01bda1b3d6a9d9d2b"
 dependencies = [
  "stable_deref_trait",
 ]

Diff for: compiler/rustc_data_structures/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 either = "1.0"
-elsa = "=1.7.1"
+elsa = "1.11.0"
 ena = "0.14.3"
 indexmap = "2.4.0"
 jobserver_crate = { version = "0.1.28", package = "jobserver" }

Diff for: compiler/rustc_passes/src/stability.rs

@@ -300,11 +300,24 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         // const stability: inherit feature gate from regular stability.
         let mut const_stab = const_stab.map(|(stab, _span)| stab);
 
+        // `impl const Trait for Type` items forward their const stability to their
+        // immediate children.
+        // FIXME(const_trait_impl): how is this supposed to interact with `#[rustc_const_stable_indirect]`?
+        // Currently, once that is set, we do not inherit anything from the parent any more.
+        if const_stab.is_none()
+            && let Some(parent) = self.parent_const_stab
+            && parent.is_const_unstable()
+        {
+            // For now, `const fn` in const traits/trait impls does not exist.
+            assert!(fn_sig.is_none_or(|s| !s.header.is_const()), "should never have parent const stability for a const fn");
+            self.index.const_stab_map.insert(def_id, parent);
+        }
+
         // If this is a const fn but not annotated with stability markers, see if we can inherit regular stability.
-        if fn_sig.is_some_and(|s| s.header.is_const())  && const_stab.is_none() &&
+        if fn_sig.is_some_and(|s| s.header.is_const())
+            && const_stab.is_none()
             // We only ever inherit unstable features.
-            let Some(inherit_regular_stab) =
-                final_stab.filter(|s| s.is_unstable())
+            && let Some(inherit_regular_stab) = final_stab.filter(|s| s.is_unstable())
         {
             const_stab = Some(ConstStability {
                 // We subject these implicitly-const functions to recursive const stability.
@@ -329,19 +342,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             self.index.implications.insert(implied_by, feature);
         }
 
-        // `impl const Trait for Type` items forward their const stability to their
-        // immediate children.
-        // FIXME(const_trait_impl): how is this supposed to interact with `#[rustc_const_stable_indirect]`?
-        // Currently, once that is set, we do not inherit anything from the parent any more.
-        if const_stab.is_none() {
-            debug!("annotate: const_stab not found, parent = {:?}", self.parent_const_stab);
-            if let Some(parent) = self.parent_const_stab {
-                if parent.is_const_unstable() {
-                    self.index.const_stab_map.insert(def_id, parent);
-                }
-            }
-        }
-
         self.recurse_with_stability_attrs(
             depr.map(|(d, _)| DeprecationEntry::local(d, def_id)),
             stab,
@@ -418,6 +418,9 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
                 kind = AnnotationKind::DeprecationProhibited;
                 const_stab_inherit = InheritConstStability::Yes;
             }
+            hir::ItemKind::Trait(..) => {
+                const_stab_inherit = InheritConstStability::Yes;
+            }
             hir::ItemKind::Struct(ref sd, _) => {
                 if let Some(ctor_def_id) = sd.ctor_def_id() {
                     self.annotate(

Diff for: tests/ui/traits/const-traits/auxiliary/staged-api.rs

@@ -9,6 +9,13 @@
 pub trait MyTrait {
     #[stable(feature = "rust1", since = "1.0.0")]
     fn func();
+
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn default<T: ~const MyTrait>() {
+        // This call is const-unstable, but permitted here since we inherit
+        // the `rustc_const_unstable` above.
+        T::func();
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -18,6 +25,12 @@ pub struct Unstable;
 #[rustc_const_unstable(feature = "unstable", issue = "none")]
 impl const MyTrait for Unstable {
     fn func() {}
+
+    fn default<T: ~const MyTrait>() {
+        // This call is const-unstable, but permitted here since we inherit
+        // the `rustc_const_unstable` above.
+        T::func();
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]