Merge pull request #260 from calcit-lang/rust2024

try rust 2024 with some fixes

Author: NoEgAm

Cargo.toml

@@ -2,7 +2,7 @@
 name = "calcit"
 version = "0.9.8"
 authors = ["jiyinyiyong <jiyinyiyong@gmail.com>"]
-edition = "2021"
+edition = "2024"
 license = "MIT"
 description = "Interpreter and js codegen for Calcit"
 homepage = "http://calcit-lang.org"

rust-toolchain.toml

@@ -1,3 +1,3 @@
 
 [toolchain]
-channel = "stable"
+channel = "1.85.0"

src/bin/injection/mod.rs

@@ -268,7 +268,7 @@ pub fn blocking_dylib_edn_fn(xs: Vec<Calcit>, call_stack: &CallStackList) -> Res
 }
 
 /// need to put it here since the crate does not compile for dylib
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn on_ctrl_c(xs: Vec<Calcit>, call_stack: &CallStackList) -> Result<Calcit, CalcitErr> {
   if xs.len() == 1 {
     let cb = Arc::new(xs[0].to_owned());

src/builtins/lists.rs

@@ -278,14 +278,14 @@ pub fn foldl_shortcut(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calci
                   format!("return value in foldl-shortcut should be a bool, got: {a}"),
                   call_stack,
                   a.get_location(),
-                ))
+                ));
               }
             },
             _ => {
               return Err(CalcitErr::use_msg_stack(
                 format!("return value for foldl-shortcut should be `:: bool acc`, got: {pair}"),
                 call_stack,
-              ))
+              ));
             }
           }
         }
@@ -315,14 +315,14 @@ pub fn foldl_shortcut(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calci
                   format!("return value in foldl-shortcut should be a bool, got: {a}"),
                   call_stack,
                   a.get_location(),
-                ))
+                ));
               }
             },
             _ => {
               return Err(CalcitErr::use_msg_stack(
                 format!("return value for foldl-shortcut should be `:: bool acc`, got: {pair}"),
                 call_stack,
-              ))
+              ));
             }
           }
         }
@@ -356,14 +356,14 @@ pub fn foldl_shortcut(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calci
                   format!("return value in foldl-shortcut should be a bool, got: {a}"),
                   call_stack,
                   a.get_location(),
-                ))
+                ));
               }
             },
             _ => {
               return Err(CalcitErr::use_msg_stack(
                 format!("return value for foldl-shortcut should be `:: bool acc`, got: {pair}"),
                 call_stack,
-              ))
+              ));
             }
           }
         }
@@ -420,14 +420,14 @@ pub fn foldr_shortcut(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calci
                   format!("return value in foldr-shortcut should be a bool, got: {a}"),
                   call_stack,
                   a.get_location(),
-                ))
+                ));
               }
             },
             _ => {
               return Err(CalcitErr::use_msg_stack(
                 format!("return value for foldr-shortcut should be `:: bool acc`, got: {pair}"),
                 call_stack,
-              ))
+              ));
             }
           }
         }
@@ -464,8 +464,8 @@ pub fn sort(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calcit, CalcitE
           let v = runner::run_fn(&[(*a).to_owned(), (*b).to_owned()], info, call_stack);
           match v {
             Ok(Calcit::Number(x)) if x < 0.0 => Ordering::Less,
-            Ok(Calcit::Number(x)) if x == 0.0 => Ordering::Equal,
             Ok(Calcit::Number(x)) if x > 0.0 => Ordering::Greater,
+            Ok(Calcit::Number(_)) => Ordering::Equal,
             Ok(a) => {
               eprintln!("expected number from sort comparator, got: {a}");
               panic!("failed to sort")
@@ -491,8 +491,8 @@ pub fn sort(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calcit, CalcitE
           let v = builtins::handle_proc(*proc, &[(*a).to_owned(), (*b).to_owned()], call_stack);
           match v {
             Ok(Calcit::Number(x)) if x < 0.0 => Ordering::Less,
-            Ok(Calcit::Number(x)) if x == 0.0 => Ordering::Equal,
             Ok(Calcit::Number(x)) if x > 0.0 => Ordering::Greater,
+            Ok(Calcit::Number(_)) => Ordering::Equal,
             Ok(a) => {
               eprintln!("expected number from sort comparator, got: {a}");
               panic!("failed to sort")

src/codegen/emit_js/internal_states.rs

@@ -5,12 +5,13 @@ use std::collections::{HashMap, HashSet};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, LazyLock, RwLock};
 
+type ProgramCache = HashMap<Arc<str>, HashSet<Arc<str>>>;
+
 // track if it's the first compilation
 static FIRST_COMPILATION: AtomicBool = AtomicBool::new(true);
 
 // caches program data for detecting incremental changes of libs
-static GLOBAL_PREVIOUS_PROGRAM_CACHES: LazyLock<RwLock<HashMap<Arc<str>, HashSet<Arc<str>>>>> =
-  LazyLock::new(|| RwLock::new(HashMap::new()));
+static GLOBAL_PREVIOUS_PROGRAM_CACHES: LazyLock<RwLock<ProgramCache>> = LazyLock::new(|| RwLock::new(HashMap::new()));
 
 pub fn lookup_prev_ns_cache(ns: &str) -> Option<HashSet<Arc<str>>> {
   let previous_program_caches = &GLOBAL_PREVIOUS_PROGRAM_CACHES.read().expect("load cache");

src/runner/preprocess.rs

@@ -2,7 +2,7 @@ use crate::{
   builtins::{is_js_syntax_procs, is_proc_name, is_registered_proc},
   calcit::{
     self, Calcit, CalcitArgLabel, CalcitErr, CalcitFnArgs, CalcitImport, CalcitList, CalcitLocal, CalcitProc, CalcitScope,
-    CalcitSymbolInfo, CalcitSyntax, CalcitThunk, CalcitThunkInfo, ImportInfo, LocatedWarning, NodeLocation, RawCodeType, GENERATED_DEF,
+    CalcitSymbolInfo, CalcitSyntax, CalcitThunk, CalcitThunkInfo, GENERATED_DEF, ImportInfo, LocatedWarning, NodeLocation, RawCodeType,
   },
   call_stack::{CallStackList, StackKind},
   codegen, program, runner,
@@ -43,10 +43,7 @@ pub fn preprocess_ns_def(
           let resolved_code = preprocess_expr(&code, &HashSet::new(), ns, check_warnings, &next_stack)?;
           // println!("\n resolve code to run: {:?}", resolved_code);
           let v = if is_fn_or_macro(&resolved_code) {
-            match runner::evaluate_expr(&resolved_code, &CalcitScope::default(), ns, &next_stack) {
-              Ok(ret) => ret,
-              Err(e) => return Err(e),
-            }
+            runner::evaluate_expr(&resolved_code, &CalcitScope::default(), ns, &next_stack)?
           } else {
             Calcit::Thunk(CalcitThunk::Code {
               code: Arc::new(resolved_code),
@@ -832,27 +829,27 @@ pub fn preprocess_core_let(
           format!("invalid pair for &let binding: {a} {b}"),
           call_stack,
           a.get_location().or_else(|| b.get_location()),
-        ))
+        ));
       }
     },
     Some(a @ Calcit::List(_)) => {
       return Err(CalcitErr::use_msg_stack(
         format!("expected binding of a pair, got: {a}"),
         call_stack,
-      ))
+      ));
     }
     Some(a) => {
       return Err(CalcitErr::use_msg_stack_location(
         format!("expected binding of a pair, got: {a}"),
         call_stack,
         a.get_location(),
-      ))
+      ));
     }
     None => {
       return Err(CalcitErr::use_msg_stack(
         "expected binding of a pair, got nothing".to_owned(),
         call_stack,
-      ))
+      ));
     }
   };
   xs.push(binding);