rust fmt

```
$ cargo fmt --version
rustfmt 1.8.0
```

Author: abhillman

assembler/src/asmlib/ast.rs

@@ -19,15 +19,15 @@ use std::fmt::{self, Display, Formatter, Octal, Write};
 use std::hash::Hash;
 use std::ops::{Shl, Shr};
 
-use tracing::{event, Level};
+use tracing::{Level, event};
 
-use base::charset::{subscript_char, superscript_char, Script};
+use base::charset::{Script, subscript_char, superscript_char};
 use base::prelude::*;
 use base::u18;
 
 use super::collections::OneOrMore;
 use super::eval::{
-    symbol_name_lookup, Evaluate, EvaluationContext, HereValue, SymbolLookupFailure,
+    Evaluate, EvaluationContext, HereValue, SymbolLookupFailure, symbol_name_lookup,
 };
 use super::glyph;
 use super::listing::{Listing, ListingLine};
@@ -40,9 +40,9 @@ use super::source::Source;
 use super::span::*;
 use super::symbol::{InconsistentSymbolUse, SymbolContext, SymbolName};
 use super::symtab::{
-    record_undefined_symbol_or_return_failure, BadSymbolDefinition, ExplicitDefinition,
-    ExplicitSymbolTable, FinalSymbolDefinition, FinalSymbolTable, FinalSymbolType,
-    ImplicitSymbolTable, IndexRegisterAssigner, TagDefinition,
+    BadSymbolDefinition, ExplicitDefinition, ExplicitSymbolTable, FinalSymbolDefinition,
+    FinalSymbolTable, FinalSymbolType, ImplicitSymbolTable, IndexRegisterAssigner, TagDefinition,
+    record_undefined_symbol_or_return_failure,
 };
 use super::types::*;
 mod eval;
@@ -201,7 +201,8 @@ impl SignedAtom {
         &self,
         block_id: BlockIdentifier,
         block_offset: Unsigned18Bit,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         self.magnitude.symbol_uses(block_id, block_offset)
     }
 
@@ -308,7 +309,8 @@ impl ArithmeticExpression {
         &self,
         block_id: BlockIdentifier,
         block_offset: Unsigned18Bit,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         let mut result = Vec::with_capacity(1 + self.tail.len());
         result.extend(self.first.symbol_uses(block_id, block_offset));
         result.extend(
@@ -339,7 +341,9 @@ impl ArithmeticExpression {
             Operator::Subtract => match left.checked_sub(right) {
                 Some(result) => result,
                 None => {
-                    todo!("subtraction overflow occurred in {left}-{right} but this is not implemented")
+                    todo!(
+                        "subtraction overflow occurred in {left}-{right} but this is not implemented"
+                    )
                 }
             },
             Operator::Multiply => match left.checked_mul(right) {
@@ -445,7 +449,8 @@ impl ConfigValue {
         &self,
         block_id: BlockIdentifier,
         block_offset: Unsigned18Bit,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         self.expr
             .symbol_uses(block_id, block_offset)
             .map(|r| match r {
@@ -578,7 +583,9 @@ impl Spanned for RegistersContaining {
         match it.next() {
             Some(rc) => it.fold(rc.span(), |acc, rc| acc.union(rc.span())),
             None => {
-                unreachable!("invariant broken: RegistersContaining contains no RegisterContaining instances")
+                unreachable!(
+                    "invariant broken: RegistersContaining contains no RegisterContaining instances"
+                )
             }
         }
     }
@@ -638,7 +645,9 @@ impl RegisterContaining {
                             // words.
                         }
                         SymbolUse::Definition(ExplicitDefinition::Origin(_, _)) => {
-                            unreachable!("Found origin {name} inside an RC-word; the parser should have rejected this.");
+                            unreachable!(
+                                "Found origin {name} inside an RC-word; the parser should have rejected this."
+                            );
                         }
                         SymbolUse::Definition(_) => {
                             // e.g. we have an input like
@@ -655,7 +664,9 @@ impl RegisterContaining {
                             // When working on this case we should
                             // figure out if an equality is allowed
                             // inside a macro expansion.
-                            panic!("Found unexpected definition of {name} inside RC-word reference at {span:?}");
+                            panic!(
+                                "Found unexpected definition of {name} inside RC-word reference at {span:?}"
+                            );
                         }
                     }
                 }
@@ -776,7 +787,8 @@ impl Atom {
         &self,
         block_id: BlockIdentifier,
         block_offset: Unsigned18Bit,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         let mut result: Vec<Result<_, _>> = Vec::with_capacity(1);
         match self {
             Atom::SymbolOrLiteral(SymbolOrLiteral::Symbol(script, name, span)) => {
@@ -933,7 +945,8 @@ pub(crate) enum SymbolOrLiteral {
 impl SymbolOrLiteral {
     fn symbol_uses(
         &self,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         let mut result = Vec::with_capacity(1);
         match self {
             SymbolOrLiteral::Here(_, _) | SymbolOrLiteral::Literal(_) => (),
@@ -1101,7 +1114,8 @@ impl InstructionFragment {
         &self,
         block_id: BlockIdentifier,
         block_offset: Unsigned18Bit,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         let mut uses: Vec<Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> =
             Vec::new();
         match self {
@@ -1172,7 +1186,9 @@ impl InstructionFragment {
                         rc_word_value,
                     }),
                 SymbolSubstitution::Hit(_span, _script, _arithmetic_expression) => {
-                    todo!("macro parameter expansion is not yet fully supported in the index part of pipe constructs")
+                    todo!(
+                        "macro parameter expansion is not yet fully supported in the index part of pipe constructs"
+                    )
                 }
                 SymbolSubstitution::Omit => None,
                 SymbolSubstitution::Zero(span) => Some(InstructionFragment::Null(span)),
@@ -1282,7 +1298,8 @@ impl Origin {
     pub(super) fn symbol_uses(
         &self,
         block_id: BlockIdentifier,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         let mut result = Vec::with_capacity(1);
         match self {
             Origin::Literal(_span, _) => (),
@@ -1581,7 +1598,8 @@ impl Tag {
         &self,
         block_id: BlockIdentifier,
         block_offset: Unsigned18Bit,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         [Ok((
             self.name.clone(),
             self.span,
@@ -1621,7 +1639,8 @@ impl TaggedProgramInstruction {
         &self,
         block_id: BlockIdentifier,
         offset: Unsigned18Bit,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         let mut result: Vec<Result<_, _>> = Vec::new();
         result.extend(
             self.tags
@@ -1809,7 +1828,8 @@ impl InstructionSequence {
     pub(crate) fn symbol_uses(
         &self,
         block_id: BlockIdentifier,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         let no_symbols = ExplicitSymbolTable::default();
         let local_scope: &ExplicitSymbolTable = self.local_symbols.as_ref().unwrap_or(&no_symbols);
         let mut result: Vec<Result<_, _>> = Vec::new();
@@ -1859,7 +1879,9 @@ impl InstructionSequence {
             }
 
             if self.local_symbols.is_some() {
-                panic!("InstructionSequence::build_binary_block: evaluation with local symbol tables is not yet implemented");
+                panic!(
+                    "InstructionSequence::build_binary_block: evaluation with local symbol tables is not yet implemented"
+                );
             }
             let mut ctx = EvaluationContext {
                 explicit_symtab,
@@ -1903,7 +1925,8 @@ pub(crate) struct Equality {
 impl Equality {
     pub(super) fn symbol_uses(
         &self,
-    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<> {
+    ) -> impl Iterator<Item = Result<(SymbolName, Span, SymbolUse), InconsistentSymbolUse>> + use<>
+    {
         [Ok((
             self.name.clone(),
             self.span,

assembler/src/asmlib/collections.rs

@@ -71,14 +71,13 @@ impl<T> OneOrMore<T> {
     }
 
     pub fn try_from_iter<I: Iterator<Item = T>>(mut it: I) -> Result<Self, NoItems> {
-        match it.next() { Some(head) => {
-            Ok(Self {
+        match it.next() {
+            Some(head) => Ok(Self {
                 head,
                 tail: it.collect(),
-            })
-        } _ => {
-            Err(NoItems {})
-        }}
+            }),
+            _ => Err(NoItems {}),
+        }
     }
 
     pub fn extend<I: Iterator<Item = T>>(&mut self, items: I) {

assembler/src/asmlib/driver.rs

@@ -10,14 +10,14 @@ use std::io::{BufReader, BufWriter, Read};
 use std::path::{Path, PathBuf};
 
 use chumsky::error::Rich;
-use tracing::{event, span, Level};
+use tracing::{Level, event, span};
 
 use super::ast::*;
 use super::collections::OneOrMore;
 use super::directive::Directive;
 use super::eval::Evaluate;
 use super::eval::HereValue;
-use super::eval::{extract_final_equalities, EvaluationContext, RcBlock};
+use super::eval::{EvaluationContext, RcBlock, extract_final_equalities};
 use super::lexer;
 use super::listing::*;
 #[cfg(test)]
@@ -35,8 +35,8 @@ use super::span::*;
 use super::state::{NumeralMode, State};
 use super::symbol::SymbolName;
 use super::symtab::{
-    assign_default_rc_word_tags, ExplicitSymbolTable, FinalSymbolDefinition, FinalSymbolTable,
-    FinalSymbolType, ImplicitSymbolTable, IndexRegisterAssigner,
+    ExplicitSymbolTable, FinalSymbolDefinition, FinalSymbolTable, FinalSymbolType,
+    ImplicitSymbolTable, IndexRegisterAssigner, assign_default_rc_word_tags,
 };
 use super::types::*;
 use base::prelude::{Address, IndexBy, Unsigned18Bit, Unsigned36Bit};
@@ -117,7 +117,9 @@ fn assemble_nonempty_input<'a, 'b: 'a>(input: &'b Source<'a>) -> AssemblerPass1O
         Ok((None, _output_options)) => match OneOrMore::try_from_vec(errors) {
             Ok(errors) => AssemblerPass1Or2Output::Pass1Failed(Ok(errors)),
             Err(_) => {
-                unreachable!("assemble_pass1 returned no SourceFile instance but there were no output errors either");
+                unreachable!(
+                    "assemble_pass1 returned no SourceFile instance but there were no output errors either"
+                );
             }
         },
         Ok((Some(source_file), output_options)) => match assemble_pass2(source_file, input) {
@@ -364,9 +366,9 @@ fn assemble_pass2<'s>(
         match (&block_identifier, &block_position).evaluate(&mut ctx) {
             Ok(value) => {
                 if !ctx.index_register_assigner.is_empty() {
-                    return Err(AssemblerFailure::InternalError(
-                        format!(
-                            "While determining the addresses of {block_identifier}, we assigned an index register.  Block origins should not depend on index registers")));
+                    return Err(AssemblerFailure::InternalError(format!(
+                        "While determining the addresses of {block_identifier}, we assigned an index register.  Block origins should not depend on index registers"
+                    )));
                 }
 
                 let address: Address = subword::right_half(value).into();
@@ -541,11 +543,15 @@ fn assemble_pass3(
     for name in implicit_symtab.symbols() {
         match (implicit_symtab.get(name), explicit_symtab.get(name)) {
             (Some(implicit), Some(explicit)) => {
-                panic!("symbol {name} appears in both the implicit ({implicit:#?} and the explicit ({explicit:#?} symbol tables");
+                panic!(
+                    "symbol {name} appears in both the implicit ({implicit:#?} and the explicit ({explicit:#?} symbol tables"
+                );
             }
             (Some(_), None) | (None, Some(_)) => (),
             (None, None) => {
-                panic!("symbol {name} is returned by ImplicitSymbolTable::symbols() but is not defined there");
+                panic!(
+                    "symbol {name} is returned by ImplicitSymbolTable::symbols() but is not defined there"
+                );
             }
         }
     }
@@ -866,8 +872,11 @@ fn test_duplicate_global_tag() {
                     inner: ProgramError::SyntaxError { msg, span: _ },
                     ..
                 } => {
-                    assert!(msg
-                        .contains("bad symbol definition for TGX: TGX is defined more than once"));
+                    assert!(
+                        msg.contains(
+                            "bad symbol definition for TGX: TGX is defined more than once"
+                        )
+                    );
                 }
                 other => {
                     panic!("expected a syntax error report, got {other:?}");

assembler/src/asmlib/driver/output.rs

@@ -1,11 +1,11 @@
 use std::io::Write;
 use std::path::Path;
 
-use tracing::{event, span, Level};
+use tracing::{Level, event, span};
 
 use base::prelude::{
-    join_halves, split_halves, u18, u5, u6, unsplay, Address, Instruction, Opcode, OperandAddress,
-    Signed18Bit, SymbolicInstruction, Unsigned18Bit, Unsigned36Bit, Unsigned6Bit,
+    Address, Instruction, Opcode, OperandAddress, Signed18Bit, SymbolicInstruction, Unsigned6Bit,
+    Unsigned18Bit, Unsigned36Bit, join_halves, split_halves, u5, u6, u18, unsplay,
 };
 
 use super::super::readerleader::reader_leader;
@@ -146,7 +146,9 @@ fn create_begin_block(
             // should closely examine what appear to be the original
             // (TX-2 assembly language) programmer's assumptions about
             // what will happen.
-            panic!("PUNCH directive specifies deferred start address {start:o}; this is (deliberately) not yet supported - check carefully!");
+            panic!(
+                "PUNCH directive specifies deferred start address {start:o}; this is (deliberately) not yet supported - check carefully!"
+            );
         }
         // When there is a known start address `start` we emit a `JPQ
         // start` instruction into memory register 0o27.
@@ -193,8 +195,10 @@ pub fn write_user_program<W: Write>(
     write_data(writer, output_file_name, &reader_leader())?;
     for chunk in binary.chunks().iter() {
         if chunk.is_empty() {
-            event!(Level::ERROR, "Will not write empty block at {:o}; the assembler should not have generated one; this is a bug.",
-                   chunk.address,
+            event!(
+                Level::ERROR,
+                "Will not write empty block at {:o}; the assembler should not have generated one; this is a bug.",
+                chunk.address,
             );
             continue;
         }