From cb7efa463803b7c4bb8487fe86e97ff3f3e37d6b Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Mon, 27 Jan 2025 22:52:39 +0100 Subject: [PATCH] Commit output with new ruleset names --- ...ules@rfc3627_2021_always_eat_both-Let.snap | 143 ++++++++++++++ ..._2021_always_eat_both-SequentInMemory.snap | 175 ++++++++++++++++++ ...21_always_eat_both-SequentUserVisible.snap | 143 ++++++++++++++ ...ules@rfc3627_no_binding_modifiers-Let.snap | 123 ++++++++++++ ..._no_binding_modifiers-SequentInMemory.snap | 155 ++++++++++++++++ ..._binding_modifiers-SequentUserVisible.snap | 123 ++++++++++++ ...es@stateless_no_binding_modifiers-Let.snap | 71 +++++++ ..._no_binding_modifiers-SequentInMemory.snap | 107 +++++++++++ ..._binding_modifiers-SequentUserVisible.snap | 71 +++++++ .../ruleset_encodings@ruleset-encodings.snap | 3 + .../trace_cli@11515459865669657874.snap | 3 + .../trace_cli@16736406663811832092.snap | 3 + .../trace_cli@17515479014605656910.snap | 3 + .../trace_cli@3615762548608754050.snap | 3 + 14 files changed, 1126 insertions(+) create mode 100644 tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-Let.snap create mode 100644 tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-SequentInMemory.snap create mode 100644 tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-SequentUserVisible.snap create mode 100644 tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-Let.snap create mode 100644 tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-SequentInMemory.snap create mode 100644 tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-SequentUserVisible.snap create mode 100644 tests/snapshots/bundle_rules@stateless_no_binding_modifiers-Let.snap create mode 100644 tests/snapshots/bundle_rules@stateless_no_binding_modifiers-SequentInMemory.snap create mode 100644 tests/snapshots/bundle_rules@stateless_no_binding_modifiers-SequentUserVisible.snap diff --git a/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-Let.snap b/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-Let.snap new file mode 100644 index 0000000..3bb66c2 --- /dev/null +++ b/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-Let.snap @@ -0,0 +1,143 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: rfc3627_2021_always_eat_both + 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: true + 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, e mutable + +let p0: &T0 = &(*e).0, let p1: &T1 = &(*e).1 +--------------------------------------------- "ConstructorRef(ForceReadOnly)" +let [p0, p1]: &mut [T0, T1] = e, e read-only + +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, e mutable + +let [p0, p1]: &T = &**e +------------------------------------------ "ConstructorMultiRef(ForceReadOnly)" +let [p0, p1]: &mut &mut T = e, e read-only + +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 diff --git a/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-SequentInMemory.snap b/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-SequentInMemory.snap new file mode 100644 index 0000000..164303c --- /dev/null +++ b/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-SequentInMemory.snap @@ -0,0 +1,175 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: rfc3627_2021_always_eat_both + 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: true + eat_mut_inside_shared: true + ref_binding_on_inherited: ResetBindingMode + mut_binding_on_inherited: ResetBindingMode +--- +move, m ⊢ p0: T0, move, m ⊢ p1: T1 +----------------------------------- "Constructor" +move, m ⊢ [p0, p1]: [T0, T1] + +ref, ro ⊢ p0: T0, ref, ro ⊢ p1: T1 +----------------------------------- "ConstructorRef" +move, m ⊢ [p0, p1]: &[T0, T1] + +ref, ro ⊢ p0: T0, ref, ro ⊢ p1: T1 +----------------------------------- "ConstructorRef" +ref, m ⊢ [p0, p1]: [T0, T1] + +ref mut, rw ⊢ p0: T0, ref mut, rw ⊢ p1: T1 +------------------------------------------- "ConstructorRef" +move, rw ⊢ [p0, p1]: &mut [T0, T1] + +ref mut, rw ⊢ p0: T0, ref mut, rw ⊢ p1: T1 +------------------------------------------- "ConstructorRef" +ref mut, rw ⊢ [p0, p1]: [T0, T1] + +ref, ro ⊢ p0: T0, ref, ro ⊢ p1: T1 +----------------------------------- "ConstructorRef(ForceReadOnly)" +move, ro ⊢ [p0, p1]: &mut [T0, T1] + +ref, ro ⊢ p0: T0, ref, ro ⊢ p1: T1 +----------------------------------- "ConstructorRef(ForceReadOnly)" +ref mut, ro ⊢ [p0, p1]: [T0, T1] + +ref, ro ⊢ [p0, p1]: T +----------------------- "ConstructorMultiRef" +move, m ⊢ [p0, p1]: &&T + +ref, ro ⊢ [p0, p1]: T +--------------------------- "ConstructorMultiRef" +move, m ⊢ [p0, p1]: &&mut T + +ref, ro ⊢ [p0, p1]: T +--------------------- "ConstructorMultiRef" +ref, m ⊢ [p0, p1]: &T + +ref, ro ⊢ [p0, p1]: T +------------------------- "ConstructorMultiRef" +ref, m ⊢ [p0, p1]: &mut T + +ref, ro ⊢ [p0, p1]: T +--------------------------- "ConstructorMultiRef" +move, m ⊢ [p0, p1]: &mut &T + +ref mut, rw ⊢ [p0, p1]: T +-------------------------------- "ConstructorMultiRef" +move, rw ⊢ [p0, p1]: &mut &mut T + +ref, ro ⊢ [p0, p1]: T +------------------------- "ConstructorMultiRef" +ref mut, m ⊢ [p0, p1]: &T + +ref mut, rw ⊢ [p0, p1]: T +------------------------------ "ConstructorMultiRef" +ref mut, rw ⊢ [p0, p1]: &mut T + +ref, ro ⊢ [p0, p1]: T +-------------------------------- "ConstructorMultiRef(ForceReadOnly)" +move, ro ⊢ [p0, p1]: &mut &mut T + +ref, ro ⊢ [p0, p1]: T +------------------------------ "ConstructorMultiRef(ForceReadOnly)" +ref mut, ro ⊢ [p0, p1]: &mut T + +move, ro ⊢ p: T +---------------- "Deref(EatOuter)" +move, m ⊢ &p: &T + +move, ro ⊢ p: T +------------------------------------ "Deref(EatOuter)" +ref, m ⊢ &p: T, T is not a reference + +move, m ⊢ p: T +------------------------ "Deref(EatOuter)" +move, m ⊢ &mut p: &mut T + +move, m ⊢ p: T +-------------------------------------------- "Deref(EatOuter)" +ref mut, m ⊢ &mut p: T, T is not a reference + +move, ro ⊢ p: T +--------------- "Deref(EatBoth)" +ref, m ⊢ &p: &T + +move, ro ⊢ p: T +------------------- "Deref(EatBoth)" +ref mut, m ⊢ &p: &T + +move, m ⊢ p: T +----------------------- "Deref(EatBoth)" +ref, m ⊢ &mut p: &mut T + +move, m ⊢ p: T +--------------------------- "Deref(EatBoth)" +ref mut, m ⊢ &mut p: &mut T + +move, ro ⊢ p: T +----------------------- "Deref(EatBoth, FallbackToOuter(EatBoth))" +ref mut, m ⊢ &mut p: &T + +move, ro ⊢ p: T +-------------------- "DerefMutWithShared(EatOuter)" +move, m ⊢ &p: &mut T + +move, ro ⊢ p: T +---------------------------------------- "DerefMutWithShared(EatOuter)" +ref mut, m ⊢ &p: T, T is not a reference + +move, ro ⊢ p: T +------------------- "DerefMutWithShared(EatBoth)" +ref, m ⊢ &p: &mut T + +move, ro ⊢ p: T +----------------------- "DerefMutWithShared(EatBoth)" +ref mut, m ⊢ &p: &mut T + +bm, m ⊢ ref x: T +----------------- "RefBindingResetBindingMode" +ref, m ⊢ ref x: T + +bm, m ⊢ ref x: T +--------------------- "RefBindingResetBindingMode" +ref mut, m ⊢ ref x: T + +bm, m ⊢ ref mut x: T +--------------------- "RefBindingResetBindingMode" +ref, m ⊢ ref mut x: T + +bm, m ⊢ ref mut x: T +------------------------- "RefBindingResetBindingMode" +ref mut, m ⊢ ref mut x: T + +bm, m ⊢ mut x: T +----------------- "MutBindingResetBindingMode" +ref, m ⊢ mut x: T + +bm, m ⊢ mut x: T +--------------------- "MutBindingResetBindingMode" +ref mut, m ⊢ mut x: T + +ref, m ⊢ x: T +------------------ "BindingBorrow" +move, m ⊢ ref x: T + +ref mut, m ⊢ x: T +---------------------- "BindingBorrow" +move, m ⊢ ref mut x: T + + +------------ "Binding" +bm, m ⊢ x: T + + +------------------ "Binding" +move, m ⊢ mut x: T diff --git a/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-SequentUserVisible.snap b/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-SequentUserVisible.snap new file mode 100644 index 0000000..1300b35 --- /dev/null +++ b/tests/snapshots/bundle_rules@rfc3627_2021_always_eat_both-SequentUserVisible.snap @@ -0,0 +1,143 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: rfc3627_2021_always_eat_both + 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: true + eat_mut_inside_shared: true + ref_binding_on_inherited: ResetBindingMode + mut_binding_on_inherited: ResetBindingMode +--- +real, m ⊢ p0: T0, real, m ⊢ p1: T1 +----------------------------------- "Constructor" +_, m ⊢ [p0, p1]: [T0, T1] + +inh, ro ⊢ p0: &T0, inh, ro ⊢ p1: &T1 +------------------------------------- "ConstructorRef" +r, m ⊢ [p0, p1]: &[T0, T1] + +inh, rw ⊢ p0: &mut T0, inh, rw ⊢ p1: &mut T1 +--------------------------------------------- "ConstructorRef" +r, rw ⊢ [p0, p1]: &mut [T0, T1] + +inh, ro ⊢ p0: &T0, inh, ro ⊢ p1: &T1 +------------------------------------- "ConstructorRef(ForceReadOnly)" +r, ro ⊢ [p0, p1]: &mut [T0, T1] + +inh, ro ⊢ [p0, p1]: &T +---------------------- "ConstructorMultiRef" +r, m ⊢ [p0, p1]: &&T + +inh, ro ⊢ [p0, p1]: &T +------------------------ "ConstructorMultiRef" +r, m ⊢ [p0, p1]: &&mut T + +inh, ro ⊢ [p0, p1]: &T +------------------------ "ConstructorMultiRef" +r, m ⊢ [p0, p1]: &mut &T + +inh, rw ⊢ [p0, p1]: &mut T +----------------------------- "ConstructorMultiRef" +r, rw ⊢ [p0, p1]: &mut &mut T + +inh, ro ⊢ [p0, p1]: &T +----------------------------- "ConstructorMultiRef(ForceReadOnly)" +r, ro ⊢ [p0, p1]: &mut &mut T + +real, ro ⊢ p: T +---------------- "Deref(EatOuter)" +real, m ⊢ &p: &T + +_, ro ⊢ p: T +------------------------------------- "Deref(EatOuter)" +inh, m ⊢ &p: &T, T is not a reference + +real, m ⊢ p: T +------------------------ "Deref(EatOuter)" +real, m ⊢ &mut p: &mut T + +_, m ⊢ p: T +--------------------------------------------- "Deref(EatOuter)" +inh, m ⊢ &mut p: &mut T, T is not a reference + +real, ro ⊢ p: T +---------------- "Deref(EatBoth)" +inh, m ⊢ &p: &&T + +real, ro ⊢ p: T +-------------------- "Deref(EatBoth)" +inh, m ⊢ &p: &mut &T + +real, m ⊢ p: T +------------------------ "Deref(EatBoth)" +inh, m ⊢ &mut p: &&mut T + +real, m ⊢ p: T +---------------------------- "Deref(EatBoth)" +inh, m ⊢ &mut p: &mut &mut T + +real, ro ⊢ p: T +------------------------ "Deref(EatBoth, FallbackToOuter(EatBoth))" +inh, m ⊢ &mut p: &mut &T + +real, ro ⊢ p: T +-------------------- "DerefMutWithShared(EatOuter)" +real, m ⊢ &p: &mut T + +_, ro ⊢ p: T +----------------------------------------- "DerefMutWithShared(EatOuter)" +inh, m ⊢ &p: &mut T, T is not a reference + +real, ro ⊢ p: T +-------------------- "DerefMutWithShared(EatBoth)" +inh, m ⊢ &p: &&mut T + +real, ro ⊢ p: T +------------------------ "DerefMutWithShared(EatBoth)" +inh, m ⊢ &p: &mut &mut T + +r, m ⊢ ref x: T +------------------ "RefBindingResetBindingMode" +inh, m ⊢ ref x: &T + +r, m ⊢ ref x: T +---------------------- "RefBindingResetBindingMode" +inh, m ⊢ ref x: &mut T + +r, m ⊢ ref mut x: T +---------------------- "RefBindingResetBindingMode" +inh, m ⊢ ref mut x: &T + +r, m ⊢ ref mut x: T +-------------------------- "RefBindingResetBindingMode" +inh, m ⊢ ref mut x: &mut T + +r, m ⊢ mut x: T +------------------ "MutBindingResetBindingMode" +inh, m ⊢ mut x: &T + +r, m ⊢ mut x: T +---------------------- "MutBindingResetBindingMode" +inh, m ⊢ mut x: &mut T + +inh, m ⊢ x: &T +------------------ "BindingBorrow" +real, m ⊢ ref x: T + +inh, m ⊢ x: &mut T +---------------------- "BindingBorrow" +real, m ⊢ ref mut x: T + + +----------- "Binding" +r, m ⊢ x: T + + +------------------ "Binding" +real, m ⊢ mut x: T diff --git a/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-Let.snap b/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-Let.snap new file mode 100644 index 0000000..3821ea0 --- /dev/null +++ b/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-Let.snap @@ -0,0 +1,123 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: rfc3627_no_binding_modifiers + options: + match_constructor_through_ref: true + eat_inherited_ref_alone: true + inherited_ref_on_ref: EatInner + fallback_to_outer: EatOuter + allow_ref_pat_on_ref_mut: true + simplify_deref_mut: true + downgrade_mut_inside_shared: true + eat_mut_inside_shared: true + ref_binding_on_inherited: Error + mut_binding_on_inherited: Error +--- +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, e mutable + +let p0: &T0 = &(*e).0, let p1: &T1 = &(*e).1 +--------------------------------------------- "ConstructorRef(ForceReadOnly)" +let [p0, p1]: &mut [T0, T1] = e, e read-only + +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, e mutable + +let [p0, p1]: &T = &**e +------------------------------------------ "ConstructorMultiRef(ForceReadOnly)" +let [p0, p1]: &mut &mut T = e, e read-only + +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(EatInner)" +let &p: &&T = &e + +let p: &T = &*e +------------------------ "Deref(EatInner)" +let &mut p: &&mut T = &e + +let p: &mut T = &mut *e +------------------------------------------- "Deref(EatInner)" +let &mut p: &mut &mut T = &mut e, e mutable + +let p: &T = *&mut e +---------------------------- "Deref(EatInner, FallbackToOuter(EatOuter))" +let &mut p: &mut &T = &mut e + +let p: &T = &*e +------------------------ "Deref(EatInner, ForceReadOnly)" +let &p: &mut &T = &mut e + +let p: &T = &*e +--------------------------------------------- "Deref(EatInner, ForceReadOnly)" +let &mut p: &mut &mut T = &mut e, e read-only + +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(EatInner)" +let &p: &&mut T = &e + +let p: &T = &*&*e +---------------------------- "DerefMutWithShared(EatInner)" +let &p: &mut &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 diff --git a/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-SequentInMemory.snap b/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-SequentInMemory.snap new file mode 100644 index 0000000..eef0a79 --- /dev/null +++ b/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-SequentInMemory.snap @@ -0,0 +1,155 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: rfc3627_no_binding_modifiers + options: + match_constructor_through_ref: true + eat_inherited_ref_alone: true + inherited_ref_on_ref: EatInner + fallback_to_outer: EatOuter + allow_ref_pat_on_ref_mut: true + simplify_deref_mut: true + downgrade_mut_inside_shared: true + eat_mut_inside_shared: true + ref_binding_on_inherited: Error + mut_binding_on_inherited: Error +--- +move, m ⊢ p0: T0, move, m ⊢ p1: T1 +----------------------------------- "Constructor" +move, m ⊢ [p0, p1]: [T0, T1] + +ref, ro ⊢ p0: T0, ref, ro ⊢ p1: T1 +----------------------------------- "ConstructorRef" +move, m ⊢ [p0, p1]: &[T0, T1] + +ref, ro ⊢ p0: T0, ref, ro ⊢ p1: T1 +----------------------------------- "ConstructorRef" +ref, m ⊢ [p0, p1]: [T0, T1] + +ref mut, rw ⊢ p0: T0, ref mut, rw ⊢ p1: T1 +------------------------------------------- "ConstructorRef" +move, rw ⊢ [p0, p1]: &mut [T0, T1] + +ref mut, rw ⊢ p0: T0, ref mut, rw ⊢ p1: T1 +------------------------------------------- "ConstructorRef" +ref mut, rw ⊢ [p0, p1]: [T0, T1] + +ref, ro ⊢ p0: T0, ref, ro ⊢ p1: T1 +----------------------------------- "ConstructorRef(ForceReadOnly)" +move, ro ⊢ [p0, p1]: &mut [T0, T1] + +ref, ro ⊢ p0: T0, ref, ro ⊢ p1: T1 +----------------------------------- "ConstructorRef(ForceReadOnly)" +ref mut, ro ⊢ [p0, p1]: [T0, T1] + +ref, ro ⊢ [p0, p1]: T +----------------------- "ConstructorMultiRef" +move, m ⊢ [p0, p1]: &&T + +ref, ro ⊢ [p0, p1]: T +--------------------------- "ConstructorMultiRef" +move, m ⊢ [p0, p1]: &&mut T + +ref, ro ⊢ [p0, p1]: T +--------------------- "ConstructorMultiRef" +ref, m ⊢ [p0, p1]: &T + +ref, ro ⊢ [p0, p1]: T +------------------------- "ConstructorMultiRef" +ref, m ⊢ [p0, p1]: &mut T + +ref, ro ⊢ [p0, p1]: T +--------------------------- "ConstructorMultiRef" +move, m ⊢ [p0, p1]: &mut &T + +ref mut, rw ⊢ [p0, p1]: T +-------------------------------- "ConstructorMultiRef" +move, rw ⊢ [p0, p1]: &mut &mut T + +ref, ro ⊢ [p0, p1]: T +------------------------- "ConstructorMultiRef" +ref mut, m ⊢ [p0, p1]: &T + +ref mut, rw ⊢ [p0, p1]: T +------------------------------ "ConstructorMultiRef" +ref mut, rw ⊢ [p0, p1]: &mut T + +ref, ro ⊢ [p0, p1]: T +-------------------------------- "ConstructorMultiRef(ForceReadOnly)" +move, ro ⊢ [p0, p1]: &mut &mut T + +ref, ro ⊢ [p0, p1]: T +------------------------------ "ConstructorMultiRef(ForceReadOnly)" +ref mut, ro ⊢ [p0, p1]: &mut T + +move, ro ⊢ p: T +---------------- "Deref(EatOuter)" +move, m ⊢ &p: &T + +move, ro ⊢ p: T +------------------------------------ "Deref(EatOuter)" +ref, m ⊢ &p: T, T is not a reference + +move, m ⊢ p: T +------------------------ "Deref(EatOuter)" +move, m ⊢ &mut p: &mut T + +move, m ⊢ p: T +-------------------------------------------- "Deref(EatOuter)" +ref mut, m ⊢ &mut p: T, T is not a reference + +ref, ro ⊢ p: T +--------------- "Deref(EatInner)" +ref, m ⊢ &p: &T + +ref, m ⊢ p: T +----------------------- "Deref(EatInner)" +ref, m ⊢ &mut p: &mut T + +ref mut, rw ⊢ p: T +---------------------------- "Deref(EatInner)" +ref mut, rw ⊢ &mut p: &mut T + +move, m ⊢ p: &T +----------------------- "Deref(EatInner, FallbackToOuter(EatOuter))" +ref mut, m ⊢ &mut p: &T + +ref, ro ⊢ p: T +------------------- "Deref(EatInner, ForceReadOnly)" +ref mut, m ⊢ &p: &T + +ref, ro ⊢ p: T +---------------------------- "Deref(EatInner, ForceReadOnly)" +ref mut, ro ⊢ &mut p: &mut T + +move, ro ⊢ p: T +-------------------- "DerefMutWithShared(EatOuter)" +move, m ⊢ &p: &mut T + +move, ro ⊢ p: T +---------------------------------------- "DerefMutWithShared(EatOuter)" +ref mut, m ⊢ &p: T, T is not a reference + +ref, ro ⊢ p: T +------------------- "DerefMutWithShared(EatInner)" +ref, m ⊢ &p: &mut T + +ref, ro ⊢ p: T +----------------------- "DerefMutWithShared(EatInner)" +ref mut, m ⊢ &p: &mut T + +ref, m ⊢ x: T +------------------ "BindingBorrow" +move, m ⊢ ref x: T + +ref mut, m ⊢ x: T +---------------------- "BindingBorrow" +move, m ⊢ ref mut x: T + + +------------ "Binding" +bm, m ⊢ x: T + + +------------------ "Binding" +move, m ⊢ mut x: T diff --git a/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-SequentUserVisible.snap b/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-SequentUserVisible.snap new file mode 100644 index 0000000..c5d7f69 --- /dev/null +++ b/tests/snapshots/bundle_rules@rfc3627_no_binding_modifiers-SequentUserVisible.snap @@ -0,0 +1,123 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: rfc3627_no_binding_modifiers + options: + match_constructor_through_ref: true + eat_inherited_ref_alone: true + inherited_ref_on_ref: EatInner + fallback_to_outer: EatOuter + allow_ref_pat_on_ref_mut: true + simplify_deref_mut: true + downgrade_mut_inside_shared: true + eat_mut_inside_shared: true + ref_binding_on_inherited: Error + mut_binding_on_inherited: Error +--- +real, m ⊢ p0: T0, real, m ⊢ p1: T1 +----------------------------------- "Constructor" +_, m ⊢ [p0, p1]: [T0, T1] + +inh, ro ⊢ p0: &T0, inh, ro ⊢ p1: &T1 +------------------------------------- "ConstructorRef" +r, m ⊢ [p0, p1]: &[T0, T1] + +inh, rw ⊢ p0: &mut T0, inh, rw ⊢ p1: &mut T1 +--------------------------------------------- "ConstructorRef" +r, rw ⊢ [p0, p1]: &mut [T0, T1] + +inh, ro ⊢ p0: &T0, inh, ro ⊢ p1: &T1 +------------------------------------- "ConstructorRef(ForceReadOnly)" +r, ro ⊢ [p0, p1]: &mut [T0, T1] + +inh, ro ⊢ [p0, p1]: &T +---------------------- "ConstructorMultiRef" +r, m ⊢ [p0, p1]: &&T + +inh, ro ⊢ [p0, p1]: &T +------------------------ "ConstructorMultiRef" +r, m ⊢ [p0, p1]: &&mut T + +inh, ro ⊢ [p0, p1]: &T +------------------------ "ConstructorMultiRef" +r, m ⊢ [p0, p1]: &mut &T + +inh, rw ⊢ [p0, p1]: &mut T +----------------------------- "ConstructorMultiRef" +r, rw ⊢ [p0, p1]: &mut &mut T + +inh, ro ⊢ [p0, p1]: &T +----------------------------- "ConstructorMultiRef(ForceReadOnly)" +r, ro ⊢ [p0, p1]: &mut &mut T + +real, ro ⊢ p: T +---------------- "Deref(EatOuter)" +real, m ⊢ &p: &T + +_, ro ⊢ p: T +------------------------------------- "Deref(EatOuter)" +inh, m ⊢ &p: &T, T is not a reference + +real, m ⊢ p: T +------------------------ "Deref(EatOuter)" +real, m ⊢ &mut p: &mut T + +_, m ⊢ p: T +--------------------------------------------- "Deref(EatOuter)" +inh, m ⊢ &mut p: &mut T, T is not a reference + +inh, ro ⊢ p: &T +---------------- "Deref(EatInner)" +inh, m ⊢ &p: &&T + +inh, m ⊢ p: &T +------------------------ "Deref(EatInner)" +inh, m ⊢ &mut p: &&mut T + +inh, rw ⊢ p: &mut T +----------------------------- "Deref(EatInner)" +inh, rw ⊢ &mut p: &mut &mut T + +real, m ⊢ p: &T +------------------------ "Deref(EatInner, FallbackToOuter(EatOuter))" +inh, m ⊢ &mut p: &mut &T + +inh, ro ⊢ p: &T +-------------------- "Deref(EatInner, ForceReadOnly)" +inh, m ⊢ &p: &mut &T + +inh, ro ⊢ p: &T +----------------------------- "Deref(EatInner, ForceReadOnly)" +inh, ro ⊢ &mut p: &mut &mut T + +real, ro ⊢ p: T +-------------------- "DerefMutWithShared(EatOuter)" +real, m ⊢ &p: &mut T + +_, ro ⊢ p: T +----------------------------------------- "DerefMutWithShared(EatOuter)" +inh, m ⊢ &p: &mut T, T is not a reference + +inh, ro ⊢ p: &T +-------------------- "DerefMutWithShared(EatInner)" +inh, m ⊢ &p: &&mut T + +inh, ro ⊢ p: &T +------------------------ "DerefMutWithShared(EatInner)" +inh, m ⊢ &p: &mut &mut T + +inh, m ⊢ x: &T +------------------ "BindingBorrow" +real, m ⊢ ref x: T + +inh, m ⊢ x: &mut T +---------------------- "BindingBorrow" +real, m ⊢ ref mut x: T + + +----------- "Binding" +r, m ⊢ x: T + + +------------------ "Binding" +real, m ⊢ mut x: T diff --git a/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-Let.snap b/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-Let.snap new file mode 100644 index 0000000..91388b7 --- /dev/null +++ b/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-Let.snap @@ -0,0 +1,71 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: stateless_no_binding_modifiers + options: + match_constructor_through_ref: true + eat_inherited_ref_alone: true + inherited_ref_on_ref: EatOuter + fallback_to_outer: "No" + 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: Error + mut_binding_on_inherited: Error +--- +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" +let &p: &T = e + +let p: T = *e +---------------------- "Deref" +let &mut p: &mut T = e + +let p: T = *&*e +------------------ "DerefMutWithShared" +let &p: &mut T = 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 diff --git a/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-SequentInMemory.snap b/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-SequentInMemory.snap new file mode 100644 index 0000000..937b3fe --- /dev/null +++ b/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-SequentInMemory.snap @@ -0,0 +1,107 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: stateless_no_binding_modifiers + options: + match_constructor_through_ref: true + eat_inherited_ref_alone: true + inherited_ref_on_ref: EatOuter + fallback_to_outer: "No" + 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: Error + mut_binding_on_inherited: Error +--- +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" +move ⊢ &p: &T + +move ⊢ p: T +----------- "Deref" +ref ⊢ &p: T + +move ⊢ p: T +--------------------- "Deref" +move ⊢ &mut p: &mut T + +move ⊢ p: T +------------------- "Deref" +ref mut ⊢ &mut p: T + +move ⊢ p: T +----------------- "DerefMutWithShared" +move ⊢ &p: &mut T + +move ⊢ p: T +--------------- "DerefMutWithShared" +ref mut ⊢ &p: 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 diff --git a/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-SequentUserVisible.snap b/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-SequentUserVisible.snap new file mode 100644 index 0000000..2902535 --- /dev/null +++ b/tests/snapshots/bundle_rules@stateless_no_binding_modifiers-SequentUserVisible.snap @@ -0,0 +1,71 @@ +--- +source: src/analyses/compute_rules.rs +info: + bundle_name: stateless_no_binding_modifiers + options: + match_constructor_through_ref: true + eat_inherited_ref_alone: true + inherited_ref_on_ref: EatOuter + fallback_to_outer: "No" + 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: Error + mut_binding_on_inherited: Error +--- +real ⊢ p0: T0, real ⊢ p1: T1 +----------------------------- "Constructor" +_ ⊢ [p0, p1]: [T0, T1] + +inh ⊢ p0: &T0, inh ⊢ p1: &T1 +----------------------------- "ConstructorRef" +r ⊢ [p0, p1]: &[T0, T1] + +inh ⊢ p0: &mut T0, inh ⊢ p1: &mut T1 +------------------------------------- "ConstructorRef" +r ⊢ [p0, p1]: &mut [T0, T1] + +inh ⊢ [p0, p1]: &T +------------------ "ConstructorMultiRef" +r ⊢ [p0, p1]: &&T + +inh ⊢ [p0, p1]: &T +--------------------- "ConstructorMultiRef" +r ⊢ [p0, p1]: &&mut T + +inh ⊢ [p0, p1]: &T +--------------------- "ConstructorMultiRef" +r ⊢ [p0, p1]: &mut &T + +inh ⊢ [p0, p1]: &mut T +------------------------- "ConstructorMultiRef" +r ⊢ [p0, p1]: &mut &mut T + +real ⊢ p: T +----------- "Deref" +r ⊢ &p: &T + +real ⊢ p: T +------------------ "Deref" +r ⊢ &mut p: &mut T + +real ⊢ p: T +-------------- "DerefMutWithShared" +r ⊢ &p: &mut T + +inh ⊢ x: &T +--------------- "BindingBorrow" +real ⊢ ref x: T + +inh ⊢ x: &mut T +------------------- "BindingBorrow" +real ⊢ ref mut x: T + + +-------- "Binding" +r ⊢ x: T + + +--------------- "Binding" +real ⊢ mut x: T diff --git a/tests/snapshots/ruleset_encodings@ruleset-encodings.snap b/tests/snapshots/ruleset_encodings@ruleset-encodings.snap index 48502ef..dfb853e 100644 --- a/tests/snapshots/ruleset_encodings@ruleset-encodings.snap +++ b/tests/snapshots/ruleset_encodings@ruleset-encodings.snap @@ -4,10 +4,13 @@ source: src/wasm.rs stable_rust: AQEAAQAAAQABAAAAAAAAAAAAAAAAAAA= stateless: AQEBAAABAQABAQEAAAAAAAAAAAAAAAA= stateless_no_temporaries: AQEBAAABAQABAgEAAAAAAAAAAAAAAAA= +stateless_no_binding_modifiers: AQEBAAABAQABAgIAAAAAAAAAAAAAAAA= stateless_2021: AQEBAQABAQABAAAAAAAAAAAAAAAAAAA= eat_outer_2021: AQEBAQIBAQABAAAAAAAAAAAAAAAAAAA= rfc3627: AQEBAgEBAQEBAAIAAAAAAAAAAAAAAAA= +rfc3627_no_binding_modifiers: AQEBAgEBAQEBAgIAAAAAAAAAAAAAAAA= rfc3627_2021: AQEBAQEBAQEBAAAAAAAAAAAAAAAAAAA= +rfc3627_2021_always_eat_both: AQEBAQIBAQEBAAAAAAAAAAAAAAAAAAA= rfc3627_2024_min: AQEAAgAAAQABAAIAAAAAAAAAAAAAAAA= structural: AQAAAwAAAQAAAQEAAAAAAAAAAAAAAAA= min_ergonomics: AQEAAwAAAQAAAgIAAAAAAAAAAAAAAAA= diff --git a/tests/snapshots/trace_cli@11515459865669657874.snap b/tests/snapshots/trace_cli@11515459865669657874.snap index 857a914..3408690 100644 --- a/tests/snapshots/trace_cli@11515459865669657874.snap +++ b/tests/snapshots/trace_cli@11515459865669657874.snap @@ -32,10 +32,13 @@ There also exist some predefined option-bundles. Activate one with `set - stable_rust: The behavior of current stable rust - stateless: A proposal that tracks no hidden state; purely type-based - stateless_no_temporaries: A reasonable proposal; like `stateless` but forbids `ref` bindings that create temporaries +- stateless_no_binding_modifiers: Like `stateless` but forbids `ref` and `mut` bindings on inherited references. - stateless_2021: The currently-planned version of the `stateless` ruleset for edition 2021. Not actually stateless. - eat_outer_2021: A backwards-compatible proposal by @dianne that behaves close to the 2024 stateless proposal. - rfc3627: The accepted RFC3627 behavior +- rfc3627_no_binding_modifiers: Like RFC3627 but forbids `ref` and `mut` bindings on inherited references. - rfc3627_2021: The accepted RFC3627 behavior under edition 2021 +- rfc3627_2021_always_eat_both: Variant of `rfc3627_2021` proposed by @dianne that always eats two layers of references. - rfc3627_2024_min: The breaking changes for edition 2024 planned in RFC3627 - structural: Purely structural matching, with no match ergonomics - min_ergonomics: The minimal amout of match ergonomics that's forward-compatible with most proposals diff --git a/tests/snapshots/trace_cli@16736406663811832092.snap b/tests/snapshots/trace_cli@16736406663811832092.snap index 59e01b7..5ccea2b 100644 --- a/tests/snapshots/trace_cli@16736406663811832092.snap +++ b/tests/snapshots/trace_cli@16736406663811832092.snap @@ -32,10 +32,13 @@ There also exist some predefined option-bundles. Activate one with `set - stable_rust: The behavior of current stable rust - stateless: A proposal that tracks no hidden state; purely type-based - stateless_no_temporaries: A reasonable proposal; like `stateless` but forbids `ref` bindings that create temporaries +- stateless_no_binding_modifiers: Like `stateless` but forbids `ref` and `mut` bindings on inherited references. - stateless_2021: The currently-planned version of the `stateless` ruleset for edition 2021. Not actually stateless. - eat_outer_2021: A backwards-compatible proposal by @dianne that behaves close to the 2024 stateless proposal. - rfc3627: The accepted RFC3627 behavior +- rfc3627_no_binding_modifiers: Like RFC3627 but forbids `ref` and `mut` bindings on inherited references. - rfc3627_2021: The accepted RFC3627 behavior under edition 2021 +- rfc3627_2021_always_eat_both: Variant of `rfc3627_2021` proposed by @dianne that always eats two layers of references. - rfc3627_2024_min: The breaking changes for edition 2024 planned in RFC3627 - structural: Purely structural matching, with no match ergonomics - min_ergonomics: The minimal amout of match ergonomics that's forward-compatible with most proposals diff --git a/tests/snapshots/trace_cli@17515479014605656910.snap b/tests/snapshots/trace_cli@17515479014605656910.snap index 691e8e3..06613c2 100644 --- a/tests/snapshots/trace_cli@17515479014605656910.snap +++ b/tests/snapshots/trace_cli@17515479014605656910.snap @@ -32,10 +32,13 @@ There also exist some predefined option-bundles. Activate one with `set - stable_rust: The behavior of current stable rust - stateless: A proposal that tracks no hidden state; purely type-based - stateless_no_temporaries: A reasonable proposal; like `stateless` but forbids `ref` bindings that create temporaries +- stateless_no_binding_modifiers: Like `stateless` but forbids `ref` and `mut` bindings on inherited references. - stateless_2021: The currently-planned version of the `stateless` ruleset for edition 2021. Not actually stateless. - eat_outer_2021: A backwards-compatible proposal by @dianne that behaves close to the 2024 stateless proposal. - rfc3627: The accepted RFC3627 behavior +- rfc3627_no_binding_modifiers: Like RFC3627 but forbids `ref` and `mut` bindings on inherited references. - rfc3627_2021: The accepted RFC3627 behavior under edition 2021 +- rfc3627_2021_always_eat_both: Variant of `rfc3627_2021` proposed by @dianne that always eats two layers of references. - rfc3627_2024_min: The breaking changes for edition 2024 planned in RFC3627 - structural: Purely structural matching, with no match ergonomics - min_ergonomics: The minimal amout of match ergonomics that's forward-compatible with most proposals diff --git a/tests/snapshots/trace_cli@3615762548608754050.snap b/tests/snapshots/trace_cli@3615762548608754050.snap index 8366f2b..a1fcab7 100644 --- a/tests/snapshots/trace_cli@3615762548608754050.snap +++ b/tests/snapshots/trace_cli@3615762548608754050.snap @@ -33,10 +33,13 @@ There also exist some predefined option-bundles. Activate one with `set - stable_rust: The behavior of current stable rust - stateless: A proposal that tracks no hidden state; purely type-based - stateless_no_temporaries: A reasonable proposal; like `stateless` but forbids `ref` bindings that create temporaries +- stateless_no_binding_modifiers: Like `stateless` but forbids `ref` and `mut` bindings on inherited references. - stateless_2021: The currently-planned version of the `stateless` ruleset for edition 2021. Not actually stateless. - eat_outer_2021: A backwards-compatible proposal by @dianne that behaves close to the 2024 stateless proposal. - rfc3627: The accepted RFC3627 behavior +- rfc3627_no_binding_modifiers: Like RFC3627 but forbids `ref` and `mut` bindings on inherited references. - rfc3627_2021: The accepted RFC3627 behavior under edition 2021 +- rfc3627_2021_always_eat_both: Variant of `rfc3627_2021` proposed by @dianne that always eats two layers of references. - rfc3627_2024_min: The breaking changes for edition 2024 planned in RFC3627 - structural: Purely structural matching, with no match ergonomics - min_ergonomics: The minimal amout of match ergonomics that's forward-compatible with most proposals