Fix removed unstable features

thaliaarchi · thaliaarchi · commit 90010a966ecc · 2023-06-08T18:40:41.000-06:00
diff --git a/src/bf/mod.rs b/src/bf/mod.rs
@@ -51,7 +51,7 @@ pub enum InstExt {
     Debug,
 }
 
-impl const VariantIndex for Inst {
+impl VariantIndex for Inst {
     const COUNT: u32 = 8;
     #[inline]
     fn variant(index: u32) -> Self {
@@ -63,7 +63,7 @@ impl const VariantIndex for Inst {
     }
 }
 
-impl const VariantIndex for InstExt {
+impl VariantIndex for InstExt {
     const COUNT: u32 = 9;
     #[inline]
     fn variant(index: u32) -> Self {
diff --git a/src/bf/ook.rs b/src/bf/ook.rs
@@ -75,7 +75,7 @@ pub static TABLE: LazyLock<PrefixTable<Punct, Inst>> = LazyLock::new(|| {
     table
 });
 
-impl const Tokens for Inst {
+impl Tokens for Inst {
     type Token = Punct;
 
     #[inline]
@@ -95,13 +95,13 @@ impl const Tokens for Inst {
     }
 }
 
-impl const From<bf::Inst> for Inst {
+impl From<bf::Inst> for Inst {
     fn from(inst: bf::Inst) -> Self {
         Inst::Bf(inst)
     }
 }
 
-impl const VariantIndex for Punct {
+impl VariantIndex for Punct {
     const COUNT: u32 = 3;
     #[inline]
     fn variant(index: u32) -> Self {
@@ -113,7 +113,7 @@ impl const VariantIndex for Punct {
     }
 }
 
-impl const VariantIndex for Inst {
+impl VariantIndex for Inst {
     const COUNT: u32 = 9;
     #[inline]
     fn variant(index: u32) -> Self {
diff --git a/src/bf/spoon.rs b/src/bf/spoon.rs
@@ -91,7 +91,7 @@ impl Inst {
     }
 }
 
-impl const Tokens for Inst {
+impl Tokens for Inst {
     type Token = Token;
 
     #[inline]
@@ -112,13 +112,13 @@ impl const Tokens for Inst {
     }
 }
 
-impl const From<bf::Inst> for Inst {
+impl From<bf::Inst> for Inst {
     fn from(inst: bf::Inst) -> Self {
         Inst::Bf(inst)
     }
 }
 
-impl const VariantIndex for Token {
+impl VariantIndex for Token {
     const COUNT: u32 = 2;
     #[inline]
     fn variant(index: u32) -> Self {
@@ -130,7 +130,7 @@ impl const VariantIndex for Token {
     }
 }
 
-impl const VariantIndex for Inst {
+impl VariantIndex for Inst {
     const COUNT: u32 = 10;
     #[inline]
     fn variant(index: u32) -> Self {
diff --git a/src/lib.rs b/src/lib.rs
@@ -8,29 +8,21 @@
 
 #![feature(
     box_patterns,
-    box_syntax,
     concat_bytes,
     const_array_into_iter_constructors,
-    const_clone,
-    const_convert,
-    const_default_impls,
     const_for,
     const_intoiterator_identity,
     const_mut_refs,
     const_option,
-    const_option_cloned,
     const_option_ext,
     const_trait_impl,
     core_intrinsics,
     if_let_guard,
     inline_const,
-    int_log,
-    label_break_value,
+    lazy_cell,
     let_chains,
-    let_else,
     map_try_insert,
     never_type,
-    once_cell,
     split_array,
     trait_alias
 )]
diff --git a/src/main.rs b/src/main.rs
@@ -6,8 +6,6 @@
 // later version. You should have received a copy of the GNU Lesser General
 // Public License along with Nebula 2. If not, see http://www.gnu.org/licenses/.
 
-#![feature(box_syntax)]
-
 use std::ffi::OsStr;
 use std::fs;
 use std::path::PathBuf;
@@ -70,12 +68,14 @@ fn parse(program: ProgramOptions) -> Parser<'static, Box<dyn Lexer>> {
     let src = fs::read(&program.filename).unwrap();
     let ext = program.filename.extension().and_then(OsStr::to_str);
     let lex: Box<dyn Lexer> = if ext == Some("wsx") {
-        box bit_unpack_dynamic(&src, program.bit_order)
-            .into_iter()
-            .map(Ok)
+        Box::new(
+            bit_unpack_dynamic(&src, program.bit_order)
+                .into_iter()
+                .map(Ok),
+        )
     } else {
         // TODO: Avoid leaking
-        let src: &'static Vec<u8> = Box::leak(box src);
+        let src: &'static Vec<u8> = Box::leak(Box::new(src));
         if program.mapping_s != None || program.mapping_t != None || program.mapping_l != None {
             lex_mapping(
                 src,
@@ -87,9 +87,9 @@ fn parse(program: ProgramOptions) -> Parser<'static, Box<dyn Lexer>> {
             )
             .expect("invalid mapping")
         } else if program.ascii {
-            box MappingLexer::new_bytes(src, Mapping::default())
+            Box::new(MappingLexer::new_bytes(src, Mapping::default()))
         } else {
-            box MappingLexer::new_utf8(src, Mapping::default(), true)
+            Box::new(MappingLexer::new_utf8(src, Mapping::default(), true))
         }
     };
     Parser::new(lex)
diff --git a/src/syntax/token_seq.rs b/src/syntax/token_seq.rs
@@ -48,7 +48,10 @@ pub struct TokenSeq<T> {
 }
 
 impl<T: VariantIndex> TokenSeq<T> {
-    pub const MAX: TokenSeq<T> = TokenSeq::from(u32::MAX);
+    pub const MAX: TokenSeq<T> = TokenSeq {
+        inner: u32::MAX,
+        elem: PhantomData,
+    };
 
     #[inline]
     #[must_use]
@@ -109,14 +112,14 @@ impl<T: VariantIndex> TokenSeq<T> {
     }
 }
 
-impl<T> const From<u32> for TokenSeq<T> {
+impl<T> From<u32> for TokenSeq<T> {
     #[inline]
     fn from(seq: u32) -> Self {
         TokenSeq { inner: seq, elem: PhantomData }
     }
 }
 
-impl<T> const From<usize> for TokenSeq<T> {
+impl<T> From<usize> for TokenSeq<T> {
     #[inline]
     fn from(seq: usize) -> Self {
         debug_assert!(seq < u32::MAX as usize);
@@ -165,26 +168,26 @@ impl<T: Debug + VariantIndex> Debug for TokenSeq<T> {
 }
 
 // Avoid extra bounds for T from derive
-impl<T> const Clone for TokenSeq<T> {
+impl<T> Clone for TokenSeq<T> {
     fn clone(&self) -> Self {
         TokenSeq {
             inner: self.inner,
             elem: PhantomData,
         }
     }
 }
-impl<T> const Copy for TokenSeq<T> {}
-impl<T: VariantIndex> const Default for TokenSeq<T> {
+impl<T> Copy for TokenSeq<T> {}
+impl<T: VariantIndex> Default for TokenSeq<T> {
     fn default() -> Self {
         TokenSeq::new()
     }
 }
-impl<T> const PartialEq for TokenSeq<T> {
+impl<T> PartialEq for TokenSeq<T> {
     fn eq(&self, other: &Self) -> bool {
         self.inner == other.inner
     }
 }
-impl<T> const Eq for TokenSeq<T> {}
+impl<T> Eq for TokenSeq<T> {}
 impl<T> PartialOrd for TokenSeq<T> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.inner.partial_cmp(&other.inner)
diff --git a/src/syntax/variant.rs b/src/syntax/variant.rs
@@ -39,7 +39,7 @@ pub trait VariantIndex {
     }
 }
 
-impl const VariantIndex for ! {
+impl VariantIndex for ! {
     const COUNT: u32 = 0;
     #[inline]
     fn variant(_index: u32) -> Self {
@@ -122,9 +122,9 @@ impl<T: VariantIndex> ExactSizeIterator for VariantRange<T> {
     }
 }
 
-impl<T: VariantIndex> const FusedIterator for VariantRange<T> {}
+impl<T: VariantIndex> FusedIterator for VariantRange<T> {}
 
-impl<T: VariantIndex> const Default for VariantRange<T> {
+impl<T: VariantIndex> Default for VariantRange<T> {
     #[inline]
     fn default() -> Self {
         VariantRange {
@@ -183,7 +183,7 @@ mod tests {
         enum E {
             V,
         }
-        impl const VariantIndex for E {
+        impl VariantIndex for E {
             const COUNT: u32 = 1;
             fn variant(_index: u32) -> Self {
                 E::V
diff --git a/src/text/iter.rs b/src/text/iter.rs
@@ -27,9 +27,9 @@ pub struct Utf8Iterator<'a> {
 impl<'a> Utf8Iterator<'a> {
     #[inline]
     #[must_use]
-    pub const fn new<B>(src: &'a B, error_once: bool) -> Self
+    pub fn new<B>(src: &'a B, error_once: bool) -> Self
     where
-        B: ~const AsRef<[u8]> + ?Sized,
+        B: AsRef<[u8]> + ?Sized,
     {
         Utf8Iterator {
             src: src.as_ref(),
@@ -81,7 +81,7 @@ impl Iterator for Utf8Iterator<'_> {
     }
 }
 
-impl const FusedIterator for Utf8Iterator<'_> {}
+impl FusedIterator for Utf8Iterator<'_> {}
 
 #[derive(Clone, Debug)]
 pub struct ByteIterator<'a> {
@@ -92,7 +92,7 @@ pub struct ByteIterator<'a> {
 impl<'a> ByteIterator<'a> {
     #[inline]
     #[must_use]
-    pub const fn new<B: ~const AsRef<[u8]> + ?Sized>(src: &'a B) -> Self {
+    pub fn new<B: AsRef<[u8]> + ?Sized>(src: &'a B) -> Self {
         ByteIterator { src: src.as_ref(), offset: 0 }
     }
 
@@ -116,7 +116,7 @@ impl Iterator for ByteIterator<'_> {
     }
 }
 
-impl const FusedIterator for ByteIterator<'_> {}
+impl FusedIterator for ByteIterator<'_> {}
 
 #[cfg(test)]
 mod tests {
diff --git a/src/ws/gmh.rs b/src/ws/gmh.rs
@@ -122,7 +122,7 @@ impl Mapping {
     }
 }
 
-impl const Default for Mapping {
+impl Default for Mapping {
     #[inline]
     fn default() -> Self {
         Mapping {
diff --git a/src/ws/inst.rs b/src/ws/inst.rs
@@ -105,7 +105,7 @@ macro_rules! insts {
             }
         }
 
-        impl const Tokens for Opcode {
+        impl Tokens for Opcode {
             type Token = Token;
 
             #[inline]
@@ -116,7 +116,7 @@ macro_rules! insts {
             }
         }
 
-        impl const From<Opcode> for Inst<(), ()> {
+        impl From<Opcode> for Inst<(), ()> {
             #[inline]
             fn from(opcode: Opcode) -> Self {
                 match opcode {
@@ -125,7 +125,7 @@ macro_rules! insts {
             }
         }
 
-        impl const VariantIndex for Opcode {
+        impl VariantIndex for Opcode {
             const COUNT: u32 = count!($($opcode)+);
             #[inline]
             fn variant(index: u32) -> Self {
@@ -201,14 +201,14 @@ impl<I1, L1> Inst<I1, L1> {
     }
 }
 
-impl<I, L, E: Into<InstError>> const From<E> for Inst<I, L> {
+impl<I, L, E: Into<InstError>> From<E> for Inst<I, L> {
     #[inline]
     fn from(err: E) -> Self {
         Inst::Error(err.into())
     }
 }
 
-impl const From<ParseError> for InstError {
+impl From<ParseError> for InstError {
     #[inline]
     fn from(err: ParseError) -> Self {
         InstError::ParseError(err)
diff --git a/src/ws/parse.rs b/src/ws/parse.rs
@@ -114,7 +114,7 @@ impl<L: Lexer> Iterator for Parser<'_, L> {
     }
 }
 
-impl<L: Lexer + FusedIterator> const FusedIterator for Parser<'_, L> {}
+impl<L: Lexer + FusedIterator> FusedIterator for Parser<'_, L> {}
 
 impl From<PrefixError<Token, Opcode>> for ParseError {
     fn from(err: PrefixError<Token, Opcode>) -> Self {
diff --git a/src/ws/syntax/label.rs b/src/ws/syntax/label.rs
@@ -33,14 +33,14 @@ macro_rules! id_index(
         #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
         pub struct $Id(pub $Int);
 
-        impl const From<usize> for $Id {
+        impl  From<usize> for $Id {
             #[inline]
             fn from(id: usize) -> Self {
                 $Id(id as u32)
             }
         }
 
-        impl const From<$Id> for usize {
+        impl  From<$Id> for usize {
             #[inline]
             fn from(id: $Id) -> Self {
                 id.0 as usize
diff --git a/src/ws/tests.rs b/src/ws/tests.rs
@@ -109,11 +109,17 @@ fn parse() {
 #[test]
 fn parse_dyn() {
     let lexers: [Box<dyn Lexer>; 3] = [
-        box MappingLexer::new_utf8(TUTORIAL_STL, Mapping::<char>::STL, true),
-        box MappingLexer::new_bytes(TUTORIAL_STL, Mapping::<u8>::STL),
-        box bit_unpack_padded::<u8, Msb0>(TUTORIAL_BITS)
-            .into_iter()
-            .map(Ok),
+        Box::new(MappingLexer::new_utf8(
+            TUTORIAL_STL,
+            Mapping::<char>::STL,
+            true,
+        )),
+        Box::new(MappingLexer::new_bytes(TUTORIAL_STL, Mapping::<u8>::STL)),
+        Box::new(
+            bit_unpack_padded::<u8, Msb0>(TUTORIAL_BITS)
+                .into_iter()
+                .map(Ok),
+        ),
     ];
     for lex in lexers {
         let parser = Parser::new(lex);
diff --git a/src/ws/token/mapping.rs b/src/ws/token/mapping.rs
diff --git a/src/ws/token/mod.rs b/src/ws/token/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ pub enum InstExt {`
`51`	`51`	`Debug,`
`52`	`52`	`}`
`53`	`53`
`54`		`-impl const VariantIndex for Inst {`
	`54`	`+impl VariantIndex for Inst {`
`55`	`55`	`const COUNT: u32 = 8;`
`56`	`56`	`#[inline]`
`57`	`57`	`fn variant(index: u32) -> Self {`
`@@ -63,7 +63,7 @@ impl const VariantIndex for Inst {`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`		`-impl const VariantIndex for InstExt {`
	`66`	`+impl VariantIndex for InstExt {`
`67`	`67`	`const COUNT: u32 = 9;`
`68`	`68`	`#[inline]`
`69`	`69`	`fn variant(index: u32) -> Self {`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ pub static TABLE: LazyLock<PrefixTable<Punct, Inst>> = LazyLock::new(\|\| {`
`75`	`75`	`table`
`76`	`76`	`});`
`77`	`77`
`78`		`-impl const Tokens for Inst {`
	`78`	`+impl Tokens for Inst {`
`79`	`79`	`type Token = Punct;`
`80`	`80`
`81`	`81`	`#[inline]`
`@@ -95,13 +95,13 @@ impl const Tokens for Inst {`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`		`-impl const From<bf::Inst> for Inst {`
	`98`	`+impl From<bf::Inst> for Inst {`
`99`	`99`	`fn from(inst: bf::Inst) -> Self {`
`100`	`100`	`Inst::Bf(inst)`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`		`-impl const VariantIndex for Punct {`
	`104`	`+impl VariantIndex for Punct {`
`105`	`105`	`const COUNT: u32 = 3;`
`106`	`106`	`#[inline]`
`107`	`107`	`fn variant(index: u32) -> Self {`
`@@ -113,7 +113,7 @@ impl const VariantIndex for Punct {`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`
`116`		`-impl const VariantIndex for Inst {`
	`116`	`+impl VariantIndex for Inst {`
`117`	`117`	`const COUNT: u32 = 9;`
`118`	`118`	`#[inline]`
`119`	`119`	`fn variant(index: u32) -> Self {`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ impl Inst {`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`-impl const Tokens for Inst {`
	`94`	`+impl Tokens for Inst {`
`95`	`95`	`type Token = Token;`
`96`	`96`
`97`	`97`	`#[inline]`
`@@ -112,13 +112,13 @@ impl const Tokens for Inst {`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`
`115`		`-impl const From<bf::Inst> for Inst {`
	`115`	`+impl From<bf::Inst> for Inst {`
`116`	`116`	`fn from(inst: bf::Inst) -> Self {`
`117`	`117`	`Inst::Bf(inst)`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`121`		`-impl const VariantIndex for Token {`
	`121`	`+impl VariantIndex for Token {`
`122`	`122`	`const COUNT: u32 = 2;`
`123`	`123`	`#[inline]`
`124`	`124`	`fn variant(index: u32) -> Self {`
`@@ -130,7 +130,7 @@ impl const VariantIndex for Token {`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`		`-impl const VariantIndex for Inst {`
	`133`	`+impl VariantIndex for Inst {`
`134`	`134`	`const COUNT: u32 = 10;`
`135`	`135`	`#[inline]`
`136`	`136`	`fn variant(index: u32) -> Self {`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,10 @@ pub struct TokenSeq<T> {`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`impl<T: VariantIndex> TokenSeq<T> {`
`51`		`- pub const MAX: TokenSeq<T> = TokenSeq::from(u32::MAX);`
	`51`	`+ pub const MAX: TokenSeq<T> = TokenSeq {`
	`52`	`+ inner: u32::MAX,`
	`53`	`+ elem: PhantomData,`
	`54`	`+ };`
`52`	`55`
`53`	`56`	`#[inline]`
`54`	`57`	`#[must_use]`
`@@ -109,14 +112,14 @@ impl<T: VariantIndex> TokenSeq<T> {`
`109`	`112`	`}`
`110`	`113`	`}`
`111`	`114`
`112`		`-impl<T> const From<u32> for TokenSeq<T> {`
	`115`	`+impl<T> From<u32> for TokenSeq<T> {`
`113`	`116`	`#[inline]`
`114`	`117`	`fn from(seq: u32) -> Self {`
`115`	`118`	`TokenSeq { inner: seq, elem: PhantomData }`
`116`	`119`	`}`
`117`	`120`	`}`
`118`	`121`
`119`		`-impl<T> const From<usize> for TokenSeq<T> {`
	`122`	`+impl<T> From<usize> for TokenSeq<T> {`
`120`	`123`	`#[inline]`
`121`	`124`	`fn from(seq: usize) -> Self {`
`122`	`125`	`debug_assert!(seq < u32::MAX as usize);`
`@@ -165,26 +168,26 @@ impl<T: Debug + VariantIndex> Debug for TokenSeq<T> {`
`165`	`168`	`}`
`166`	`169`
`167`	`170`	`// Avoid extra bounds for T from derive`
`168`		`-impl<T> const Clone for TokenSeq<T> {`
	`171`	`+impl<T> Clone for TokenSeq<T> {`
`169`	`172`	`fn clone(&self) -> Self {`
`170`	`173`	`TokenSeq {`
`171`	`174`	`inner: self.inner,`
`172`	`175`	`elem: PhantomData,`
`173`	`176`	`}`
`174`	`177`	`}`
`175`	`178`	`}`
`176`		`-impl<T> const Copy for TokenSeq<T> {}`
`177`		`-impl<T: VariantIndex> const Default for TokenSeq<T> {`
	`179`	`+impl<T> Copy for TokenSeq<T> {}`
	`180`	`+impl<T: VariantIndex> Default for TokenSeq<T> {`
`178`	`181`	`fn default() -> Self {`
`179`	`182`	`TokenSeq::new()`
`180`	`183`	`}`
`181`	`184`	`}`
`182`		`-impl<T> const PartialEq for TokenSeq<T> {`
	`185`	`+impl<T> PartialEq for TokenSeq<T> {`
`183`	`186`	`fn eq(&self, other: &Self) -> bool {`
`184`	`187`	`self.inner == other.inner`
`185`	`188`	`}`
`186`	`189`	`}`
`187`		`-impl<T> const Eq for TokenSeq<T> {}`
	`190`	`+impl<T> Eq for TokenSeq<T> {}`
`188`	`191`	`impl<T> PartialOrd for TokenSeq<T> {`
`189`	`192`	`fn partial_cmp(&self, other: &Self) -> Option<Ordering> {`
`190`	`193`	`self.inner.partial_cmp(&other.inner)`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ pub trait VariantIndex {`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`-impl const VariantIndex for ! {`
	`42`	`+impl VariantIndex for ! {`
`43`	`43`	`const COUNT: u32 = 0;`
`44`	`44`	`#[inline]`
`45`	`45`	`fn variant(_index: u32) -> Self {`
`@@ -122,9 +122,9 @@ impl<T: VariantIndex> ExactSizeIterator for VariantRange<T> {`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`		`-impl<T: VariantIndex> const FusedIterator for VariantRange<T> {}`
	`125`	`+impl<T: VariantIndex> FusedIterator for VariantRange<T> {}`
`126`	`126`
`127`		`-impl<T: VariantIndex> const Default for VariantRange<T> {`
	`127`	`+impl<T: VariantIndex> Default for VariantRange<T> {`
`128`	`128`	`#[inline]`
`129`	`129`	`fn default() -> Self {`
`130`	`130`	`VariantRange {`
`@@ -183,7 +183,7 @@ mod tests {`
`183`	`183`	`enum E {`
`184`	`184`	`V,`
`185`	`185`	`}`
`186`		`- impl const VariantIndex for E {`
	`186`	`+ impl VariantIndex for E {`
`187`	`187`	`const COUNT: u32 = 1;`
`188`	`188`	`fn variant(_index: u32) -> Self {`
`189`	`189`	`E::V`
Original file line number	Diff line number	Diff line change
`@@ -27,9 +27,9 @@ pub struct Utf8Iterator<'a> {`
`27`	`27`	`impl<'a> Utf8Iterator<'a> {`
`28`	`28`	`#[inline]`
`29`	`29`	`#[must_use]`
`30`		`- pub const fn new<B>(src: &'a B, error_once: bool) -> Self`
	`30`	`+ pub fn new<B>(src: &'a B, error_once: bool) -> Self`
`31`	`31`	`where`
`32`		`- B: ~const AsRef<[u8]> + ?Sized,`
	`32`	`+ B: AsRef<[u8]> + ?Sized,`
`33`	`33`	`{`
`34`	`34`	`Utf8Iterator {`
`35`	`35`	`src: src.as_ref(),`
`@@ -81,7 +81,7 @@ impl Iterator for Utf8Iterator<'_> {`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`-impl const FusedIterator for Utf8Iterator<'_> {}`
	`84`	`+impl FusedIterator for Utf8Iterator<'_> {}`
`85`	`85`
`86`	`86`	`#[derive(Clone, Debug)]`
`87`	`87`	`pub struct ByteIterator<'a> {`
`@@ -92,7 +92,7 @@ pub struct ByteIterator<'a> {`
`92`	`92`	`impl<'a> ByteIterator<'a> {`
`93`	`93`	`#[inline]`
`94`	`94`	`#[must_use]`
`95`		`- pub const fn new<B: ~const AsRef<[u8]> + ?Sized>(src: &'a B) -> Self {`
	`95`	`+ pub fn new<B: AsRef<[u8]> + ?Sized>(src: &'a B) -> Self {`
`96`	`96`	`ByteIterator { src: src.as_ref(), offset: 0 }`
`97`	`97`	`}`
`98`	`98`
`@@ -116,7 +116,7 @@ impl Iterator for ByteIterator<'_> {`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
`119`		`-impl const FusedIterator for ByteIterator<'_> {}`
	`119`	`+impl FusedIterator for ByteIterator<'_> {}`
`120`	`120`
`121`	`121`	`#[cfg(test)]`
`122`	`122`	`mod tests {`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ impl Mapping {`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`		`-impl const Default for Mapping {`
	`125`	`+impl Default for Mapping {`
`126`	`126`	`#[inline]`
`127`	`127`	`fn default() -> Self {`
`128`	`128`	`Mapping {`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ macro_rules! insts {`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`108`		`- impl const Tokens for Opcode {`
	`108`	`+ impl Tokens for Opcode {`
`109`	`109`	`type Token = Token;`
`110`	`110`
`111`	`111`	`#[inline]`
`@@ -116,7 +116,7 @@ macro_rules! insts {`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
`119`		`- impl const From<Opcode> for Inst<(), ()> {`
	`119`	`+ impl From<Opcode> for Inst<(), ()> {`
`120`	`120`	`#[inline]`
`121`	`121`	`fn from(opcode: Opcode) -> Self {`
`122`	`122`	`match opcode {`
`@@ -125,7 +125,7 @@ macro_rules! insts {`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`		`- impl const VariantIndex for Opcode {`
	`128`	`+ impl VariantIndex for Opcode {`
`129`	`129`	`const COUNT: u32 = count!($($opcode)+);`
`130`	`130`	`#[inline]`
`131`	`131`	`fn variant(index: u32) -> Self {`
`@@ -201,14 +201,14 @@ impl<I1, L1> Inst<I1, L1> {`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`
`204`		`-impl<I, L, E: Into<InstError>> const From<E> for Inst<I, L> {`
	`204`	`+impl<I, L, E: Into<InstError>> From<E> for Inst<I, L> {`
`205`	`205`	`#[inline]`
`206`	`206`	`fn from(err: E) -> Self {`
`207`	`207`	`Inst::Error(err.into())`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`211`		`-impl const From<ParseError> for InstError {`
	`211`	`+impl From<ParseError> for InstError {`
`212`	`212`	`#[inline]`
`213`	`213`	`fn from(err: ParseError) -> Self {`
`214`	`214`	`InstError::ParseError(err)`