feat: expand stdlib common modules (#6)

* feat: optimize method map get lowering

* feat: expand stdlib common modules

* fix: address stdlib review findings

Author: lollipopkit

Cargo.lock

@@ -7,19 +7,26 @@ members = [
     "stdlib/crates/bytes",
     "stdlib/crates/chan",
     "stdlib/crates/datetime",
+    "stdlib/crates/encoding",
+    "stdlib/crates/env",
+    "stdlib/crates/fs",
+    "stdlib/crates/hash",
+    "stdlib/crates/http",
     "stdlib/crates/io",
     "stdlib/crates/iter",
-    "stdlib/crates/json",
     "stdlib/crates/math",
     "stdlib/crates/net",
     "stdlib/crates/os",
+    "stdlib/crates/path",
+    "stdlib/crates/process",
+    "stdlib/crates/random",
+    "stdlib/crates/regex",
     "stdlib/crates/slice",
     "stdlib/crates/stream",
     "stdlib/crates/string",
     "stdlib/crates/task",
     "stdlib/crates/time",
-    "stdlib/crates/toml",
-    "stdlib/crates/yaml",
+    "stdlib/crates/uuid",
     "lkrt",
     "lsp",
     "tree-sitter-lk",
@@ -40,9 +47,16 @@ serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1"
 serde_yaml = "0"
 toml = "1"
+base64 = "0.22"
+crc32fast = "1"
+hex = "0.4"
 once_cell = "1"
 chrono = "0"
 sanitize-filename = "0"
+rand = "0.9"
+regex = "1"
+sha1 = "0.10"
+sha2 = "0.10"
 tokio = { version = "1", features = [
     "rt-multi-thread",
     "macros",
@@ -57,6 +71,9 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 tempfile = "3"
 llvm-tools = "0.1"
 arcstr = { version = "1", features = ["serde"] }
+ureq = "2"
+url = "2"
+uuid = { version = "1", features = ["v4"] }
 
 [profile.release]
 panic = "abort"

Cargo.toml

@@ -2,8 +2,6 @@
 // Each block measures runtime only and prints: workload|name|checksum=...|elapsed=...ms
 use os;
 use math;
-use map;
-use string;
 
 let seed = os.epoch();
 let workload_filter = os.env.get("LK_WORKLOAD_FILTER", "");
@@ -112,7 +110,7 @@ if should_run("two_sum_map") {
         for i in 1..=two_sum_width {
             let need = target - i;
             let need_key = "n${need}";
-            if map.get(seen, need_key) != nil {
+            if seen.get(need_key) != nil {
                 found += 1;
             }
         }
@@ -201,7 +199,7 @@ if should_run("histogram_group_count") {
         for i in 1..=hist_n {
             let bucket = ((i * 17) + r) % 32;
             let key = "b${bucket}";
-            let prev = map.get(hist, key);
+            let prev = hist.get(key);
             if prev == nil {
                 hist.set(key, 1);
             } else {
@@ -210,7 +208,7 @@ if should_run("histogram_group_count") {
         }
         for b in 0..32 {
             let key = "b${b}";
-            let v = map.get(hist, key);
+            let v = hist.get(key);
             if v != nil {
                 checksum += v * v;
             }
@@ -266,7 +264,7 @@ if should_run("log_parse_filter") {
                 let line = "ts=${r}|tenant=t${i % 13}|status=error|path=/api/v1/orders/${i % 19}";
                 let parsed_len = line.split("|").join("|").len();
                 checksum += parsed_len % 7;
-                let prev = map.get(status_counts, "error");
+                let prev = status_counts.get("error");
                 if prev == nil {
                     status_counts.set("error", 1);
                 } else {
@@ -276,7 +274,7 @@ if should_run("log_parse_filter") {
                 let line = "ts=${r}|tenant=t${i % 13}|status=warn|path=/api/v1/orders/${i % 19}";
                 let parsed_len = line.split("|").join("|").len();
                 checksum += parsed_len % 7;
-                let prev = map.get(status_counts, "warn");
+                let prev = status_counts.get("warn");
                 if prev == nil {
                     status_counts.set("warn", 1);
                 } else {
@@ -286,17 +284,17 @@ if should_run("log_parse_filter") {
                 let line = "ts=${r}|tenant=t${i % 13}|status=${status}|path=/api/v1/orders/${i % 19}";
                 let parsed_len = line.split("|").join("|").len();
                 checksum += parsed_len % 7;
-                let prev = map.get(status_counts, status);
+                let prev = status_counts.get(status);
                 if prev == nil {
                     status_counts.set(status, 1);
                 } else {
                     status_counts.set(status, prev + 1);
                 }
             }
         }
-        let ok_count = map.get(status_counts, "ok");
-        let warn_count = map.get(status_counts, "warn");
-        let error_count = map.get(status_counts, "error");
+        let ok_count = status_counts.get("ok");
+        let warn_count = status_counts.get("warn");
+        let error_count = status_counts.get("error");
         if ok_count != nil { checksum += ok_count; }
         if warn_count != nil { checksum += warn_count * 7; }
         if error_count != nil { checksum += error_count * 31; }
@@ -306,8 +304,8 @@ if should_run("log_parse_filter") {
 }
 
 fn cart_line_total(sku, qty, region, prices, tax_rates) {
-    let price = map.get(prices, sku);
-    let tax = map.get(tax_rates, region);
+    let price = prices.get(sku);
+    let tax = tax_rates.get(region);
     let subtotal = price * qty;
     let discount = 0;
     if qty >= 5 {
@@ -349,15 +347,15 @@ if should_run("route_permission_check") {
     let role_levels = {"guest": 0, "user": 10, "analyst": 40, "ops": 70, "admin": 100};
     for i in 1..=route_rounds {
         if ((i % 11) == 0) {
-            checksum += (i % 97) + map.get(role_levels, "admin") + "/admin/users".len();
+            checksum += (i % 97) + role_levels.get("admin") + "/admin/users".len();
         } else if ((i % 7) == 0) {
-            checksum += (i % 97) + map.get(role_levels, "ops") + "DELETE".len();
+            checksum += (i % 97) + role_levels.get("ops") + "DELETE".len();
         } else if ((i % 5) == 0) {
-            checksum += (i % 97) + map.get(role_levels, "analyst") + "/reports/daily".len();
+            checksum += (i % 97) + role_levels.get("analyst") + "/reports/daily".len();
         } else if ((i % 2) == 0) {
-            checksum += (i % 97) + map.get(role_levels, "user") + "/api/orders".len();
+            checksum += (i % 97) + role_levels.get("user") + "/api/orders".len();
         } else {
-            checksum += 3 + map.get(role_levels, "guest");
+            checksum += 3 + role_levels.get("guest");
         }
     }
     t1 = os.clock();
@@ -373,7 +371,7 @@ if should_run("inventory_reorder") {
         let reorder = [];
         for i in 1..=64 {
             let sku = "sku-${i % 23}";
-            let current = map.get(stock, sku);
+            let current = stock.get(sku);
             let delta = ((i * 11) + r) % 37;
             if current == nil {
                 stock.set(sku, delta);
@@ -383,7 +381,7 @@ if should_run("inventory_reorder") {
         }
         for i in 0..23 {
             let sku = "sku-${i}";
-            let available = map.get(stock, sku);
+            let available = stock.get(sku);
             if available == nil {
                 available = 0;
             }
@@ -408,7 +406,7 @@ fn fraud_score(amount, country, device, prior_declines, risky_countries) {
     } else if amount > 400 {
         score += 15;
     }
-    if map.get(risky_countries, country) != nil {
+    if risky_countries.get(country) != nil {
         score += 35;
     }
     if device.starts_with("emu") {
@@ -511,9 +509,9 @@ if should_run("event_join_by_id") {
         }
         for e in 0..event_n {
             let uid = "u${(e * 7 + r) % user_n}";
-            let quota = map.get(user_quotas, uid);
+            let quota = user_quotas.get(uid);
             if quota != nil {
-                let plan = map.get(user_plans, uid);
+                let plan = user_plans.get(uid);
                 checksum += quota % 31;
                 if plan == 3 {
                     checksum += 41;
@@ -539,13 +537,13 @@ if should_run("config_defaults_merge") {
         if ((i % 3) == 0) { config.set("timeout", 30 + (i % 17)); }
         if ((i % 5) == 0) { config.set("region", 2); }
         if ((i % 7) == 0) { config.set("mode", 2); }
-        let retries = map.get(config, "retries");
+        let retries = config.get("retries");
         if retries == nil { retries = 3; }
-        let timeout = map.get(config, "timeout");
+        let timeout = config.get("timeout");
         if timeout == nil { timeout = 25; }
-        let region = map.get(config, "region");
+        let region = config.get("region");
         if region == nil { region = 1; }
-        let mode = map.get(config, "mode");
+        let mode = config.get("mode");
         if mode == nil { mode = 1; }
         checksum += retries * 13 + timeout;
         if region == 2 { checksum += 17; } else { checksum += 5; }

bench/workloads_business_algorithms.lk

@@ -58,6 +58,9 @@ impl Compiler {
                 let callee = self.lower_readonly_operand(callee)?;
                 return self.lower_call_window_boxes(callee, args);
             }
+            if let Some((target, key)) = map_get_method_call_args(callee, args) {
+                return self.lower_map_get_method_call(target, key);
+            }
             return self.lower_builtin_method_call(target, method, args);
         }
         let callee = self.lower_readonly_operand(callee)?;
@@ -90,18 +93,32 @@ impl Compiler {
         Ok(dst)
     }
 
+    fn lower_map_get_method_call(&mut self, target: &Expr, key: &Expr) -> Result<u16> {
+        let dst = self.alloc_reg();
+        self.lower_map_get_expr_to_register(dst, target, key)?;
+        Ok(dst)
+    }
+
     pub(super) fn lower_map_get_function_call_to_register(&mut self, dst: u16, args: &[Box<Expr>]) -> Result<()> {
         if args.len() != 2 {
             bail!("Compiler map.get expects 2 args, got {}", args.len());
         }
-        if let Some(value) = self.lower_const_map_get(&args[0], &args[1])? {
+        self.lower_map_get_expr_to_register(dst, &args[0], &args[1])
+    }
+
+    pub(super) fn lower_map_get_method_call_to_register(&mut self, dst: u16, target: &Expr, key: &Expr) -> Result<()> {
+        self.lower_map_get_expr_to_register(dst, target, key)
+    }
+
+    fn lower_map_get_expr_to_register(&mut self, dst: u16, target_expr: &Expr, key_expr: &Expr) -> Result<()> {
+        if let Some(value) = self.lower_const_map_get(target_expr, key_expr)? {
             let move_source = !self.is_current_local_slot(value);
             self.emit_move_with_policy(dst, value, "map.get const value", move_source)?;
             return Ok(());
         }
-        let target = self.lower_readonly_index_operand(&args[0])?;
+        let target = self.lower_readonly_index_operand(target_expr)?;
         let index_fact = index_fact_from_target(&self.function.performance, target);
-        if let Some((suffix, key_fact)) = self.try_lower_string_int_key_for_map(index_fact, &args[1])? {
+        if let Some((suffix, key_fact)) = self.try_lower_string_int_key_for_map(index_fact, key_expr)? {
             let pc = self.function.code.len();
             self.emit(Instr::abc(
                 Opcode::GetIndexStrI,
@@ -116,7 +133,7 @@ impl Compiler {
             }
             return Ok(());
         }
-        let (key, key_fact) = self.lower_readonly_index_key_for_target(target, index_fact, &args[1])?;
+        let (key, key_fact) = self.lower_readonly_index_key_for_target(target, index_fact, key_expr)?;
         let pc = self.function.code.len();
         if let Some(const_key) = get_field_key(index_fact, key_fact) {
             self.emit(Instr::abc(
@@ -992,6 +1009,19 @@ fn method_name(expr: &Expr) -> Option<&str> {
     }
 }
 
+pub(super) fn map_get_method_call_args<'a>(callee: &'a Expr, args: &'a [Box<Expr>]) -> Option<(&'a Expr, &'a Expr)> {
+    if args.len() != 1 {
+        return None;
+    }
+    let Expr::Access(target, method) = callee else {
+        return None;
+    };
+    if method_name(method) != Some("get") {
+        return None;
+    }
+    Some((target.as_ref(), args[0].as_ref()))
+}
+
 fn literal_string_text(expr: &Expr) -> Option<&str> {
     match expr {
         Expr::Paren(inner) => literal_string_text(inner),

core/src/vm/compiler/call.rs

@@ -11,7 +11,9 @@ use crate::{
 };
 
 use super::{
-    Compiler, checked_u8,
+    Compiler,
+    call::map_get_method_call_args,
+    checked_u8,
     inline::{inline_body_is_supported, stmt_contains_call_to},
     support::{FunctionInlineBody, const_runtime_map_key_from_literal},
 };
@@ -934,30 +936,40 @@ fn const_map_get_scalar_loop_key(
     expr: &Expr,
     const_maps: &HashMap<String, FastHashMap<RuntimeMapKey, ConstRuntimeValue>>,
 ) -> Result<Option<ScalarLoopConstKey>> {
-    let Expr::CallExpr(callee, args) = expr else {
+    let Some((target, key)) = const_map_get_target_and_key(expr) else {
         return Ok(None);
     };
-    if args.len() != 2 {
-        return Ok(None);
-    }
-    let Expr::Access(target, method) = callee.as_ref() else {
-        return Ok(None);
-    };
-    if !matches!(target.as_ref(), Expr::Var(name) if name == "map") || method_name(method) != Some("get") {
-        return Ok(None);
-    }
-    let Some(target_name) = super::support::simple_local_expr_name(&args[0]) else {
+    let Some(target_name) = super::support::simple_local_expr_name(target) else {
         return Ok(None);
     };
     let Some(map) = const_maps.get(target_name) else {
         return Ok(None);
     };
-    let Some(key) = const_map_key_from_expr(&args[1])? else {
+    let Some(key) = const_map_key_from_expr(key)? else {
         return Ok(None);
     };
     Ok(map.get(&key).and_then(const_runtime_scalar_loop_key))
 }
 
+fn const_map_get_target_and_key(expr: &Expr) -> Option<(&Expr, &Expr)> {
+    let Expr::CallExpr(callee, args) = expr else {
+        return None;
+    };
+    if let Some((target, key)) = map_get_method_call_args(callee, args) {
+        return Some((target, key));
+    }
+    if args.len() != 2 {
+        return None;
+    }
+    let Expr::Access(target, method) = callee.as_ref() else {
+        return None;
+    };
+    if !matches!(target.as_ref(), Expr::Var(name) if name == "map") || method_name(method) != Some("get") {
+        return None;
+    }
+    Some((args[0].as_ref(), args[1].as_ref()))
+}
+
 fn const_map_key_from_expr(expr: &Expr) -> Result<Option<RuntimeMapKey>> {
     match expr {
         Expr::Paren(inner) => const_map_key_from_expr(inner),