Name two extra rulesets

Author: Nadrieril

src/rulesets/ty_based.rs

@@ -401,16 +401,13 @@ impl RuleOptions {
 
     /// Reproduces RFC3627 (match ergonomics 2024) behavior
     pub const ERGO2024: Self = RuleOptions {
-        match_constructor_through_ref: true,
-        ref_binding_on_inherited: RefBindingOnInheritedBehavior::ResetBindingMode,
         mut_binding_on_inherited: MutBindingOnInheritedBehavior::Error,
         inherited_ref_on_ref: InheritedRefOnRefBehavior::EatInner,
         fallback_to_outer: FallbackToOuterBehavior::EatOuter,
         allow_ref_pat_on_ref_mut: true,
-        simplify_deref_mut: true,
         eat_inherited_ref_alone: true,
         downgrade_mut_inside_shared: true,
-        eat_mut_inside_shared: true,
+        ..RuleOptions::STABLE_RUST
     };
 
     /// A fairly permissive proposal, with the benefit of requiring 0 implicit state: we never
@@ -434,6 +431,21 @@ impl RuleOptions {
         ..Self::STATELESS
     };
 
+    /// The currently-planned version of the `stateless` ruleset for edition 2021. Not actually
+    /// stateless.
+    pub const STATELESS_2021: Self = RuleOptions {
+        allow_ref_pat_on_ref_mut: true,
+        eat_inherited_ref_alone: true,
+        ..RuleOptions::STABLE_RUST
+    };
+
+    /// A backwards-compatible proposal by @dianne that behaves close to the 2024 stateless
+    /// proposal.
+    pub const EAT_OUTER_2021: Self = RuleOptions {
+        fallback_to_outer: FallbackToOuterBehavior::EatBoth,
+        ..RuleOptions::STATELESS_2021
+    };
+
     /// Purely structural matching, with no match ergonomics.
     pub const STRUCTURAL: Self = RuleOptions {
         inherited_ref_on_ref: InheritedRefOnRefBehavior::Error,
@@ -492,21 +504,31 @@ impl RuleOptions {
 
 /// The known bundles, with a short explanation.
 pub static KNOWN_TY_BASED_BUNDLES: &[BundleDoc<RuleOptions>] = &[
+    BundleDoc {
+        name: "stable_rust",
+        ruleset: RuleOptions::STABLE_RUST,
+        doc: "The behavior of current stable rust",
+    },
+    BundleDoc {
+        name: "stateless",
+        ruleset: RuleOptions::STATELESS,
+        doc: "A proposal that tracks no hidden state; purely type-based",
+    },
     BundleDoc {
         name: "nadri",
         ruleset: RuleOptions::NADRI,
         doc: "A reasonable proposal; like `stateless` but \
                 forbids `ref` bindings that create temporaries",
     },
     BundleDoc {
-        name: "stateless",
-        ruleset: RuleOptions::STATELESS,
-        doc: "A proposal that tracks no hidden state; purely type-based",
+        name: "stateless_2021",
+        ruleset: RuleOptions::STATELESS_2021,
+        doc: "The currently-planned version of the `stateless` ruleset for edition 2021. Not actually stateless.",
     },
     BundleDoc {
-        name: "stable_rust",
-        ruleset: RuleOptions::STABLE_RUST,
-        doc: "The behavior of current stable rust",
+        name: "eat_outer_2021",
+        ruleset: RuleOptions::EAT_OUTER_2021,
+        doc: "A backwards-compatible proposal by @dianne that behaves close to the 2024 stateless proposal.",
     },
     BundleDoc {
         name: "rfc3627",
@@ -523,16 +545,16 @@ pub static KNOWN_TY_BASED_BUNDLES: &[BundleDoc<RuleOptions>] = &[
         ruleset: RuleOptions::ERGO2024_BREAKING_ONLY,
         doc: "The breaking changes for edition 2024 planned in RFC3627",
     },
-    BundleDoc {
-        name: "min_ergonomics",
-        ruleset: RuleOptions::MIN_ERGONOMICS,
-        doc: "The minimal amout of match ergonomics that's forward-compatible with most proposals",
-    },
     BundleDoc {
         name: "structural",
         ruleset: RuleOptions::STRUCTURAL,
         doc: "Purely structural matching, with no match ergonomics",
     },
+    BundleDoc {
+        name: "min_ergonomics",
+        ruleset: RuleOptions::MIN_ERGONOMICS,
+        doc: "The minimal amout of match ergonomics that's forward-compatible with most proposals",
+    },
     BundleDoc {
         name: "waffle",
         ruleset: RuleOptions::WAFFLE,

tests/snapshots/bundle_rules@eat_outer_2021-Let.snap

@@ -0,0 +1,135 @@
+---
+source: src/analyses/compute_rules.rs
+info:
+  bundle_name: eat_outer_2021
+  options:
+    match_constructor_through_ref: true
+    eat_inherited_ref_alone: true
+    inherited_ref_on_ref: EatBoth
+    fallback_to_outer: EatBoth
+    allow_ref_pat_on_ref_mut: true
+    simplify_deref_mut: true
+    downgrade_mut_inside_shared: false
+    eat_mut_inside_shared: true
+    ref_binding_on_inherited: ResetBindingMode
+    mut_binding_on_inherited: ResetBindingMode
+---
+let p0: T0 = e.0,  let p1: T1 = e.1
+----------------------------------- "Constructor"
+let [p0, p1]: [T0, T1] = e
+
+let p0: &T0 = &(*e).0,  let p1: &T1 = &(*e).1
+--------------------------------------------- "ConstructorRef"
+let [p0, p1]: &[T0, T1] = e
+
+let p0: &mut T0 = &mut (*e).0,  let p1: &mut T1 = &mut (*e).1
+------------------------------------------------------------- "ConstructorRef"
+let [p0, p1]: &mut [T0, T1] = e
+
+let [p0, p1]: &T = &**e
+----------------------- "ConstructorMultiRef"
+let [p0, p1]: &&T = e
+
+let [p0, p1]: &T = &**e
+------------------------- "ConstructorMultiRef"
+let [p0, p1]: &&mut T = e
+
+let [p0, p1]: &T = &**e
+------------------------- "ConstructorMultiRef"
+let [p0, p1]: &mut &T = e
+
+let [p0, p1]: &mut T = &mut **e
+------------------------------- "ConstructorMultiRef"
+let [p0, p1]: &mut &mut T = e
+
+let p: T = *e
+------------------------------------ "Deref(EatOuter)"
+let &p: &T = e, e is not a reference
+
+let p: T = *&e
+------------------------------------- "Deref(EatOuter)"
+let &p: &T = &e, T is not a reference
+
+let p: T = *e
+-------------------------------------------- "Deref(EatOuter)"
+let &mut p: &mut T = e, e is not a reference
+
+let p: T = *&mut e
+------------------------------------------------- "Deref(EatOuter)"
+let &mut p: &mut T = &mut e, T is not a reference
+
+let p: T = *e
+---------------- "Deref(EatBoth)"
+let &p: &&T = &e
+
+let p: T = *e
+------------------------ "Deref(EatBoth)"
+let &p: &mut &T = &mut e
+
+let p: T = *e
+------------------------ "Deref(EatBoth)"
+let &mut p: &&mut T = &e
+
+let p: T = *e
+-------------------------------- "Deref(EatBoth)"
+let &mut p: &mut &mut T = &mut e
+
+let p: T = **&mut e
+---------------------------- "Deref(EatBoth, FallbackToOuter(EatBoth))"
+let &mut p: &mut &T = &mut e
+
+let p: T = *&*e
+---------------------------------------- "DerefMutWithShared(EatOuter)"
+let &p: &mut T = e, e is not a reference
+
+let p: T = *&*&mut e
+--------------------------------------------- "DerefMutWithShared(EatOuter)"
+let &p: &mut T = &mut e, T is not a reference
+
+let p: T = *&*e
+-------------------- "DerefMutWithShared(EatBoth)"
+let &p: &&mut T = &e
+
+let p: T = *&*e
+---------------------------- "DerefMutWithShared(EatBoth)"
+let &p: &mut &mut T = &mut e
+
+let ref x: T = e
+------------------ "RefBindingResetBindingMode"
+let ref x: &T = &e
+
+let ref x: T = e
+-------------------------- "RefBindingResetBindingMode"
+let ref x: &mut T = &mut e
+
+let ref mut x: T = e
+---------------------- "RefBindingResetBindingMode"
+let ref mut x: &T = &e
+
+let ref mut x: T = e
+------------------------------ "RefBindingResetBindingMode"
+let ref mut x: &mut T = &mut e
+
+let mut x: T = e
+------------------ "MutBindingResetBindingMode"
+let mut x: &T = &e
+
+let mut x: T = e
+-------------------------- "MutBindingResetBindingMode"
+let mut x: &mut T = &mut e
+
+let x: &T = &e
+-------------------------------------- "BindingBorrow"
+let ref x: T = e, e is not a reference
+
+let x: &mut T = &mut e
+------------------------------------------ "BindingBorrow"
+let ref mut x: T = e, e is not a reference
+
+
+------------ "Binding"
+let x: T = e
+
+
+-------------------------------------- "Binding"
+let mut x: T = e, e is not a reference

tests/snapshots/bundle_rules@eat_outer_2021-SequentInMemory.snap

@@ -0,0 +1,159 @@
+---
+source: src/analyses/compute_rules.rs
+info:
+  bundle_name: eat_outer_2021
+  options:
+    match_constructor_through_ref: true
+    eat_inherited_ref_alone: true
+    inherited_ref_on_ref: EatBoth
+    fallback_to_outer: EatBoth
+    allow_ref_pat_on_ref_mut: true
+    simplify_deref_mut: true
+    downgrade_mut_inside_shared: false
+    eat_mut_inside_shared: true
+    ref_binding_on_inherited: ResetBindingMode
+    mut_binding_on_inherited: ResetBindingMode
+---
+move ⊢ p0: T0,  move ⊢ p1: T1
+----------------------------- "Constructor"
+move ⊢ [p0, p1]: [T0, T1]
+
+ref ⊢ p0: T0,  ref ⊢ p1: T1
+--------------------------- "ConstructorRef"
+move ⊢ [p0, p1]: &[T0, T1]
+
+ref ⊢ p0: T0,  ref ⊢ p1: T1
+--------------------------- "ConstructorRef"
+ref ⊢ [p0, p1]: [T0, T1]
+
+ref mut ⊢ p0: T0,  ref mut ⊢ p1: T1
+----------------------------------- "ConstructorRef"
+move ⊢ [p0, p1]: &mut [T0, T1]
+
+ref mut ⊢ p0: T0,  ref mut ⊢ p1: T1
+----------------------------------- "ConstructorRef"
+ref mut ⊢ [p0, p1]: [T0, T1]
+
+ref ⊢ [p0, p1]: T
+-------------------- "ConstructorMultiRef"
+move ⊢ [p0, p1]: &&T
+
+ref ⊢ [p0, p1]: T
+------------------------ "ConstructorMultiRef"
+move ⊢ [p0, p1]: &&mut T
+
+ref ⊢ [p0, p1]: T
+------------------ "ConstructorMultiRef"
+ref ⊢ [p0, p1]: &T
+
+ref ⊢ [p0, p1]: T
+---------------------- "ConstructorMultiRef"
+ref ⊢ [p0, p1]: &mut T
+
+ref ⊢ [p0, p1]: T
+------------------------ "ConstructorMultiRef"
+move ⊢ [p0, p1]: &mut &T
+
+ref mut ⊢ [p0, p1]: T
+---------------------------- "ConstructorMultiRef"
+move ⊢ [p0, p1]: &mut &mut T
+
+ref ⊢ [p0, p1]: T
+---------------------- "ConstructorMultiRef"
+ref mut ⊢ [p0, p1]: &T
+
+ref mut ⊢ [p0, p1]: T
+-------------------------- "ConstructorMultiRef"
+ref mut ⊢ [p0, p1]: &mut T
+
+move ⊢ p: T
+------------- "Deref(EatOuter)"
+move ⊢ &p: &T
+
+move ⊢ p: T
+--------------------------------- "Deref(EatOuter)"
+ref ⊢ &p: T, T is not a reference
+
+move ⊢ p: T
+--------------------- "Deref(EatOuter)"
+move ⊢ &mut p: &mut T
+
+move ⊢ p: T
+----------------------------------------- "Deref(EatOuter)"
+ref mut ⊢ &mut p: T, T is not a reference
+
+move ⊢ p: T
+------------ "Deref(EatBoth)"
+ref ⊢ &p: &T
+
+move ⊢ p: T
+---------------- "Deref(EatBoth)"
+ref mut ⊢ &p: &T
+
+move ⊢ p: T
+-------------------- "Deref(EatBoth)"
+ref ⊢ &mut p: &mut T
+
+move ⊢ p: T
+------------------------ "Deref(EatBoth)"
+ref mut ⊢ &mut p: &mut T
+
+move ⊢ p: T
+-------------------- "Deref(EatBoth, FallbackToOuter(EatBoth))"
+ref mut ⊢ &mut p: &T
+
+move ⊢ p: T
+----------------- "DerefMutWithShared(EatOuter)"
+move ⊢ &p: &mut T
+
+move ⊢ p: T
+------------------------------------- "DerefMutWithShared(EatOuter)"
+ref mut ⊢ &p: T, T is not a reference
+
+move ⊢ p: T
+---------------- "DerefMutWithShared(EatBoth)"
+ref ⊢ &p: &mut T
+
+move ⊢ p: T
+-------------------- "DerefMutWithShared(EatBoth)"
+ref mut ⊢ &p: &mut T
+
+bm ⊢ ref x: T
+-------------- "RefBindingResetBindingMode"
+ref ⊢ ref x: T
+
+bm ⊢ ref x: T
+------------------ "RefBindingResetBindingMode"
+ref mut ⊢ ref x: T
+
+bm ⊢ ref mut x: T
+------------------ "RefBindingResetBindingMode"
+ref ⊢ ref mut x: T
+
+bm ⊢ ref mut x: T
+---------------------- "RefBindingResetBindingMode"
+ref mut ⊢ ref mut x: T
+
+bm ⊢ mut x: T
+-------------- "MutBindingResetBindingMode"
+ref ⊢ mut x: T
+
+bm ⊢ mut x: T
+------------------ "MutBindingResetBindingMode"
+ref mut ⊢ mut x: T
+
+ref ⊢ x: T
+--------------- "BindingBorrow"
+move ⊢ ref x: T
+
+ref mut ⊢ x: T
+------------------- "BindingBorrow"
+move ⊢ ref mut x: T
+
+
+--------- "Binding"
+bm ⊢ x: T
+
+
+--------------- "Binding"
+move ⊢ mut x: T