update with new rust version

.github/workflows/ci.yaml

@@ -0,0 +1,27 @@
+name: CI
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, reopened, synchronize]
+
+jobs:
+  test:
+    name: ${{matrix.name}}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@master
+
+      - name: Install rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+      - name: Test everything
+        uses: actions-rs/cargo@v1
+        with:
+          command: test

.gitignore

@@ -11,3 +11,5 @@ Cargo.lock
 
 .idea/
 notes.txt
+
+.vscode/

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 authors = ["Paul Dix <[email protected]>"]
 description = "A rust implementation of Thorsten Ball's Monkey programming language."
 license = "MIT"
-edition = "2018"
+edition = "2024"
 
 [dependencies]
 byteorder = "1"

src/ast.rs

@@ -1,6 +1,6 @@
 use crate::token;
-use std::fmt;
 use std::collections::HashMap;
+use std::fmt;
 use std::hash::{Hash, Hasher};
 
 #[derive(Debug)]
@@ -71,7 +71,7 @@ impl fmt::Display for Expression {
 
 #[derive(Eq, PartialEq, Clone, Debug)]
 pub struct HashLiteral {
-    pub pairs: HashMap<Expression,Expression>,
+    pub pairs: HashMap<Expression, Expression>,
 }
 
 // Had to implement Hash for this because HashMap doesn't. Doesn't matter what this is because
@@ -84,7 +84,10 @@ impl Hash for HashLiteral {
 
 impl fmt::Display for HashLiteral {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let pairs: Vec<String> = (&self.pairs).into_iter().map(|(k, v)| format!("{}:{}", k.to_string(), v.to_string())).collect();
+        let pairs: Vec<String> = (&self.pairs)
+            .iter()
+            .map(|(k, v)| format!("{}:{}", k, v))
+            .collect();
         write!(f, "{{{}}}", pairs.join(", "))
     }
 }
@@ -114,7 +117,7 @@ pub struct ArrayLiteral {
 
 impl fmt::Display for ArrayLiteral {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let elements: Vec<String> = (&self.elements).into_iter().map(|e| e.to_string()).collect();
+        let elements: Vec<String> = (&self.elements).iter().map(|e| e.to_string()).collect();
         write!(f, "[{}]", elements.join(", "))
     }
 }
@@ -127,7 +130,7 @@ pub struct IndexExpression {
 
 impl fmt::Display for IndexExpression {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "({}[{}])", self.left.to_string(), self.index.to_string())
+        write!(f, "({}[{}])", self.left, self.index)
     }
 }
 
@@ -153,7 +156,7 @@ pub struct FunctionLiteral {
 
 impl fmt::Display for FunctionLiteral {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let param_list: Vec<String> = (&self.parameters).into_iter().map(|p| p.to_string()).collect();
+        let param_list: Vec<String> = (&self.parameters).iter().map(|p| p.to_string()).collect();
         write!(f, "({}) {}", param_list.join(", "), self.body)
     }
 }
@@ -166,8 +169,11 @@ pub struct CallExpression {
 
 impl fmt::Display for CallExpression {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let arg_list: Vec<String> = (&self.arguments).into_iter().map(|exp| exp.to_string()).collect();
-        write!(f, "{}({})", self.function.to_string(), arg_list.join(", "))
+        let arg_list: Vec<String> = (&self.arguments)
+            .iter()
+            .map(|exp| exp.to_string())
+            .collect();
+        write!(f, "{}({})", self.function, arg_list.join(", "))
     }
 }
 
@@ -243,7 +249,7 @@ impl fmt::Display for ReturnStatement {
 
 #[derive(Hash, Eq, PartialEq, Clone, Debug)]
 pub struct ExpressionStatement {
-    pub expression: Expression
+    pub expression: Expression,
 }
 
 impl fmt::Display for ExpressionStatement {
@@ -257,6 +263,12 @@ pub struct Program {
     pub statements: Vec<Statement>,
 }
 
+impl Default for Program {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Program {
     pub fn new() -> Program {
         Program {
@@ -267,7 +279,10 @@ impl Program {
 
 impl fmt::Display for Program {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let statements: Vec<String> = (&self.statements).into_iter().map(|stmt| stmt.to_string()).collect();
+        let statements: Vec<String> = (&self.statements)
+            .iter()
+            .map(|stmt| stmt.to_string())
+            .collect();
         write!(f, "{}", statements.join(""))
     }
 }
@@ -278,13 +293,11 @@ mod test {
 
     #[test]
     fn display() {
-
-        let p = Program{
-            statements: vec![
-                Statement::Let(Box::new(
-                    LetStatement{
-                            name: "asdf".to_string(),
-                            value: Expression::Identifier("bar".to_string())}))],
+        let p = Program {
+            statements: vec![Statement::Let(Box::new(LetStatement {
+                name: "asdf".to_string(),
+                value: Expression::Identifier("bar".to_string()),
+            }))],
         };
 
         let expected = "let asdf = bar;";

src/code.rs

@@ -1,6 +1,4 @@
-use byteorder;
-use std::io::Cursor;
-use self::byteorder::{ByteOrder, BigEndian, WriteBytesExt, ReadBytesExt};
+use byteorder::{BigEndian, ByteOrder, WriteBytesExt};
 
 pub type Instructions = Vec<u8>;
 
@@ -15,12 +13,16 @@ impl InstructionsFns for Instructions {
         let mut i = 0;
 
         while i < self.len() {
-            let op:u8 = *self.get(i).unwrap();
+            let op: u8 = *self.get(i).unwrap();
             let op = unsafe { ::std::mem::transmute(op) };
 
-            let (operands, read) = read_operands(&op, &self[i+1..]);
+            let (operands, read) = read_operands(&op, &self[i + 1..]);
 
-            ret.push_str(&format!("{:04} {}\n", i, Self::fmt_instruction(&op, &operands)));
+            ret.push_str(&format!(
+                "{:04} {}\n",
+                i,
+                Self::fmt_instruction(&op, &operands)
+            ));
             i = i + 1 + read;
         }
 
@@ -31,13 +33,12 @@ impl InstructionsFns for Instructions {
         match op.operand_widths().len() {
             2 => format!("{} {} {}", op.name(), operands[0], operands[1]),
             1 => format!("{} {}", op.name(), operands[0]),
-            0 => format!("{}", op.name()),
-            _ => panic!("unsuported operand width")
+            0 => op.name().to_string(),
+            _ => panic!("unsuported operand width"),
         }
     }
 }
 
-
 #[repr(u8)]
 #[derive(Eq, PartialEq, Debug, Clone)]
 pub enum Op {
@@ -109,13 +110,29 @@ impl Op {
 
     pub fn operand_widths(&self) -> Vec<u8> {
         match self {
-            Op::Constant | Op::JumpNotTruthy | Op::Jump |
-            Op::SetGobal | Op::GetGlobal | Op::Array | Op::Hash => vec![2],
-            Op::Add | Op::Sub | Op::Mul |
-            Op::Div | Op::Pop | Op::True |
-            Op::False | Op::Equal | Op::NotEqual |
-            Op::GreaterThan | Op::Minus | Op::Bang | Op::Null |
-            Op::Index | Op::ReturnValue | Op::Return => vec![],
+            Op::Constant
+            | Op::JumpNotTruthy
+            | Op::Jump
+            | Op::SetGobal
+            | Op::GetGlobal
+            | Op::Array
+            | Op::Hash => vec![2],
+            Op::Add
+            | Op::Sub
+            | Op::Mul
+            | Op::Div
+            | Op::Pop
+            | Op::True
+            | Op::False
+            | Op::Equal
+            | Op::NotEqual
+            | Op::GreaterThan
+            | Op::Minus
+            | Op::Bang
+            | Op::Null
+            | Op::Index
+            | Op::ReturnValue
+            | Op::Return => vec![],
             Op::GetLocal | Op::SetLocal | Op::Call | Op::GetBuiltin | Op::GetFree => vec![1],
             Op::Closure => vec![2, 1],
         }
@@ -127,14 +144,10 @@ pub fn make_instruction(op: Op, operands: &Vec<usize>) -> Vec<u8> {
     let widths = op.operand_widths();
     instruction.push(op as u8);
 
-    for (o, width) in operands.into_iter().zip(widths) {
+    for (o, width) in operands.iter().zip(widths) {
         match width {
-            2 => {
-                instruction.write_u16::<BigEndian>(*o as u16).unwrap()
-            },
-            1 => {
-                instruction.write_u8(*o as u8).unwrap()
-            },
+            2 => instruction.write_u16::<BigEndian>(*o as u16).unwrap(),
+            1 => instruction.write_u8(*o as u8).unwrap(),
             _ => panic!("unsupported operand width {}", width),
         };
     }
@@ -149,14 +162,14 @@ pub fn read_operands(op: &Op, instructions: &[u8]) -> (Vec<usize>, usize) {
     for width in op.operand_widths() {
         match width {
             2 => {
-                operands.push(BigEndian::read_u16(&instructions[offset..offset+2]) as usize);
+                operands.push(BigEndian::read_u16(&instructions[offset..offset + 2]) as usize);
                 offset += 2;
-            },
+            }
             1 => {
                 operands.push(instructions[offset] as usize);
                 offset += 1;
-            },
-            _ => panic!("width not supported for operand")
+            }
+            _ => panic!("width not supported for operand"),
         }
     }
 
@@ -176,10 +189,26 @@ mod test {
         }
 
         let tests = vec![
-            Test{op: Op::Constant, operands: vec![65534], expected: vec![Op::Constant as u8, 255, 254]},
-            Test{op: Op::Add, operands: vec![], expected: vec![Op::Add as u8]},
-            Test{op: Op::GetLocal, operands: vec![255], expected: vec![Op::GetLocal as u8, 255]},
-            Test{op: Op::Call, operands: vec![255], expected: vec![Op::Call as u8, 255]},
+            Test {
+                op: Op::Constant,
+                operands: vec![65534],
+                expected: vec![Op::Constant as u8, 255, 254],
+            },
+            Test {
+                op: Op::Add,
+                operands: vec![],
+                expected: vec![Op::Add as u8],
+            },
+            Test {
+                op: Op::GetLocal,
+                operands: vec![255],
+                expected: vec![Op::GetLocal as u8, 255],
+            },
+            Test {
+                op: Op::Call,
+                operands: vec![255],
+                expected: vec![Op::Call as u8, 255],
+            },
         ];
 
         for t in tests {
@@ -216,8 +245,16 @@ mod test {
         }
 
         let tests = vec![
-            Test{op: Op::Constant, operands: vec![65535], bytes_read: 2},
-            Test{op: Op::GetLocal, operands: vec![255], bytes_read: 1},
+            Test {
+                op: Op::Constant,
+                operands: vec![65535],
+                bytes_read: 2,
+            },
+            Test {
+                op: Op::GetLocal,
+                operands: vec![255],
+                bytes_read: 1,
+            },
         ];
 
         for t in tests {
@@ -228,4 +265,4 @@ mod test {
             assert_eq!(operands_read, t.operands);
         }
     }
-}
+}