RustPython
diff --git a/‎jit/src/instructions.rs‎
Lines changed: 2 additions & 2 deletions b/‎jit/src/instructions.rs‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎jit/src/lib.rs‎
Lines changed: 4 additions & 3 deletions b/‎jit/src/lib.rs‎
Lines changed: 4 additions & 3 deletions
diff --git a/‎jit/tests/bool_tests.rs‎
Lines changed: 0 additions & 1 deletion b/‎jit/tests/bool_tests.rs‎
Lines changed: 0 additions & 1 deletion
@@ -159,7 +159,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 });
                 Ok(())
             }
-            _ => Err(JitCompileError::NotSupported)
+            _ => Err(JitCompileError::NotSupported),
         }
     }
 
@@ -223,7 +223,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.store_variable(name.clone(), val)
             }
-            Instruction::LoadConst { value } => { self.load_const(value) }
+            Instruction::LoadConst { value } => self.load_const(value),
             Instruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 if let Some(ref ty) = self.sig.ret {
 
@@ -250,15 +250,16 @@ impl TryFrom<AbiValue> for bool {
     fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
         match value {
             AbiValue::Bool(b) => Ok(b),
-            _ => Err(())
+            _ => Err(()),
         }
     }
 }
 
 fn type_check(ty: &JitType, val: &AbiValue) -> Result<(), JitArgumentError> {
     match (ty, val) {
-        (JitType::Int, AbiValue::Int(_)) | (JitType::Float, AbiValue::Float(_)) |
-        (JitType::Bool, AbiValue::Bool(_)) => Ok(()),
+        (JitType::Int, AbiValue::Int(_))
+        | (JitType::Float, AbiValue::Float(_))
+        | (JitType::Bool, AbiValue::Bool(_)) => Ok(()),
         _ => Err(JitArgumentError::ArgumentTypeMismatch),
     }
 }
 
@@ -50,4 +50,3 @@ fn test_if_not() {
     assert_eq!(if_not(true), Ok(1));
     assert_eq!(if_not(false), Ok(0));
 }
-
Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {`
`159`	`159`	`});`
`160`	`160`	`Ok(())`
`161`	`161`	`}`
`162`		`- _ => Err(JitCompileError::NotSupported)`
	`162`	`+ _ => Err(JitCompileError::NotSupported),`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`@@ -223,7 +223,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {`
`223`	`223`	`let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;`
`224`	`224`	`self.store_variable(name.clone(), val)`
`225`	`225`	`}`
`226`		`- Instruction::LoadConst { value } => { self.load_const(value) }`
	`226`	`+ Instruction::LoadConst { value } => self.load_const(value),`
`227`	`227`	`Instruction::ReturnValue => {`
`228`	`228`	`let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;`
`229`	`229`	`if let Some(ref ty) = self.sig.ret {`
Original file line number	Diff line number	Diff line change
`@@ -250,15 +250,16 @@ impl TryFrom<AbiValue> for bool {`
`250`	`250`	`fn try_from(value: AbiValue) -> Result<Self, Self::Error> {`
`251`	`251`	`match value {`
`252`	`252`	`AbiValue::Bool(b) => Ok(b),`
`253`		`- _ => Err(())`
	`253`	`+ _ => Err(()),`
`254`	`254`	`}`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`fn type_check(ty: &JitType, val: &AbiValue) -> Result<(), JitArgumentError> {`
`259`	`259`	`match (ty, val) {`
`260`		`- (JitType::Int, AbiValue::Int(_)) \| (JitType::Float, AbiValue::Float(_)) \|`
`261`		`- (JitType::Bool, AbiValue::Bool(_)) => Ok(()),`
	`260`	`+ (JitType::Int, AbiValue::Int(_))`
	`261`	`+ \| (JitType::Float, AbiValue::Float(_))`
	`262`	`+ \| (JitType::Bool, AbiValue::Bool(_)) => Ok(()),`
`262`	`263`	`_ => Err(JitArgumentError::ArgumentTypeMismatch),`
`263`	`264`	`}`
`264`	`265`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,4 +50,3 @@ fn test_if_not() {`
`50`	`50`	`assert_eq!(if_not(true), Ok(1));`
`51`	`51`	`assert_eq!(if_not(false), Ok(0));`
`52`	`52`	`}`
`53`		`-`