[assembler] Clippy: enable, fix enum_glob_use.

youngman-g · youngman-g · commit 08b89236b7f8 · 2025-10-08T22:30:01.000+01:00
diff --git a/assembler/src/asmlib/ast.rs b/assembler/src/asmlib/ast.rs
@@ -1213,14 +1213,15 @@ impl InstructionFragment {
         implicit_symtab: &mut ImplicitSymbolTable,
         rc_allocator: &mut R,
     ) -> Result<(), RcWordAllocationFailure> {
-        use InstructionFragment::*;
         match self {
-            Null(_) | DeferredAddressing(_) => Ok(()),
-            Arithmetic(expr) => {
+            InstructionFragment::Null(_) | InstructionFragment::DeferredAddressing(_) => Ok(()),
+            InstructionFragment::Arithmetic(expr) => {
                 expr.allocate_rc_words(explicit_symtab, implicit_symtab, rc_allocator)
             }
-            Config(cfg) => cfg.allocate_rc_words(explicit_symtab, implicit_symtab, rc_allocator),
-            PipeConstruct {
+            InstructionFragment::Config(cfg) => {
+                cfg.allocate_rc_words(explicit_symtab, implicit_symtab, rc_allocator)
+            }
+            InstructionFragment::PipeConstruct {
                 index: _,
                 rc_word_span,
                 rc_word_value,
diff --git a/assembler/src/asmlib/eval.rs b/assembler/src/asmlib/eval.rs
@@ -79,9 +79,8 @@ impl Spanned for EvaluationFailure {
 
 impl Display for EvaluationFailure {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
-        use EvaluationFailure::*;
         match self {
-            SymbolDefinitionLoop {
+            EvaluationFailure::SymbolDefinitionLoop {
                 deps_in_order,
                 span: _,
             } => {
@@ -93,16 +92,19 @@ impl Display for EvaluationFailure {
                     names.join("->")
                 )
             }
-            FailedToAssignIndexRegister(ExhaustedIndexRegisters { name, .. }) => {
+            EvaluationFailure::FailedToAssignIndexRegister(ExhaustedIndexRegisters {
+                name,
+                ..
+            }) => {
                 write!(
                     f,
                     "unable to assign index register as the default value for symbol {name} because there are not enough index registers"
                 )
             }
-            BlockTooLarge(_span, mle) => {
+            EvaluationFailure::BlockTooLarge(_span, mle) => {
                 write!(f, "program block too large: {mle}")
             }
-            HereIsNotAllowedHere(_) => {
+            EvaluationFailure::HereIsNotAllowedHere(_) => {
                 f.write_str("'#' (representing the current address) is not allowed here")
             }
         }
@@ -164,8 +166,6 @@ fn assign_default_value(
     name: &SymbolName,
     contexts_used: &SymbolContext,
 ) -> Result<Unsigned36Bit, ExhaustedIndexRegisters> {
-    use ConfigUse::*;
-    use IndexUse::*;
     event!(
         Level::DEBUG,
         "assigning default value for {name} used in contexts {contexts_used:?}"
@@ -178,7 +178,7 @@ fn assign_default_value(
             )
         }
         OriginUse::NotOrigin { config, index } => match (config, index) {
-            (NotConfig, NotIndex) => {
+            (ConfigUse::NotConfig, IndexUse::NotIndex) => {
                 if contexts_used.is_address() {
                     // Values which refer to addresses (and which
                     // therefore should point to a zero-initialised
@@ -193,8 +193,8 @@ fn assign_default_value(
                     )
                 }
             }
-            (IncludesConfig, _) => Ok(Unsigned36Bit::ZERO),
-            (NotConfig, IncludesIndex) => {
+            (ConfigUse::IncludesConfig, _) => Ok(Unsigned36Bit::ZERO),
+            (ConfigUse::NotConfig, IndexUse::IncludesIndex) => {
                 // Index but not also configuration. Assign the next
                 // index register.
                 match index_register_assigner.assign_index_register() {
diff --git a/assembler/src/asmlib/lexer/lower.rs b/assembler/src/asmlib/lexer/lower.rs
@@ -104,12 +104,11 @@ impl<'a> LowerLexer<'a> {
 
     pub(super) fn next(&mut self) -> Lexeme<'a> {
         use super::Token;
-        use Lexeme::*;
 
         loop {
             let tok = match self.inner.next() {
                 None => {
-                    return EndOfInput;
+                    return Lexeme::EndOfInput;
                 }
                 Some(Result::Err(())) => {
                     if self.state.in_comment {
@@ -136,7 +135,7 @@ impl<'a> LowerLexer<'a> {
                     // symbols across a space.  Per section 6-2.3 of
                     // the User Handbook, tab is not allowed inside a
                     // symex.
-                    return Tok(Token::Tab);
+                    return Lexeme::Tok(Token::Tab);
                 }
                 InnerToken::CommentStart => {
                     self.state.in_comment = true;
@@ -150,7 +149,7 @@ impl<'a> LowerLexer<'a> {
                     self.state.lbrace_count = self.state.lbrace_count.checked_add(1).expect(
                         "the number of '{' on one line should be countable without overflow",
                     );
-                    return Tok(Token::LeftBrace(Script::Normal));
+                    return Lexeme::Tok(Token::LeftBrace(Script::Normal));
                 }
                 InnerToken::RightBrace => {
                     match self.state.lbrace_count.checked_sub(1) {
@@ -163,26 +162,26 @@ impl<'a> LowerLexer<'a> {
                                 // the comment text.
                                 continue;
                             }
-                            return Tok(Token::RightBrace(Script::Normal));
+                            return Lexeme::Tok(Token::RightBrace(Script::Normal));
                         }
                         Some(reduced_count) => {
                             self.state.lbrace_count = reduced_count;
                             self.state.in_comment = false;
-                            return Tok(Token::RightBrace(Script::Normal));
+                            return Lexeme::Tok(Token::RightBrace(Script::Normal));
                         }
                     }
                 }
                 InnerToken::Newline => {
                     self.state.lbrace_count = 0;
                     self.state.in_comment = false;
                     self.state.check_set_up_for_start_of_line();
-                    return Tok(Token::Newline);
+                    return Lexeme::Tok(Token::Newline);
                 }
                 InnerToken::Text => {
                     if self.state.in_comment {
                         continue;
                     }
-                    return Text(self.inner.slice());
+                    return Lexeme::Text(self.inner.slice());
                 }
             }
         }
diff --git a/assembler/src/asmlib/lib.rs b/assembler/src/asmlib/lib.rs
@@ -15,7 +15,6 @@
 #![warn(clippy::redundant_closure_for_method_calls)]
 #![warn(clippy::pedantic)]
 #![allow(clippy::verbose_bit_mask)] // because many of our types don't have trailing_zeros().
-#![allow(clippy::enum_glob_use)] // fix later
 #![allow(clippy::too_many_lines)] // fix later
 #![allow(clippy::explicit_into_iter_loop)] // fix later
 #![allow(clippy::default_trait_access)] // fix later
diff --git a/assembler/src/asmlib/parser.rs b/assembler/src/asmlib/parser.rs
@@ -791,7 +791,6 @@ pub(crate) fn instructions_with_comma_counts<I>(it: I) -> Vec<CommaDelimitedFrag
 where
     I: Iterator<Item = CommasOrInstruction>,
 {
-    use CommasOrInstruction::*;
     /// Fold operation which estabishes an alternating pattern of
     /// commas and instructions.
     ///
@@ -834,11 +833,11 @@ where
                     acc.push(CommasOrInstruction::C(None));
                 }
             },
-            Some(I(_)) => unreachable!("invariant was broken"),
+            Some(CommasOrInstruction::I(_)) => unreachable!("invariant was broken"),
             None => unreachable!("invariant was not established"),
         }
-        assert!(matches!(acc.first(), Some(C(_))));
-        assert!(matches!(acc.last(), Some(C(_))));
+        assert!(matches!(acc.first(), Some(CommasOrInstruction::C(_))));
+        assert!(matches!(acc.last(), Some(CommasOrInstruction::C(_))));
         acc
     }
 
@@ -849,8 +848,8 @@ where
             None => {
                 return Vec::new();
             }
-            Some(I(_)) => None,
-            Some(C(maybe_commas)) => {
+            Some(CommasOrInstruction::I(_)) => None,
+            Some(CommasOrInstruction::C(maybe_commas)) => {
                 let c = maybe_commas.clone();
                 it.next();
                 c
@@ -868,7 +867,7 @@ where
             (None, _) => {
                 break;
             }
-            (Some(C(before_commas)), Some(I(inst))) => {
+            (Some(CommasOrInstruction::C(before_commas)), Some(CommasOrInstruction::I(inst))) => {
                 let after_commas: Option<Commas> = match it.peek() {
                     Some(CommasOrInstruction::C(commas)) => commas.clone(),
                     None => None,
@@ -882,11 +881,12 @@ where
                     after_commas,
                 ));
             }
-            (Some(C(_)), None) => {
+            (Some(CommasOrInstruction::C(_)), None) => {
                 // No instructions in the input.
                 break;
             }
-            (Some(I(_)), _) | (Some(C(_)), Some(C(_))) => {
+            (Some(CommasOrInstruction::I(_)), _)
+            | (Some(CommasOrInstruction::C(_)), Some(CommasOrInstruction::C(_))) => {
                 unreachable!("fold_step did not maintain its invariant");
             }
         }
diff --git a/assembler/src/asmlib/symtab.rs b/assembler/src/asmlib/symtab.rs
@@ -360,10 +360,9 @@ impl ImplicitDefinition {
 
 impl Display for ImplicitDefinition {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        use ImplicitDefinition::*;
         match self {
-            Undefined(_context) => f.write_str("undefined"),
-            DefaultAssigned(value, _) => {
+            ImplicitDefinition::Undefined(_context) => f.write_str("undefined"),
+            ImplicitDefinition::DefaultAssigned(value, _) => {
                 write!(f, "default-assigned as {value}")
             }
         }
@@ -470,9 +469,8 @@ pub(super) fn record_undefined_symbol_or_return_failure(
     e: EvaluationFailure,
     undefined_symbols: &mut BTreeMap<SymbolName, ProgramError>,
 ) -> Result<(), AssemblerFailure> {
-    use EvaluationFailure::*;
     match e {
-        SymbolDefinitionLoop {
+        EvaluationFailure::SymbolDefinitionLoop {
             span,
             deps_in_order,
             ..
diff --git a/assembler/src/asmlib/types.rs b/assembler/src/asmlib/types.rs
@@ -147,38 +147,36 @@ pub enum ProgramError {
 
 impl Spanned for ProgramError {
     fn span(&self) -> Span {
-        use ProgramError::*;
         match self {
-            RcBlockTooLong(RcWordSource { span, .. })
-            | FailedToAssignIndexRegister(span, _)
-            | BlockTooLong(span, _)
-            | InconsistentTag { span, .. }
-            | SymbolDefinitionLoop { span, .. }
-            | SyntaxError { span, .. } => *span,
+            ProgramError::RcBlockTooLong(RcWordSource { span, .. })
+            | ProgramError::FailedToAssignIndexRegister(span, _)
+            | ProgramError::BlockTooLong(span, _)
+            | ProgramError::InconsistentTag { span, .. }
+            | ProgramError::SymbolDefinitionLoop { span, .. }
+            | ProgramError::SyntaxError { span, .. } => *span,
         }
     }
 }
 
 impl Display for ProgramError {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
-        use ProgramError::*;
         match self {
-            RcBlockTooLong(RcWordSource { kind, .. }) => {
+            ProgramError::RcBlockTooLong(RcWordSource { kind, .. }) => {
                 write!(f, "RC-word block grew too long to allocate {kind}")
             }
-            FailedToAssignIndexRegister(_span, symbol_name) => {
+            ProgramError::FailedToAssignIndexRegister(_span, symbol_name) => {
                 write!(
                     f,
                     "there are not enough index registers available to assign one for {symbol_name}"
                 )
             }
-            BlockTooLong(_span, mle) => {
+            ProgramError::BlockTooLong(_span, mle) => {
                 write!(f, "program block contains too many machine words: {mle}")
             }
-            InconsistentTag { name, span: _, msg } => {
+            ProgramError::InconsistentTag { name, span: _, msg } => {
                 write!(f, "inconsistent definitions for tag {name}: {msg}")
             }
-            SymbolDefinitionLoop {
+            ProgramError::SymbolDefinitionLoop {
                 symbol_names,
                 span: _,
             } => {
@@ -195,7 +193,7 @@ impl Display for ProgramError {
                 }
                 Ok(())
             }
-            SyntaxError { span: _, msg } => {
+            ProgramError::SyntaxError { span: _, msg } => {
                 write!(f, "{msg}")
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -79,9 +79,8 @@ impl Spanned for EvaluationFailure {`
`79`	`79`
`80`	`80`	`impl Display for EvaluationFailure {`
`81`	`81`	`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {`
`82`		`- use EvaluationFailure::*;`
`83`	`82`	`match self {`
`84`		`- SymbolDefinitionLoop {`
	`83`	`+ EvaluationFailure::SymbolDefinitionLoop {`
`85`	`84`	`deps_in_order,`
`86`	`85`	`span: _,`
`87`	`86`	`} => {`
`@@ -93,16 +92,19 @@ impl Display for EvaluationFailure {`
`93`	`92`	`names.join("->")`
`94`	`93`	`)`
`95`	`94`	`}`
`96`		`- FailedToAssignIndexRegister(ExhaustedIndexRegisters { name, .. }) => {`
	`95`	`+ EvaluationFailure::FailedToAssignIndexRegister(ExhaustedIndexRegisters {`
	`96`	`+ name,`
	`97`	`+ ..`
	`98`	`+ }) => {`
`97`	`99`	`write!(`
`98`	`100`	`f,`
`99`	`101`	`"unable to assign index register as the default value for symbol {name} because there are not enough index registers"`
`100`	`102`	`)`
`101`	`103`	`}`
`102`		`- BlockTooLarge(_span, mle) => {`
	`104`	`+ EvaluationFailure::BlockTooLarge(_span, mle) => {`
`103`	`105`	`write!(f, "program block too large: {mle}")`
`104`	`106`	`}`
`105`		`- HereIsNotAllowedHere(_) => {`
	`107`	`+ EvaluationFailure::HereIsNotAllowedHere(_) => {`
`106`	`108`	`f.write_str("'#' (representing the current address) is not allowed here")`
`107`	`109`	`}`
`108`	`110`	`}`
`@@ -164,8 +166,6 @@ fn assign_default_value(`
`164`	`166`	`name: &SymbolName,`
`165`	`167`	`contexts_used: &SymbolContext,`
`166`	`168`	`) -> Result<Unsigned36Bit, ExhaustedIndexRegisters> {`
`167`		`- use ConfigUse::*;`
`168`		`- use IndexUse::*;`
`169`	`169`	`event!(`
`170`	`170`	`Level::DEBUG,`
`171`	`171`	`"assigning default value for {name} used in contexts {contexts_used:?}"`
`@@ -178,7 +178,7 @@ fn assign_default_value(`
`178`	`178`	`)`
`179`	`179`	`}`
`180`	`180`	`OriginUse::NotOrigin { config, index } => match (config, index) {`
`181`		`- (NotConfig, NotIndex) => {`
	`181`	`+ (ConfigUse::NotConfig, IndexUse::NotIndex) => {`
`182`	`182`	`if contexts_used.is_address() {`
`183`	`183`	`// Values which refer to addresses (and which`
`184`	`184`	`// therefore should point to a zero-initialised`
`@@ -193,8 +193,8 @@ fn assign_default_value(`
`193`	`193`	`)`
`194`	`194`	`}`
`195`	`195`	`}`
`196`		`- (IncludesConfig, _) => Ok(Unsigned36Bit::ZERO),`
`197`		`- (NotConfig, IncludesIndex) => {`
	`196`	`+ (ConfigUse::IncludesConfig, _) => Ok(Unsigned36Bit::ZERO),`
	`197`	`+ (ConfigUse::NotConfig, IndexUse::IncludesIndex) => {`
`198`	`198`	`// Index but not also configuration. Assign the next`
`199`	`199`	`// index register.`
`200`	`200`	`match index_register_assigner.assign_index_register() {`
Original file line number	Diff line number	Diff line change
`@@ -104,12 +104,11 @@ impl<'a> LowerLexer<'a> {`
`104`	`104`
`105`	`105`	`pub(super) fn next(&mut self) -> Lexeme<'a> {`
`106`	`106`	`use super::Token;`
`107`		`- use Lexeme::*;`
`108`	`107`
`109`	`108`	`loop {`
`110`	`109`	`let tok = match self.inner.next() {`
`111`	`110`	`None => {`
`112`		`- return EndOfInput;`
	`111`	`+ return Lexeme::EndOfInput;`
`113`	`112`	`}`
`114`	`113`	`Some(Result::Err(())) => {`
`115`	`114`	`if self.state.in_comment {`
`@@ -136,7 +135,7 @@ impl<'a> LowerLexer<'a> {`
`136`	`135`	`// symbols across a space. Per section 6-2.3 of`
`137`	`136`	`// the User Handbook, tab is not allowed inside a`
`138`	`137`	`// symex.`
`139`		`- return Tok(Token::Tab);`
	`138`	`+ return Lexeme::Tok(Token::Tab);`
`140`	`139`	`}`
`141`	`140`	`InnerToken::CommentStart => {`
`142`	`141`	`self.state.in_comment = true;`
`@@ -150,7 +149,7 @@ impl<'a> LowerLexer<'a> {`
`150`	`149`	`self.state.lbrace_count = self.state.lbrace_count.checked_add(1).expect(`
`151`	`150`	`"the number of '{' on one line should be countable without overflow",`
`152`	`151`	`);`
`153`		`- return Tok(Token::LeftBrace(Script::Normal));`
	`152`	`+ return Lexeme::Tok(Token::LeftBrace(Script::Normal));`
`154`	`153`	`}`
`155`	`154`	`InnerToken::RightBrace => {`
`156`	`155`	`match self.state.lbrace_count.checked_sub(1) {`
`@@ -163,26 +162,26 @@ impl<'a> LowerLexer<'a> {`
`163`	`162`	`// the comment text.`
`164`	`163`	`continue;`
`165`	`164`	`}`
`166`		`- return Tok(Token::RightBrace(Script::Normal));`
	`165`	`+ return Lexeme::Tok(Token::RightBrace(Script::Normal));`
`167`	`166`	`}`
`168`	`167`	`Some(reduced_count) => {`
`169`	`168`	`self.state.lbrace_count = reduced_count;`
`170`	`169`	`self.state.in_comment = false;`
`171`		`- return Tok(Token::RightBrace(Script::Normal));`
	`170`	`+ return Lexeme::Tok(Token::RightBrace(Script::Normal));`
`172`	`171`	`}`
`173`	`172`	`}`
`174`	`173`	`}`
`175`	`174`	`InnerToken::Newline => {`
`176`	`175`	`self.state.lbrace_count = 0;`
`177`	`176`	`self.state.in_comment = false;`
`178`	`177`	`self.state.check_set_up_for_start_of_line();`
`179`		`- return Tok(Token::Newline);`
	`178`	`+ return Lexeme::Tok(Token::Newline);`
`180`	`179`	`}`
`181`	`180`	`InnerToken::Text => {`
`182`	`181`	`if self.state.in_comment {`
`183`	`182`	`continue;`
`184`	`183`	`}`
`185`		`- return Text(self.inner.slice());`
	`184`	`+ return Lexeme::Text(self.inner.slice());`
`186`	`185`	`}`
`187`	`186`	`}`
`188`	`187`	`}`
Original file line number	Diff line number	Diff line change
`@@ -791,7 +791,6 @@ pub(crate) fn instructions_with_comma_counts<I>(it: I) -> Vec<CommaDelimitedFrag`
`791`	`791`	`where`
`792`	`792`	`I: Iterator<Item = CommasOrInstruction>,`
`793`	`793`	`{`
`794`		`- use CommasOrInstruction::*;`
`795`	`794`	`/// Fold operation which estabishes an alternating pattern of`
`796`	`795`	`/// commas and instructions.`
`797`	`796`	`///`
`@@ -834,11 +833,11 @@ where`
`834`	`833`	`acc.push(CommasOrInstruction::C(None));`
`835`	`834`	`}`
`836`	`835`	`},`
`837`		`- Some(I(_)) => unreachable!("invariant was broken"),`
	`836`	`+ Some(CommasOrInstruction::I(_)) => unreachable!("invariant was broken"),`
`838`	`837`	`None => unreachable!("invariant was not established"),`
`839`	`838`	`}`
`840`		`- assert!(matches!(acc.first(), Some(C(_))));`
`841`		`- assert!(matches!(acc.last(), Some(C(_))));`
	`839`	`+ assert!(matches!(acc.first(), Some(CommasOrInstruction::C(_))));`
	`840`	`+ assert!(matches!(acc.last(), Some(CommasOrInstruction::C(_))));`
`842`	`841`	`acc`
`843`	`842`	`}`
`844`	`843`
`@@ -849,8 +848,8 @@ where`
`849`	`848`	`None => {`
`850`	`849`	`return Vec::new();`
`851`	`850`	`}`
`852`		`- Some(I(_)) => None,`
`853`		`- Some(C(maybe_commas)) => {`
	`851`	`+ Some(CommasOrInstruction::I(_)) => None,`
	`852`	`+ Some(CommasOrInstruction::C(maybe_commas)) => {`
`854`	`853`	`let c = maybe_commas.clone();`
`855`	`854`	`it.next();`
`856`	`855`	`c`
`@@ -868,7 +867,7 @@ where`
`868`	`867`	`(None, _) => {`
`869`	`868`	`break;`
`870`	`869`	`}`
`871`		`- (Some(C(before_commas)), Some(I(inst))) => {`
	`870`	`+ (Some(CommasOrInstruction::C(before_commas)), Some(CommasOrInstruction::I(inst))) => {`
`872`	`871`	`let after_commas: Option<Commas> = match it.peek() {`
`873`	`872`	`Some(CommasOrInstruction::C(commas)) => commas.clone(),`
`874`	`873`	`None => None,`
`@@ -882,11 +881,12 @@ where`
`882`	`881`	`after_commas,`
`883`	`882`	`));`
`884`	`883`	`}`
`885`		`- (Some(C(_)), None) => {`
	`884`	`+ (Some(CommasOrInstruction::C(_)), None) => {`
`886`	`885`	`// No instructions in the input.`
`887`	`886`	`break;`
`888`	`887`	`}`
`889`		`- (Some(I(_)), _) \| (Some(C(_)), Some(C(_))) => {`
	`888`	`+ (Some(CommasOrInstruction::I(_)), _)`
	`889`	`+ \| (Some(CommasOrInstruction::C(_)), Some(CommasOrInstruction::C(_))) => {`
`890`	`890`	`unreachable!("fold_step did not maintain its invariant");`
`891`	`891`	`}`
`892`	`892`	`}`
Original file line number	Diff line number	Diff line change
`@@ -147,38 +147,36 @@ pub enum ProgramError {`
`147`	`147`
`148`	`148`	`impl Spanned for ProgramError {`
`149`	`149`	`fn span(&self) -> Span {`
`150`		`- use ProgramError::*;`
`151`	`150`	`match self {`
`152`		`- RcBlockTooLong(RcWordSource { span, .. })`
`153`		`- \| FailedToAssignIndexRegister(span, _)`
`154`		`- \| BlockTooLong(span, _)`
`155`		`- \| InconsistentTag { span, .. }`
`156`		`- \| SymbolDefinitionLoop { span, .. }`
`157`		`- \| SyntaxError { span, .. } => *span,`
	`151`	`+ ProgramError::RcBlockTooLong(RcWordSource { span, .. })`
	`152`	`+ \| ProgramError::FailedToAssignIndexRegister(span, _)`
	`153`	`+ \| ProgramError::BlockTooLong(span, _)`
	`154`	`+ \| ProgramError::InconsistentTag { span, .. }`
	`155`	`+ \| ProgramError::SymbolDefinitionLoop { span, .. }`
	`156`	`+ \| ProgramError::SyntaxError { span, .. } => *span,`
`158`	`157`	`}`
`159`	`158`	`}`
`160`	`159`	`}`
`161`	`160`
`162`	`161`	`impl Display for ProgramError {`
`163`	`162`	`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {`
`164`		`- use ProgramError::*;`
`165`	`163`	`match self {`
`166`		`- RcBlockTooLong(RcWordSource { kind, .. }) => {`
	`164`	`+ ProgramError::RcBlockTooLong(RcWordSource { kind, .. }) => {`
`167`	`165`	`write!(f, "RC-word block grew too long to allocate {kind}")`
`168`	`166`	`}`
`169`		`- FailedToAssignIndexRegister(_span, symbol_name) => {`
	`167`	`+ ProgramError::FailedToAssignIndexRegister(_span, symbol_name) => {`
`170`	`168`	`write!(`
`171`	`169`	`f,`
`172`	`170`	`"there are not enough index registers available to assign one for {symbol_name}"`
`173`	`171`	`)`
`174`	`172`	`}`
`175`		`- BlockTooLong(_span, mle) => {`
	`173`	`+ ProgramError::BlockTooLong(_span, mle) => {`
`176`	`174`	`write!(f, "program block contains too many machine words: {mle}")`
`177`	`175`	`}`
`178`		`- InconsistentTag { name, span: _, msg } => {`
	`176`	`+ ProgramError::InconsistentTag { name, span: _, msg } => {`
`179`	`177`	`write!(f, "inconsistent definitions for tag {name}: {msg}")`
`180`	`178`	`}`
`181`		`- SymbolDefinitionLoop {`
	`179`	`+ ProgramError::SymbolDefinitionLoop {`
`182`	`180`	`symbol_names,`
`183`	`181`	`span: _,`
`184`	`182`	`} => {`
`@@ -195,7 +193,7 @@ impl Display for ProgramError {`
`195`	`193`	`}`
`196`	`194`	`Ok(())`
`197`	`195`	`}`
`198`		`- SyntaxError { span: _, msg } => {`
	`196`	`+ ProgramError::SyntaxError { span: _, msg } => {`
`199`	`197`	`write!(f, "{msg}")`
`200`	`198`	`}`
`201`	`199`	`}`