misc: Update formatting rules

Update the rustfmt config and re-format everything.

Author: jakemarsden

jakescript-test262/src/main.rs

@@ -37,11 +37,13 @@ fn main() {
         let expected = Expected::from(test.desc.negative.as_ref());
         let test_path = &test.path.display();
 
-        // TODO: Time out to protect against tests which fail by entering an infinite loop.
+        // TODO: Time out to protect against tests which fail by entering an infinite
+        // loop.
         let test_result = exec_test_suppressing_panic(&test);
 
-        // TODO: For negative test cases, check that the name of the thrown exception matches the
-        //  `Negative::type` (as well as the `Negative::phase`) in the test description.
+        // TODO: For negative test cases, check that the name of the thrown exception
+        // matches the `Negative::type` (as well as the `Negative::phase`) in the test
+        // description.
         match (test_result, expected) {
             (Ok(()), Expected::Pass)
             | (Err(FailureReason::Parse(..)), Expected::ParserFail)
@@ -140,8 +142,8 @@ impl From<Option<&Negative>> for Expected {
     }
 }
 
-// TODO: Using `String` as a workaround for the fact that `parser::Error` and `interpreter::Error`
-//  aren't currently `Send`.
+// TODO: Using `String` as a workaround for the fact that `parser::Error` and
+// `interpreter::Error` aren't currently `Send`.
 #[derive(Debug)]
 enum FailureReason {
     Parse(String),

jakescript/src/ast/declaration.rs

@@ -64,9 +64,10 @@ pub struct VariableDeclaration {
 impl VariableDeclaration {
     /// Split the declaration into
     ///
-    /// 1. a "main" [`VariableDeclaration`], sans initialisers, to declare each entry
-    /// 2. a new, synthesised [`Expression`] to initialise each entry, for each entry which started
-    /// with an initialiser.
+    /// 1. a "main" [`VariableDeclaration`], sans initialisers, to declare each
+    /// entry.
+    /// 2. a new, synthesised [`Expression`] to initialise each
+    /// entry, for each entry which started with an initialiser.
     pub fn into_declaration_and_initialiser(mut self) -> (Self, Vec<Expression>) {
         let mut initialisers = Vec::with_capacity(self.bindings.len());
         for entry in &mut self.bindings {

jakescript/src/ast/expression.rs

@@ -487,6 +487,6 @@ pub enum Associativity {
 pub struct Precedence(u8);
 
 impl Precedence {
-    pub const MIN: Self = Self(1);
     pub const MAX: Self = Self(21);
+    pub const MIN: Self = Self(1);
 }

jakescript/src/ast/literal.rs

@@ -9,8 +9,8 @@ pub enum Literal {
     Null,
 }
 
-/// Numeric literal tokens are **always unsigned** (but can be made negative at runtime with the
-/// negation unary operator).
+/// Numeric literal tokens are **always unsigned** (but can be made negative at
+/// runtime with the negation unary operator).
 #[derive(Copy, Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub enum NumericLiteral {
     Int(u64),

jakescript/src/ast/mod.rs

@@ -1,12 +1,11 @@
+use crate::token::SourceLocation;
 pub use block::*;
 pub use declaration::*;
 pub use expression::*;
 pub use identifier::*;
 pub use literal::*;
-pub use statement::*;
-
-use crate::token::SourceLocation;
 use serde::{de, ser};
+pub use statement::*;
 use std::fmt;
 
 mod block;

jakescript/src/ast/statement.rs

@@ -167,15 +167,18 @@ pub struct ForStatement {
 
 impl_node!(ForStatement);
 
-// TODO: a better way to factor this, if there is one. A for-loop's initialiser can either be a
-//  variable declaration or an expression (why?), so it's type can't be as simple as
-//  `VariableDeclaration`. It also can't be `Expression` because a declaration can't be made a type
-//  of expression, and it can't be `Statement` because only certain types of statement are allowed.
-//  - valid:   for (var i = 0;;) {}                  // can be a variable declaration
+// TODO: a better way to factor this, if there is one. A for-loop's initialiser
+// can either be a  variable declaration or an expression (why?), so it's type
+// can't be as simple as  `VariableDeclaration`. It also can't be `Expression`
+// because a declaration can't be made a type  of expression, and it can't be
+// `Statement` because only certain types of statement are allowed.
+//  - valid:   for (var i = 0;;) {}                  // can be a variable
+//    declaration
 //  - valid:   for (1 + 1;;) {}                      // can be any expression
 //  - valid:   for (console.log("hello world");;) {} // can be any expression
 //  - invalid: for (if (true) {};;) {}               // can't be any statement
-//  - invalid: console.log(let foo = "bar");         // a declaration can't be a type of expression
+//  - invalid: console.log(let foo = "bar");         // a declaration can't be a
+//    type of expression
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 #[serde(tag = "initialiser_type")]
 pub enum LoopInitialiser {

jakescript/src/interpreter/heap.rs

@@ -16,22 +16,26 @@ impl Heap {
         Ok(Reference::new(obj_idx, obj))
     }
 
-    // unused_self: Will be used in the future, see comment about storing objects inside the heap.
+    // unused_self: Will be used in the future, see comment about storing objects
+    // inside the heap.
     #[allow(clippy::unused_self)]
     pub fn resolve<'a>(&self, refr: &'a Reference) -> Ref<'a, Object> {
         refr.deref()
     }
-    // unused_self: Will be used in the future, see comment about storing objects inside the heap.
+
+    // unused_self: Will be used in the future, see comment about storing objects
+    // inside the heap.
     #[allow(clippy::unused_self)]
     pub fn resolve_mut<'a>(&mut self, refr: &'a Reference) -> RefMut<'a, Object> {
         refr.deref_mut()
     }
 }
 
-// TODO: Store objects inside the actual `Heap` struct, rather than ref-counting them in the
-//  `Reference` type because currently, the heap stores nothing. This was done for simplicity, and
-//  to avoid needing to worry about garbage collection. Also simplify the `Reference` type to
-//  `#[derive(Copy, Clone)] pub struct Reference(usize)` when possible.
+// TODO: Store objects inside the actual `Heap` struct, rather than ref-counting
+// them in the  `Reference` type because currently, the heap stores nothing.
+// This was done for simplicity, and  to avoid needing to worry about garbage
+// collection. Also simplify the `Reference` type to  `#[derive(Copy, Clone)]
+// pub struct Reference(usize)` when possible.
 #[derive(Clone)]
 pub struct Reference(usize, Rc<RefCell<Object>>);
 
@@ -43,6 +47,7 @@ impl Reference {
     fn deref(&self) -> Ref<Object> {
         RefCell::borrow(&self.1)
     }
+
     fn deref_mut(&self) -> RefMut<Object> {
         RefCell::borrow_mut(&self.1)
     }
@@ -58,7 +63,8 @@ impl PartialEq for Reference {
 
 impl fmt::Display for Reference {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // Note: 6 includes the 2 chars for the "0x" prefix, so only 4 actual digits are displayed.
+        // Note: 6 includes the 2 chars for the "0x" prefix, so only 4 actual digits are
+        // displayed.
         write!(f, "{:#06x}", self.0)
     }
 }

jakescript/src/interpreter/mod.rs

@@ -1,16 +1,15 @@
+use crate::ast::*;
+use crate::runtime::{Builtin, NativeCall};
 pub use error::*;
 pub use heap::*;
 pub use object::*;
 pub use stack::*;
-pub use value::*;
-pub use vm::*;
-
-use crate::ast::*;
-use crate::runtime::{Builtin, NativeCall};
 use std::cmp;
 use std::collections::HashMap;
 use std::ops::{BitAnd, BitOr, BitXor, Not};
 use std::str::FromStr;
+pub use value::*;
+pub use vm::*;
 
 mod block;
 mod declaration;
@@ -42,6 +41,7 @@ impl Interpreter {
     pub fn vm(&self) -> &Vm {
         &self.vm
     }
+
     pub fn vm_mut(&mut self) -> &mut Vm {
         &mut self.vm
     }
@@ -162,10 +162,10 @@ impl Interpreter {
             .stack_mut()
             .push_frame(declared_scope, receiver);
         if let Some(fn_name) = f.name() {
-            // Create an outer scope with nothing but the function's name, which points to itself,
-            // so that named function literals may recurse using their name without making the name
-            // visible outside of the function body. It has its own outer scope so it can still be
-            // shadowed by parameters with the same name.
+            // Create an outer scope with nothing but the function's name, which points to
+            // itself, so that named function literals may recurse using their name without
+            // making the name visible outside of the function body. It has its own outer
+            // scope so it can still be shadowed by parameters with the same name.
             let fn_scope_ctx_outer = ScopeCtx::new(vec![Variable::new(
                 VariableKind::Var,
                 fn_name.clone(),

jakescript/src/interpreter/object.rs

@@ -113,6 +113,7 @@ impl Object {
     pub fn prototype(&self) -> Option<&Reference> {
         self.proto.as_ref()
     }
+
     pub fn set_prototype(&mut self, proto: Option<Reference>) -> bool {
         match self.extensible() {
             Extensible::Yes => {
@@ -130,6 +131,7 @@ impl Object {
     pub fn own_property(&self, key: &PropertyKey) -> Option<&Property> {
         self.props.get(key)
     }
+
     pub fn own_property_mut(&mut self, key: &PropertyKey) -> Option<&mut Property> {
         self.props.get_mut(key)
     }

jakescript/src/interpreter/stack.rs

@@ -15,6 +15,7 @@ impl CallStack {
     pub fn frame(&self) -> &CallFrame {
         self.frames.last().unwrap_or(&self.root)
     }
+
     pub fn frame_mut(&mut self) -> &mut CallFrame {
         self.frames.last_mut().unwrap_or(&mut self.root)
     }
@@ -38,6 +39,7 @@ impl CallFrame {
     pub fn scope(&self) -> &Scope {
         &self.scope
     }
+
     pub fn scope_mut(&mut self) -> &mut Scope {
         &mut self.scope
     }

jakescript/src/interpreter/statement.rs

@@ -84,8 +84,8 @@ impl Eval for SwitchStatement {
             }
             cases.next().unwrap();
         }
-        // Evaluate remaining cases in turn (may do nothing if any of the cases change the execution
-        // state).
+        // Evaluate remaining cases in turn (may do nothing if any of the cases change
+        // the execution state).
         for case in cases {
             case.eval(it)?;
         }
@@ -102,8 +102,8 @@ impl Eval for SwitchStatement {
             | ExecutionState::Return(_)
             | ExecutionState::Exception(_)
             | ExecutionState::Exit => {
-                // Don't reset the execution state just yet so that it can be handled/cleared by
-                // some calling AST node.
+                // Don't reset the execution state just yet so that it can be
+                // handled/cleared by some calling AST node.
             }
         }
         Ok(())

jakescript/src/interpreter/value.rs

@@ -31,9 +31,9 @@ pub enum Number {
 }
 
 impl Number {
-    pub const POS_INF: Self = Self::Float(f64::INFINITY);
-    pub const NEG_INF: Self = Self::Float(f64::NEG_INFINITY);
     pub const NAN: Self = Self::Float(f64::NAN);
+    pub const NEG_INF: Self = Self::Float(f64::NEG_INFINITY);
+    pub const POS_INF: Self = Self::Float(f64::INFINITY);
 
     pub fn infinity(sign: i64) -> Self {
         if sign >= 0 {

jakescript/src/interpreter/vm.rs

@@ -35,7 +35,8 @@ impl Vm {
 
     /// # Panics
     ///
-    /// Panics if the current execution state is not [`ExecutionState::Advance`].
+    /// Panics if the current execution state is not
+    /// [`ExecutionState::Advance`].
     pub fn set_execution_state(&mut self, execution_state: ExecutionState) {
         assert_matches!(self.execution_state, ExecutionState::Advance);
         self.execution_state = execution_state;
@@ -45,10 +46,11 @@ impl Vm {
         mem::take(&mut self.execution_state)
     }
 
-    /// If the current execution state is an exception, reset it to [`ExecutionState::Advance`] and
-    /// stash the exception value away so it may be [restored][Self::restore_hidden_exception()]
-    /// later. If an exception has already been hidden, discard the exception value taken from the
-    /// execution state.
+    /// If the current execution state is an exception, reset it to
+    /// [`ExecutionState::Advance`] and stash the exception value away so it
+    /// may be [restored][Self::restore_hidden_exception()] later. If an
+    /// exception has already been hidden, discard the exception value taken
+    /// from the execution state.
     ///
     /// This is useful for allowing `finally` blocks to function properly.
     ///
@@ -102,9 +104,10 @@ impl Vm {
         }
     }
 
-    /// If an exception was previously [hidden][Self::hide_current_exception()], restore it by
-    /// putting it back into the execution state. If the execution state already contains an
-    /// exception, discard the hidden exception.
+    /// If an exception was previously [hidden][Self::hide_current_exception()],
+    /// restore it by putting it back into the execution state. If the
+    /// execution state already contains an exception, discard the hidden
+    /// exception.
     pub fn restore_hidden_exception(&mut self) {
         if let Some(exception) = self.hidden_exception.take() {
             if !matches!(self.execution_state(), ExecutionState::Exception(..)) {
@@ -113,8 +116,8 @@ impl Vm {
         }
     }
 
-    /// Reset the execution state to [`ExecutionState::Advance`] if it contains an exception, and
-    /// discard any hidden exception.
+    /// Reset the execution state to [`ExecutionState::Advance`] if it contains
+    /// an exception, and discard any hidden exception.
     pub fn clear_exception(&mut self) -> Option<Value> {
         self.hidden_exception.take();
         if matches!(self.execution_state(), ExecutionState::Exception(..)) {
@@ -131,20 +134,23 @@ impl Vm {
     pub fn heap(&self) -> &Heap {
         &self.heap
     }
+
     pub fn heap_mut(&mut self) -> &mut Heap {
         &mut self.heap
     }
 
     pub fn runtime(&self) -> &Runtime {
         &self.runtime
     }
+
     pub fn runtime_mut(&mut self) -> &mut Runtime {
         &mut self.runtime
     }
 
     pub fn stack(&self) -> &CallStack {
         &self.stack
     }
+
     pub fn stack_mut(&mut self) -> &mut CallStack {
         &mut self.stack
     }

jakescript/src/iter/peek_fallible.rs

@@ -123,8 +123,8 @@ impl<I: FallibleIterator> PeekableNthFallible<I> {
 }
 
 impl<I: FallibleIterator> FallibleIterator for PeekableNthFallible<I> {
-    type Item = I::Item;
     type Error = I::Error;
+    type Item = I::Item;
 
     fn next(&mut self) -> Result<Option<Self::Item>, Self::Error> {
         match self.peeked.pop_front() {

jakescript/src/lexer/mod.rs

@@ -1,11 +1,10 @@
-pub use error::*;
-
 use crate::iter::peek_fallible::PeekableNthFallibleIterator;
 use crate::token::symbol::*;
 use crate::token::*;
 use error::ErrorKind::{
     DigitFollowingNumericLiteral, IdentifierFollowingNumericLiteral, UnclosedComment,
 };
+pub use error::*;
 use fallible_iterator::FallibleIterator;
 use source::{Fallible, SourceCode};
 use std::io;
@@ -335,9 +334,9 @@ impl<I: FallibleIterator<Item = char, Error = io::Error>> Lexer<I> {
             return Ok(None);
         }
         if matches!(self.source.peek_nth(1)?, Some('/')) {
-            // Not a valid `RegularExpressionFirstChar`. Empty regexes aren't representable because
-            // `//` represents the start of a single-line comment. The spec suggests using `/(?:)/`
-            // as a workaround.
+            // Not a valid `RegularExpressionFirstChar`. Empty regexes aren't representable
+            // because `//` represents the start of a single-line comment. The
+            // spec suggests using `/(?:)/` as a workaround.
             return Ok(None);
         }
         let mut escaped = false;
@@ -484,7 +483,8 @@ impl<I: FallibleIterator<Item = char, Error = io::Error>> Lexer<I> {
             return Ok(None);
         }
         let mut content = String::new();
-        // Number of code points. Different from `content.len()`, which is the number of bytes.
+        // Number of code points. Different from `content.len()`, which is the number of
+        // bytes.
         let mut content_len = 0;
         for offset in 2.. {
             let ch = match self.source.peek_nth(offset)? {
@@ -510,8 +510,8 @@ impl<I: FallibleIterator<Item = char, Error = io::Error>> Lexer<I> {
 }
 
 impl<I: FallibleIterator<Item = char, Error = io::Error>> FallibleIterator for Lexer<I> {
-    type Item = Element;
     type Error = Error;
+    type Item = Element;
 
     fn next(&mut self) -> std::result::Result<Option<Self::Item>, Self::Error> {
         if self.source.peek()?.is_some() {