interpreter: Remove fmt::Display impls which didn't make sense

Also refactor uses of `todo!()` to use variables directly in their
format strings.

Author: jakemarsden

jakescript-cli/src/repl.rs

@@ -32,7 +32,7 @@ where
             match it.vm().execution_state() {
                 ExecutionState::Advance => {}
                 ExecutionState::Exception(ex) => {
-                    eprintln!("Exception: {ex}");
+                    eprintln!("Exception: {ex:?}");
                     self.input_buf.clear();
                     return Result::ExitWithRuntimeError;
                 }
@@ -86,7 +86,7 @@ where
                     continue;
                 }
             };
-            eprintln!("{value}");
+            eprintln!("{value:?}");
         }
     }
 

jakescript/src/interpreter/expression.rs

@@ -77,7 +77,7 @@ impl Eval for NewExpression {
     type Output = Value;
 
     fn eval(&self, _: &mut Interpreter) -> Result<Self::Output> {
-        todo!("NewExpression::eval: {:#?}", self)
+        todo!("NewExpression::eval: {self:#?}")
     }
 }
 
@@ -114,7 +114,7 @@ impl Eval for AssignmentExpression {
                         compute_updated,
                         map_err,
                     ),
-                    lhs => todo!("AssignmentExpression::eval: base_value={:?}", lhs),
+                    lhs => todo!("AssignmentExpression::eval: base_value={lhs:?}"),
                 }
             }
             Expression::Member(MemberExpression::ComputedMemberAccess(lhs_node)) => {
@@ -127,14 +127,14 @@ impl Eval for AssignmentExpression {
                                 // FIXME: Remove this restriction as I think it's actually OK to key
                                 // an object property by the empty
                                 // string.
-                                todo!("AssignmentExpression::eval: prop_name={}", prop_value)
+                                todo!("AssignmentExpression::eval: prop_name={prop_value:?}")
                             });
                         it.update_object_property(lhs_ref, &prop_key, compute_updated, map_err)
                     }
-                    lhs => todo!("AssignmentExpression::eval: base_value={:?}", lhs),
+                    lhs => todo!("AssignmentExpression::eval: base_value={lhs:?}"),
                 }
             }
-            lhs => todo!("AssignmentExpression::eval: lhs={:#?}", lhs),
+            lhs => todo!("AssignmentExpression::eval: lhs={lhs:#?}"),
         }
     }
 }
@@ -235,10 +235,10 @@ impl Eval for UpdateExpression {
                         compute_updated,
                         map_err,
                     ),
-                    operand => todo!("UpdateExpression::eval: operand={:?}", operand),
+                    operand => todo!("UpdateExpression::eval: operand={operand:?}"),
                 }
             }
-            operand => todo!("UpdateExpression::eval: operand={:#?}", operand),
+            operand => todo!("UpdateExpression::eval: operand={operand:#?}"),
         }
     }
 }
@@ -270,7 +270,7 @@ impl Eval for MemberAccessExpression {
                     .unwrap_or_default();
                 Ok(value)
             }
-            base_value => todo!("PropertyAccessExpression::eval: base={:?}", base_value),
+            base_value => todo!("PropertyAccessExpression::eval: base={base_value:?}"),
         }
     }
 }
@@ -282,12 +282,12 @@ impl Eval for ComputedMemberAccessExpression {
         let base_value = self.base.eval(it)?;
         let (base_refr, base_obj) = match base_value {
             Value::Object(base_refr) => (base_refr, it.vm().heap().resolve(base_refr)),
-            base_value => todo!("ComputedPropertyExpression::eval: base={:?}", base_value),
+            base_value => todo!("ComputedPropertyExpression::eval: base={base_value:?}"),
         };
         let property_value = self.member.eval(it)?;
         let property = match property_value {
             Value::Number(Number::Int(n)) => PropertyKey::from(n),
-            property => todo!("ComputedPropertyExpression::eval: property={:?}", property),
+            property => todo!("ComputedPropertyExpression::eval: property={property:?}"),
         };
         let value = base_obj
             .as_ref()
@@ -321,7 +321,7 @@ impl Eval for FunctionCallExpression {
         };
         let receiver = match receiver {
             Some(Value::Object(receiver)) => Some(receiver),
-            Some(receiver) => todo!("FunctionCallExpression: receiver={:?}", receiver),
+            Some(receiver) => todo!("FunctionCallExpression: receiver={receiver:?}"),
             None => None,
         };
 

jakescript/src/interpreter/heap.rs

@@ -35,20 +35,14 @@ impl Heap {
 #[derive(Clone, Copy, Eq, PartialEq)]
 pub struct Reference(usize);
 
-impl fmt::Display for Reference {
+impl fmt::Debug 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.
         write!(f, "{:#06x}", self.0)
     }
 }
 
-impl fmt::Debug for Reference {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-
 #[derive(Clone)]
 pub struct ObjectRef {
     obj: Rc<RefCell<Object>>,

jakescript/src/interpreter/value.rs

@@ -18,18 +18,6 @@ impl Value {
     }
 }
 
-impl fmt::Display for Value {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::Boolean(value) => write!(f, "{value}"),
-            Self::Number(value) => write!(f, "{value}"),
-            Self::Object(value) => write!(f, "{value}"),
-            Self::Null => f.write_str("null"),
-            Self::Undefined => f.write_str("undefined"),
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug)]
 pub enum Number {
     Float(f64),
@@ -166,21 +154,21 @@ impl Number {
     ///
     /// Always panics.
     pub fn checked_shl(self, rhs: Self) -> Option<Self> {
-        todo!("Number::checked_shl: lhs={}, rhs={}", self, rhs)
+        todo!("Number::checked_shl: lhs={self}, rhs={rhs}")
     }
 
     /// # Panics
     ///
     /// Always panics.
     pub fn checked_shr_signed(self, rhs: Self) -> Option<Self> {
-        todo!("Number::checked_shr_signed: lhs={}, rhs={}", self, rhs)
+        todo!("Number::checked_shr_signed: lhs={self}, rhs={rhs}")
     }
 
     /// # Panics
     ///
     /// Always panics.
     pub fn checked_shr_unsigned(self, rhs: Self) -> Option<Self> {
-        todo!("Number::checked_shr_unsigned: lhs={}, rhs={}", self, rhs)
+        todo!("Number::checked_shr_unsigned: lhs={self}, rhs={rhs}")
     }
 }
 

jakescript/src/lexer/mod.rs

@@ -57,7 +57,7 @@ impl<I: FallibleIterator<Item = char, Error = io::Error>> Lexer<I> {
             Element::new_token(it, loc)
         } else {
             let ch = self.source.peek()?.unwrap();
-            todo!("Lexer::parse_element: ch={}", ch)
+            todo!("Lexer::parse_element: ch={ch}")
         })
     }
 

jakescript/src/parser/expression.rs

@@ -284,8 +284,7 @@ impl<I: FallibleIterator<Item = Element, Error = lexer::Error>> Parser<I> {
             Expression::IdentifierReference(member_expr) => member_expr.identifier,
             member_expr => todo!(
                 "Unsupported member access expression (only simple `a.b` expressions are \
-                 supported): {:?}",
-                member_expr
+                 supported): {member_expr:?}"
             ),
         };
         Ok(MemberAccessExpression {