fix rust warnings

  - jit.rs: 5 function_casts_as_integer warnings — added as *const () intermediate cast
  - vm.rs: 3 non_fmt_panics warnings — changed "msg {var}" to "msg {}", var format
  - compiler.rs: Restored truncated file ending (missing closing braces for test_enum_in_struct and mod tests)

Author: wtholliday

src/compiler.rs

@@ -63,8 +63,10 @@ fn builtin_decls() -> Vec<Decl> {
 
     // Math builtins: unary, overloaded for f32 and f64.
     let unary_math = [
-        "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh",
-        "atanh", "ln", "exp", "exp2", "log10", "log2", "sqrt", "abs", "floor", "ceil",
+        "sin", "cos", "tan", "asin", "acos", "atan",
+        "sinh", "cosh", "tanh", "asinh", "acosh", "atanh",
+        "ln", "exp", "exp2", "log10", "log2",
+        "sqrt", "abs", "floor", "ceil",
     ];
     for name in unary_math {
         for (ty, ret_ty) in [
@@ -173,8 +175,9 @@ fn rewrite_qualified_enums(arena: &mut ExprArena, decls: &DeclTable) {
         if let Expr::Field(lhs, case_name) = arena.exprs[i].clone() {
             if let Expr::Id(id_name) = &arena.exprs[lhs] {
                 let found = decls.find(*id_name);
-                if let Some(Decl::Enum { cases, .. }) =
-                    found.iter().find(|d| matches!(d, Decl::Enum { .. }))
+                if let Some(Decl::Enum { cases, .. }) = found
+                    .iter()
+                    .find(|d| matches!(d, Decl::Enum { .. }))
                 {
                     if cases.contains(&case_name) {
                         arena.exprs[i] = Expr::Enum(case_name);

src/jit.rs

@@ -518,7 +518,7 @@ impl<'a> FunctionTranslator<'a> {
 
         self.builder.switch_to_block(cancel_block);
         self.builder.seal_block(cancel_block);
-        let fn_ptr = self.builder.ins().iconst(I64, lyte_abort as usize as i64);
+        let fn_ptr = self.builder.ins().iconst(I64, lyte_abort as *const () as usize as i64);
         let mut sig = self.module.make_signature();
         sig.params.push(AbiParam::new(I64)); // globals_base
         let sref = self.builder.import_signature(sig);
@@ -1688,7 +1688,7 @@ impl<'a> FunctionTranslator<'a> {
     }
 
     fn debug_print_i64(&mut self, value: Value) {
-        let f_ptr = self.builder.ins().iconst(I64, lyte_print_i64 as i64);
+        let f_ptr = self.builder.ins().iconst(I64, lyte_print_i64 as *const () as i64);
 
         let mut sig = Signature::new(CallConv::Fast);
         sig.params = vec![AbiParam::new(I64)];
@@ -1699,15 +1699,15 @@ impl<'a> FunctionTranslator<'a> {
 
     fn translate_func(&mut self, name: &Name, ty: &crate::Type) -> Value {
         if *name == Name::str("assert") {
-            return self.builder.ins().iconst(I64, lyte_assert as i64);
+            return self.builder.ins().iconst(I64, lyte_assert as *const () as i64);
         }
 
         if *name == Name::str("print") {
-            return self.builder.ins().iconst(I64, lyte_print_i32 as i64);
+            return self.builder.ins().iconst(I64, lyte_print_i32 as *const () as i64);
         }
 
         if *name == Name::str("putc") {
-            return self.builder.ins().iconst(I64, lyte_putc as i64);
+            return self.builder.ins().iconst(I64, lyte_putc as *const () as i64);
         }
 
         if let Some(ptr) = math_builtin_ptr(name) {

src/vm.rs

@@ -505,7 +505,7 @@ impl LinkedProgram {
                 args_start,
                 arg_count,
             } => {
-                assert!(func <= 255, "Call func index {func} out of u8 range");
+                assert!(func <= 255, "Call func index {} out of u8 range", func);
                 PackedOp::abc(tags::CALL, args_start, arg_count, func as u8)
             }
             Opcode::CallIndirect {
@@ -519,7 +519,7 @@ impl LinkedProgram {
             Opcode::AllocLocals { size } => {
                 assert!(
                     size <= u16::MAX as u32,
-                    "AllocLocals size {size} out of u16 range"
+                    "AllocLocals size {} out of u16 range", size
                 );
                 PackedOp::ad(tags::ALLOC_LOCALS, 0, size as u16 as i16)
             }
@@ -535,7 +535,7 @@ impl LinkedProgram {
             Opcode::MemZero { dst, size } => {
                 assert!(
                     size <= u16::MAX as u32,
-                    "MemZero size {size} out of u16 range"
+                    "MemZero size {} out of u16 range", size
                 );
                 PackedOp::ad(tags::MEM_ZERO, dst, size as u16 as i16)
             }