Rollup merge of rust-lang#155433 - oli-obk:bye-bye-long-attribute, r=RalfJung,ShoyuVanilla

JonathanBrouwer · web-flow · commit 9d3192a0aa63 · 2026-05-03T16:33:22.000+02:00
Rip out rustc_layout_scalar_valid_range_* attribute support And either removes tests for it or replaces the uses with pattern types. primarily fixes rust-lang#135996 fixes rust-lang#147761 fixes rust-lang#133652
diff --git a/tests/ui/eager_transmute.fixed b/tests/ui/eager_transmute.fixed
@@ -1,8 +1,9 @@
-#![feature(rustc_attrs)]
+#![feature(rustc_attrs, pattern_types, pattern_type_macro)]
 #![warn(clippy::eager_transmute)]
 #![allow(clippy::transmute_int_to_non_zero, clippy::missing_transmute_annotations)]
 
 use std::num::NonZero;
+use std::pat::pattern_type;
 
 #[repr(u8)]
 enum Opcode {
@@ -77,23 +78,25 @@ unsafe fn f2(op: u8) {
     }
 }
 
-#[rustc_layout_scalar_valid_range_end(254)]
-struct NonMaxU8(u8);
-#[rustc_layout_scalar_valid_range_end(254)]
-#[rustc_layout_scalar_valid_range_start(1)]
-struct NonZeroNonMaxU8(u8);
+struct NonMaxU8(pattern_type!(u8 is 0..=254));
+struct NonZeroNonMaxU8(pattern_type!(u8 is 1..=254));
 
 macro_rules! impls {
     ($($t:ty),*) => {
         $(
+            impl $t {
+                fn get(&self) -> u8 {
+                    unsafe { std::mem::transmute(self.0) }
+                }
+            }
             impl PartialEq<u8> for $t {
                 fn eq(&self, other: &u8) -> bool {
-                    self.0 == *other
+                    self.get() == *other
                 }
             }
             impl PartialOrd<u8> for $t {
                 fn partial_cmp(&self, other: &u8) -> Option<std::cmp::Ordering> {
-                    self.0.partial_cmp(other)
+                    self.get().partial_cmp(other)
                 }
             }
         )*
diff --git a/tests/ui/eager_transmute.rs b/tests/ui/eager_transmute.rs
@@ -1,8 +1,9 @@
-#![feature(rustc_attrs)]
+#![feature(rustc_attrs, pattern_types, pattern_type_macro)]
 #![warn(clippy::eager_transmute)]
 #![allow(clippy::transmute_int_to_non_zero, clippy::missing_transmute_annotations)]
 
 use std::num::NonZero;
+use std::pat::pattern_type;
 
 #[repr(u8)]
 enum Opcode {
@@ -77,23 +78,25 @@ unsafe fn f2(op: u8) {
     }
 }
 
-#[rustc_layout_scalar_valid_range_end(254)]
-struct NonMaxU8(u8);
-#[rustc_layout_scalar_valid_range_end(254)]
-#[rustc_layout_scalar_valid_range_start(1)]
-struct NonZeroNonMaxU8(u8);
+struct NonMaxU8(pattern_type!(u8 is 0..=254));
+struct NonZeroNonMaxU8(pattern_type!(u8 is 1..=254));
 
 macro_rules! impls {
     ($($t:ty),*) => {
         $(
+            impl $t {
+                fn get(&self) -> u8 {
+                    unsafe { std::mem::transmute(self.0) }
+                }
+            }
             impl PartialEq<u8> for $t {
                 fn eq(&self, other: &u8) -> bool {
-                    self.0 == *other
+                    self.get() == *other
                 }
             }
             impl PartialOrd<u8> for $t {
                 fn partial_cmp(&self, other: &u8) -> Option<std::cmp::Ordering> {
-                    self.0.partial_cmp(other)
+                    self.get().partial_cmp(other)
                 }
             }
         )*
diff --git a/tests/ui/eager_transmute.stderr b/tests/ui/eager_transmute.stderr
@@ -1,5 +1,5 @@
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:21:33
+  --> tests/ui/eager_transmute.rs:22:33
    |
 LL |     (op < 4).then_some(unsafe { std::mem::transmute(op) })
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     (op < 4).then(|| unsafe { std::mem::transmute(op) })
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:28:33
+  --> tests/ui/eager_transmute.rs:29:33
    |
 LL |     (op < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     (op < 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:30:33
+  --> tests/ui/eager_transmute.rs:31:33
    |
 LL |     (op > 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     (op > 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:32:34
+  --> tests/ui/eager_transmute.rs:33:34
    |
 LL |     (op == 0).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     (op == 0).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:35:68
+  --> tests/ui/eager_transmute.rs:36:68
    |
 LL |     let _: Option<Opcode> = (op > 0 && op < 10).then_some(unsafe { std::mem::transmute(op) });
    |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     let _: Option<Opcode> = (op > 0 && op < 10).then(|| unsafe { std::mem::
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:37:86
+  --> tests/ui/eager_transmute.rs:38:86
    |
 LL |     let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then_some(unsafe { std::mem::transmute(op) });
    |                                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then(|| u
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:41:84
+  --> tests/ui/eager_transmute.rs:42:84
    |
 LL |     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[0]) });
    |                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then(|| uns
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:54:70
+  --> tests/ui/eager_transmute.rs:55:70
    |
 LL |     let _: Option<Opcode> = (1..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     let _: Option<Opcode> = (1..=3).contains(&op).then(|| unsafe { std::mem
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:56:83
+  --> tests/ui/eager_transmute.rs:57:83
    |
 LL |     let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then_some(unsafe { std::mem::transmute(op) });
    |                                                                                   ^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then(|| unsa
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:58:69
+  --> tests/ui/eager_transmute.rs:59:69
    |
 LL |     let _: Option<Opcode> = (1..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     let _: Option<Opcode> = (1..3).contains(&op).then(|| unsafe { std::mem:
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:60:68
+  --> tests/ui/eager_transmute.rs:61:68
    |
 LL |     let _: Option<Opcode> = (1..).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     let _: Option<Opcode> = (1..).contains(&op).then(|| unsafe { std::mem::
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:62:68
+  --> tests/ui/eager_transmute.rs:63:68
    |
 LL |     let _: Option<Opcode> = (..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     let _: Option<Opcode> = (..3).contains(&op).then(|| unsafe { std::mem::
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:64:69
+  --> tests/ui/eager_transmute.rs:65:69
    |
 LL |     let _: Option<Opcode> = (..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     let _: Option<Opcode> = (..=3).contains(&op).then(|| unsafe { std::mem:
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:75:28
+  --> tests/ui/eager_transmute.rs:76:28
    |
 LL |         (op < 4).then_some(std::mem::transmute::<_, Opcode>(op));
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +         (op < 4).then(|| std::mem::transmute::<_, Opcode>(op));
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:106:62
+  --> tests/ui/eager_transmute.rs:109:62
    |
 LL |     let _: Option<NonZero<u8>> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
    |                                                              ^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     let _: Option<NonZero<u8>> = (v1 > 0).then(|| unsafe { std::mem::transm
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:113:86
+  --> tests/ui/eager_transmute.rs:116:86
    |
 LL |     let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
    |                                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(|| u
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:120:93
+  --> tests/ui/eager_transmute.rs:123:93
    |
 LL |     let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
    |                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`2`		`- --> tests/ui/eager_transmute.rs:21:33`
	`2`	`+ --> tests/ui/eager_transmute.rs:22:33`
`3`	`3`	`\|`
`4`	`4`	`LL \| (op < 4).then_some(unsafe { std::mem::transmute(op) })`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -13,7 +13,7 @@ LL + (op < 4).then(\|\| unsafe { std::mem::transmute(op) })`
`13`	`13`	`\|`
`14`	`14`
`15`	`15`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`16`		`- --> tests/ui/eager_transmute.rs:28:33`
	`16`	`+ --> tests/ui/eager_transmute.rs:29:33`
`17`	`17`	`\|`
`18`	`18`	`LL \| (op < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });`
`19`	`19`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -25,7 +25,7 @@ LL + (op < 4).then(\|\| unsafe { std::mem::transmute::<_, Opcode>(op) });`
`25`	`25`	`\|`
`26`	`26`
`27`	`27`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`28`		`- --> tests/ui/eager_transmute.rs:30:33`
	`28`	`+ --> tests/ui/eager_transmute.rs:31:33`
`29`	`29`	`\|`
`30`	`30`	`LL \| (op > 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });`
`31`	`31`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -37,7 +37,7 @@ LL + (op > 4).then(\|\| unsafe { std::mem::transmute::<_, Opcode>(op) });`
`37`	`37`	`\|`
`38`	`38`
`39`	`39`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`40`		`- --> tests/ui/eager_transmute.rs:32:34`
	`40`	`+ --> tests/ui/eager_transmute.rs:33:34`
`41`	`41`	`\|`
`42`	`42`	`LL \| (op == 0).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });`
`43`	`43`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -49,7 +49,7 @@ LL + (op == 0).then(\|\| unsafe { std::mem::transmute::<_, Opcode>(op) });`
`49`	`49`	`\|`
`50`	`50`
`51`	`51`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`52`		`- --> tests/ui/eager_transmute.rs:35:68`
	`52`	`+ --> tests/ui/eager_transmute.rs:36:68`
`53`	`53`	`\|`
`54`	`54`	`LL \| let _: Option<Opcode> = (op > 0 && op < 10).then_some(unsafe { std::mem::transmute(op) });`
`55`	`55`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -61,7 +61,7 @@ LL + let _: Option<Opcode> = (op > 0 && op < 10).then(\|\| unsafe { std::mem::`
`61`	`61`	`\|`
`62`	`62`
`63`	`63`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`64`		`- --> tests/ui/eager_transmute.rs:37:86`
	`64`	`+ --> tests/ui/eager_transmute.rs:38:86`
`65`	`65`	`\|`
`66`	`66`	`LL \| let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then_some(unsafe { std::mem::transmute(op) });`
`67`	`67`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -73,7 +73,7 @@ LL + let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then(\|\| u`
`73`	`73`	`\|`
`74`	`74`
`75`	`75`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`76`		`- --> tests/ui/eager_transmute.rs:41:84`
	`76`	`+ --> tests/ui/eager_transmute.rs:42:84`
`77`	`77`	`\|`
`78`	`78`	`LL \| let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[0]) });`
`79`	`79`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -85,7 +85,7 @@ LL + let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then(\|\| uns`
`85`	`85`	`\|`
`86`	`86`
`87`	`87`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`88`		`- --> tests/ui/eager_transmute.rs:54:70`
	`88`	`+ --> tests/ui/eager_transmute.rs:55:70`
`89`	`89`	`\|`
`90`	`90`	`LL \| let _: Option<Opcode> = (1..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });`
`91`	`91`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -97,7 +97,7 @@ LL + let _: Option<Opcode> = (1..=3).contains(&op).then(\|\| unsafe { std::mem`
`97`	`97`	`\|`
`98`	`98`
`99`	`99`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`100`		`- --> tests/ui/eager_transmute.rs:56:83`
	`100`	`+ --> tests/ui/eager_transmute.rs:57:83`
`101`	`101`	`\|`
`102`	`102`	`LL \| let _: Option<Opcode> = ((1..=3).contains(&op) \|\| op == 4).then_some(unsafe { std::mem::transmute(op) });`
`103`	`103`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -109,7 +109,7 @@ LL + let _: Option<Opcode> = ((1..=3).contains(&op) \|\| op == 4).then(\|\| unsa`
`109`	`109`	`\|`
`110`	`110`
`111`	`111`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`112`		`- --> tests/ui/eager_transmute.rs:58:69`
	`112`	`+ --> tests/ui/eager_transmute.rs:59:69`
`113`	`113`	`\|`
`114`	`114`	`LL \| let _: Option<Opcode> = (1..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });`
`115`	`115`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -121,7 +121,7 @@ LL + let _: Option<Opcode> = (1..3).contains(&op).then(\|\| unsafe { std::mem:`
`121`	`121`	`\|`
`122`	`122`
`123`	`123`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`124`		`- --> tests/ui/eager_transmute.rs:60:68`
	`124`	`+ --> tests/ui/eager_transmute.rs:61:68`
`125`	`125`	`\|`
`126`	`126`	`LL \| let _: Option<Opcode> = (1..).contains(&op).then_some(unsafe { std::mem::transmute(op) });`
`127`	`127`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -133,7 +133,7 @@ LL + let _: Option<Opcode> = (1..).contains(&op).then(\|\| unsafe { std::mem::`
`133`	`133`	`\|`
`134`	`134`
`135`	`135`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`136`		`- --> tests/ui/eager_transmute.rs:62:68`
	`136`	`+ --> tests/ui/eager_transmute.rs:63:68`
`137`	`137`	`\|`
`138`	`138`	`LL \| let _: Option<Opcode> = (..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });`
`139`	`139`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -145,7 +145,7 @@ LL + let _: Option<Opcode> = (..3).contains(&op).then(\|\| unsafe { std::mem::`
`145`	`145`	`\|`
`146`	`146`
`147`	`147`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`148`		`- --> tests/ui/eager_transmute.rs:64:69`
	`148`	`+ --> tests/ui/eager_transmute.rs:65:69`
`149`	`149`	`\|`
`150`	`150`	`LL \| let _: Option<Opcode> = (..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });`
`151`	`151`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -157,7 +157,7 @@ LL + let _: Option<Opcode> = (..=3).contains(&op).then(\|\| unsafe { std::mem:`
`157`	`157`	`\|`
`158`	`158`
`159`	`159`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`160`		`- --> tests/ui/eager_transmute.rs:75:28`
	`160`	`+ --> tests/ui/eager_transmute.rs:76:28`
`161`	`161`	`\|`
`162`	`162`	`LL \| (op < 4).then_some(std::mem::transmute::<_, Opcode>(op));`
`163`	`163`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -169,7 +169,7 @@ LL + (op < 4).then(\|\| std::mem::transmute::<_, Opcode>(op));`
`169`	`169`	`\|`
`170`	`170`
`171`	`171`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`172`		`- --> tests/ui/eager_transmute.rs:106:62`
	`172`	`+ --> tests/ui/eager_transmute.rs:109:62`
`173`	`173`	`\|`
`174`	`174`	`LL \| let _: Option<NonZero<u8>> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });`
`175`	`175`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -181,7 +181,7 @@ LL + let _: Option<NonZero<u8>> = (v1 > 0).then(\|\| unsafe { std::mem::transm`
`181`	`181`	`\|`
`182`	`182`
`183`	`183`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`184`		`- --> tests/ui/eager_transmute.rs:113:86`
	`184`	`+ --> tests/ui/eager_transmute.rs:116:86`
`185`	`185`	`\|`
`186`	`186`	`LL \| let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });`
`187`	`187`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -193,7 +193,7 @@ LL + let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(\|\| u`
`193`	`193`	`\|`
`194`	`194`
`195`	`195`	`error: this transmute is always evaluated eagerly, even if the condition is false`
`196`		`- --> tests/ui/eager_transmute.rs:120:93`
	`196`	`+ --> tests/ui/eager_transmute.rs:123:93`
`197`	`197`	`\|`
`198`	`198`	`LL \| let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });`
`199`	`199`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`