[assembler] Formatting fixes ("cargo fmt").

Author: youngman-g

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};
@@ -362,10 +362,10 @@ fn assemble_pass2<'s>(
         match block_position.evaluate(&mut ctx) {
             Ok(value) => {
                 if !ctx.index_register_assigner.is_empty() {
-                    return Err(AssemblerFailure::InternalError(
-                        format!(
-                            "While determining the addresses of {0}, we assigned an index register.  Block origins should not depend on index registers",
-                        &block_position.block_identifier)));
+                    return Err(AssemblerFailure::InternalError(format!(
+                        "While determining the addresses of {0}, we assigned an index register.  Block origins should not depend on index registers",
+                        &block_position.block_identifier
+                    )));
                 }
 
                 let address: Address = subword::right_half(value).into();
@@ -865,8 +865,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;

assembler/src/asmlib/driver/tests.rs

@@ -5,20 +5,20 @@ use super::super::ast::{
     InstructionSequence, LiteralValue, TaggedProgramInstruction, UntaggedProgramInstruction,
 };
 use super::super::collections::OneOrMore;
-use super::super::eval::{make_empty_rc_block_for_test, symbol_name_lookup, EvaluationContext};
+use super::super::eval::{EvaluationContext, make_empty_rc_block_for_test, symbol_name_lookup};
 use super::super::manuscript::{ManuscriptBlock, PunchCommand, SourceFile};
 use super::super::memorymap::LocatedBlock;
 use super::super::source::Source;
 use super::super::span::*;
 use super::super::symbol::SymbolName;
 use super::super::symtab::IndexRegisterAssigner;
+use super::{Binary, BinaryChunk, assemble_pass1};
 use super::{assemble_nonempty_valid_input, assemble_source};
-use super::{assemble_pass1, Binary, BinaryChunk};
 use base::{
     charset::Script,
     prelude::{
-        u18, u36, u6, Address, Instruction, Opcode, OperandAddress, SymbolicInstruction,
-        Unsigned18Bit, Unsigned36Bit, Unsigned5Bit, Unsigned6Bit,
+        Address, Instruction, Opcode, OperandAddress, SymbolicInstruction, Unsigned5Bit,
+        Unsigned6Bit, Unsigned18Bit, Unsigned36Bit, u6, u18, u36,
     },
 };
 
@@ -136,26 +136,33 @@ fn test_metacommand_dec_changes_default_base() {
         "no index register should have been default-assigned"
     );
 
-    if let [LocatedBlock {
-        origin: _,
-        location: _,
-        sequences,
-    }] = directive.blocks.values().collect::<Vec<_>>().as_slice()
+    if let [
+        LocatedBlock {
+            origin: _,
+            location: _,
+            sequences,
+        },
+    ] = directive.blocks.values().collect::<Vec<_>>().as_slice()
     {
-        if let [InstructionSequence {
-            local_symbols: None,
-            instructions,
-        }] = sequences.as_slice()
+        if let [
+            InstructionSequence {
+                local_symbols: None,
+                instructions,
+            },
+        ] = sequences.as_slice()
         {
-            if let [TaggedProgramInstruction {
-                span: _,
-                tags: tags1,
-                instruction: first_instruction,
-            }, TaggedProgramInstruction {
-                span: _,
-                tags: tags2,
-                instruction: second_instruction,
-            }] = instructions.as_slice()
+            if let [
+                TaggedProgramInstruction {
+                    span: _,
+                    tags: tags1,
+                    instruction: first_instruction,
+                },
+                TaggedProgramInstruction {
+                    span: _,
+                    tags: tags2,
+                    instruction: second_instruction,
+                },
+            ] = instructions.as_slice()
             {
                 assert!(tags1.is_empty());
                 assert!(tags2.is_empty());
@@ -1048,13 +1055,16 @@ fn test_symbol_definition_loop_detection() {
             );
             let errors = Vec::from(errors);
             match errors.as_slice() {
-                [e1 @ WithLocation {
-                    location: _,
-                    inner: ProgramError::SymbolDefinitionLoop { .. },
-                }, e2 @ WithLocation {
-                    location: _,
-                    inner: ProgramError::SymbolDefinitionLoop { .. },
-                }] => {
+                [
+                    e1 @ WithLocation {
+                        location: _,
+                        inner: ProgramError::SymbolDefinitionLoop { .. },
+                    },
+                    e2 @ WithLocation {
+                        location: _,
+                        inner: ProgramError::SymbolDefinitionLoop { .. },
+                    },
+                ] => {
                     // Then the error messages that result should name
                     // both of the problem symbols, indicating the
                     // dependency loop for each.

assembler/src/asmlib/eval.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 use std::fmt::{self, Debug, Display, Formatter};
 use std::ops::Shl;
 
-use tracing::{event, Level};
+use tracing::{Level, event};
 
 use base::{
     charset::Script,
@@ -22,9 +22,9 @@ use super::symbol::{ConfigUse, IndexUse, OriginUse, SymbolName};
 use super::types::{AssemblerFailure, BlockIdentifier, MachineLimitExceededFailure, ProgramError};
 use crate::symbol::SymbolContext;
 use crate::symtab::{
-    record_undefined_symbol_or_return_failure, ExplicitDefinition, ExplicitSymbolTable,
-    FinalSymbolDefinition, FinalSymbolTable, FinalSymbolType, ImplicitDefinition,
-    ImplicitSymbolTable, IndexRegisterAssigner, LookupOperation, TagDefinition,
+    ExplicitDefinition, ExplicitSymbolTable, FinalSymbolDefinition, FinalSymbolTable,
+    FinalSymbolType, ImplicitDefinition, ImplicitSymbolTable, IndexRegisterAssigner,
+    LookupOperation, TagDefinition, record_undefined_symbol_or_return_failure,
 };
 
 #[derive(Debug, PartialEq, Eq)]