Chore: Run Clippy

Author: lucidLuckylee

src/analyzer.rs

@@ -31,6 +31,12 @@ pub struct StackAnalyzer {
     last_constant: Option<i64>,
 }
 
+impl Default for StackAnalyzer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl StackAnalyzer {
     pub fn new() -> Self {
         StackAnalyzer {
@@ -60,7 +66,7 @@ impl StackAnalyzer {
                     self.handle_sub_script(called_script.get_stack());
                 }
                 Block::Script(block_script) => {
-                    for instruct in block_script.instructions().into_iter() {
+                    for instruct in block_script.instructions() {
                         match instruct {
                             Err(err) => {
                                 panic!("instruction extract fail from script {}", err);
@@ -82,16 +88,13 @@ impl StackAnalyzer {
     }
 
     pub fn handle_push_slice(&mut self, bytes: &PushBytes) {
-        match read_scriptint(bytes.as_bytes()) {
-            Ok(x) => {
-                // if i64(data) < 1000, last_constant is true
-                if x <= 1000 && x >= 0 {
-                    self.last_constant = Some(x);
-                } else {
-                    self.last_constant = None;
-                }
+        if let Ok(x) = read_scriptint(bytes.as_bytes()) {
+            // if i64(data) < 1000, last_constant is true
+            if (0..=1000).contains(&x) {
+                self.last_constant = Some(x);
+            } else {
+                self.last_constant = None;
             }
-            Err(_) => {}
         }
         self.stack_change(Self::plain_stack_status(0, 1));
     }
@@ -161,15 +164,15 @@ impl StackAnalyzer {
             },
             OP_PICK => match self.last_constant {
                 Some(x) => {
-                    self.stack_change(Self::plain_stack_status(-1 * (x + 1 + 1) as i32, 0));
+                    self.stack_change(Self::plain_stack_status(-((x + 1 + 1) as i32), 0));
                 }
                 None => {
                     panic!("need to be handled manually for op_pick")
                 }
             },
             OP_ROLL => match self.last_constant {
                 Some(x) => {
-                    self.stack_change(Self::plain_stack_status(-1 * (x + 1 + 1) as i32, -1));
+                    self.stack_change(Self::plain_stack_status(-((x + 1 + 1) as i32), -1));
                     // for [x2, x1, x0, 2, OP_PICK]
                 }
                 None => {
@@ -220,16 +223,16 @@ impl StackAnalyzer {
         let y = status.altstack_changed.borrow_mut();
 
         *i = min(*i, (*j) + stack_status.deepest_stack_accessed);
-        *j = *j + stack_status.stack_changed;
+        *j += stack_status.stack_changed;
 
         *x = min(*x, (*y) + stack_status.deepest_altstack_accessed);
-        *y = *y + stack_status.altstack_changed;
+        *y += stack_status.altstack_changed;
     }
 
     /// the first return is deepest access to current stack
     /// the second return is the impact for the stack
     fn opcode_stack_table(data: &Opcode) -> StackStatus {
-        let (i, j) = match data.clone() {
+        let (i, j) = match *data {
             OP_PUSHBYTES_0 | OP_PUSHBYTES_1 | OP_PUSHBYTES_2 | OP_PUSHBYTES_3 | OP_PUSHBYTES_4
             | OP_PUSHBYTES_5 | OP_PUSHBYTES_6 | OP_PUSHBYTES_7 | OP_PUSHBYTES_8
             | OP_PUSHBYTES_9 | OP_PUSHBYTES_10 | OP_PUSHBYTES_11 | OP_PUSHBYTES_12
@@ -314,7 +317,7 @@ impl StackAnalyzer {
             }
         };
 
-        let (x, y) = match data.clone() {
+        let (x, y) = match *data {
             OP_FROMALTSTACK => (-1, -1),
             OP_TOALTSTACK => (0, 1),
             _ => (0, 0),

src/builder.rs

@@ -230,9 +230,7 @@ impl StructuredScript {
         let id = calculate_hash(&data);
         self.blocks.push(Block::Call(id));
         // Register script
-        if !self.script_map.contains_key(&id) {
-            self.script_map.insert(id, data);
-        }
+        self.script_map.entry(id).or_insert(data);
         self
     }
 
@@ -400,8 +398,8 @@ impl StructuredScript {
     }
 
     pub fn push_expression<T: Pushable>(self, expression: T) -> StructuredScript {
-        let builder = expression.bitcoin_script_push(self);
-        builder
+        
+        expression.bitcoin_script_push(self)
     }
 }
 

src/chunker.rs

@@ -27,6 +27,12 @@ pub struct UndoInfo {
     num_unclosed_ifs: i32,
 }
 
+impl Default for UndoInfo {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl UndoInfo {
     pub fn new() -> Self {
         Self {
@@ -105,9 +111,9 @@ impl Chunker {
         for chunk in chunks.iter_mut() {
             let status = self.stack_analyze(&mut chunk.scripts);
             // ((-1 * access) as u32, (depth - access) as u32)
-            let stack_input_size = status.deepest_stack_accessed.abs() as usize;
+            let stack_input_size = status.deepest_stack_accessed.unsigned_abs() as usize;
             let stack_output_size = (status.stack_changed - status.deepest_stack_accessed) as usize;
-            let altstack_input_size = status.deepest_altstack_accessed.abs() as usize;
+            let altstack_input_size = status.deepest_altstack_accessed.unsigned_abs() as usize;
             let altstack_output_size =
                 (status.altstack_changed - status.deepest_altstack_accessed) as usize;
             chunk.stats = Some(ChunkStats {
@@ -253,7 +259,7 @@ impl Chunker {
                 for block in builder.blocks.iter().rev() {
                     match block {
                         Block::Call(id) => {
-                            let sub_builder = builder.script_map.get(&id).unwrap();
+                            let sub_builder = builder.script_map.get(id).unwrap();
                             self.call_stack.push(Box::new(sub_builder.clone())); //TODO: Avoid cloning here by
                                                                                  //putting Box<Builder> into
                                                                                  //the script_map

tests/test.rs

@@ -1,4 +1,4 @@
-use bitcoin::opcodes::all::{OP_ADD, OP_ENDIF};
+use bitcoin::opcodes::all::OP_ADD;
 use bitcoin_script::{script, Script};
 
 #[test]
@@ -383,15 +383,15 @@ fn test_is_script_buf() {
         OP_IF
         OP_ENDIF
     };
-    assert_eq!(script.is_script_buf(), true);
-    assert_eq!(script.contains_flow_op(), true);
+    assert!(script.is_script_buf());
+    assert!(script.contains_flow_op());
 }
 
 #[test]
 fn test_is_script_buf_false() {
     let script = script! {
         { script! {OP_ADD} }
     };
-    assert_eq!(script.is_script_buf(), false);
-    assert_eq!(script.contains_flow_op(), false);
+    assert!(!script.is_script_buf());
+    assert!(!script.contains_flow_op());
 }

tests/test_chunker.rs

@@ -1,4 +1,4 @@
-use bitcoin::{opcodes::all::OP_OVER, ScriptBuf};
+use bitcoin::ScriptBuf;
 use bitcoin_script::{script, Chunker};
 
 #[test]