diff options
126 files changed, 1219 insertions, 1219 deletions
@@ -148,17 +148,17 @@ Values that exist only at compile-time (folded into code). Use these for array s ```zc def MAX_SIZE = 1024; -var buffer: char[MAX_SIZE]; // Valid array size +let buffer: char[MAX_SIZE]; // Valid array size ``` -#### Variables (`var`) +#### Variables (`let`) Storage locations in memory. Can be mutable or read-only (`const`). ```zc -var x = 10; // Mutable +let x = 10; // Mutable x = 20; // OK -var y: const int = 10; // Read-only (Type qualified) +let y: const int = 10; // Read-only (Type qualified) // y = 20; // Error: cannot assign to const ``` @@ -183,16 +183,16 @@ var y: const int = 10; // Read-only (Type qualified) Fixed-size arrays with value semantics. ```zc def SIZE = 5; -var ints: int[SIZE] = {1, 2, 3, 4, 5}; -var zeros: [int; SIZE]; // Zero-initialized +let ints: int[SIZE] = {1, 2, 3, 4, 5}; +let zeros: [int; SIZE]; // Zero-initialized ``` #### Tuples Group multiple values together, access elements by index. ```zc -var pair = (1, "Hello"); -var x = pair.0; // 1 -var s = pair.1; // "Hello" +let pair = (1, "Hello"); +let x = pair.0; // 1 +let s = pair.1; // "Hello" ``` **Multiple Return Values** @@ -203,16 +203,16 @@ fn add_and_subtract(a: int, b: int) -> (int, int) { return (a + b, a - b); } -var result = add_and_subtract(3, 2); -var sum = result.0; // 5 -var diff = result.1; // 1 +let result = add_and_subtract(3, 2); +let sum = result.0; // 5 +let diff = result.1; // 1 ``` **Destructuring** Tuples can be destructured directly into variables: ```zc -var (sum, diff) = add_and_subtract(3, 2); +let (sum, diff) = add_and_subtract(3, 2); // sum = 5, diff = 1 ``` @@ -225,7 +225,7 @@ struct Point { } // Struct initialization -var p = Point { x: 10, y: 20 }; +let p = Point { x: 10, y: 20 }; // Bitfields struct Flags { @@ -315,9 +315,9 @@ fn main() { #### Lambdas (Closures) Anonymous functions that can capture their environment. ```zc -var factor = 2; -var double = x -> x * factor; // Arrow syntax -var full = fn(x: int) -> int { return x * factor; }; // Block syntax +let factor = 2; +let double = x -> x * factor; // Arrow syntax +let full = fn(x: int) -> int { return x * factor; }; // Block syntax ``` #### Raw Function Pointers @@ -335,14 +335,14 @@ fn get_callback() -> fn*(int) { } // Pointers to function pointers are supported (fn**) -var pptr: fn**(int) = &ptr; +let pptr: fn**(int) = &ptr; ``` #### Variadic Functions Functions can accept a variable number of arguments using `...` and the `va_list` type. ```zc fn log(lvl: int, fmt: char*, ...) { - var ap: va_list; + let ap: va_list; va_start(ap, fmt); vprintf(fmt, ap); // Use C stdio va_end(ap); @@ -362,7 +362,7 @@ if x > 10 { } // Ternary -var y = x > 10 ? 1 : 0; +let y = x > 10 ? 1 : 0; ``` #### Pattern Matching @@ -391,7 +391,7 @@ match shape { To inspect a value without taking ownership (moving it), use the `ref` keyword in the pattern. This is essential for types that implement Move Semantics (like `Option`, `Result`, non-Copy structs). ```zc -var opt = Some(NonCopyVal{...}); +let opt = Some(NonCopyVal{...}); match opt { Some(ref x) => { // 'x' is a pointer to the value inside 'opt' @@ -461,7 +461,7 @@ impl Point { } } -var p3 = p1 + p2; // Calls p1.add(p2) +let p3 = p1 + p2; // Calls p1.add(p2) ``` #### Syntactic Sugar @@ -504,8 +504,8 @@ Zen C allows you to use string literals directly as statements for quick printin You can embed expressions directly into string literals using `{}` syntax. This works with all printing methods and string shorthands. ```zc -var x = 42; -var name = "Zen"; +let x = 42; +let name = "Zen"; println "Value: {x}, Name: {name}"; "Value: {x}, Name: {name}"; // shorthand println ``` @@ -519,7 +519,7 @@ Zen C supports a shorthand for prompting user input using the `?` prefix. - Format specifiers are automatically inferred based on variable type. ```c -var age: int; +let age: int; ? "How old are you? " (age); println "You are {age} years old."; ``` @@ -531,7 +531,7 @@ Zen C allows manual memory management with ergonomic aids. #### Defer Execute code when the current scope exits. Defer statements are executed in LIFO (last-in, first-out) order. ```zc -var f = fopen("file.txt", "r"); +let f = fopen("file.txt", "r"); defer fclose(f); ``` @@ -540,7 +540,7 @@ defer fclose(f); #### Autofree Automatically free the variable when scope exits. ```zc -autofree var types = malloc(1024); +autofree let types = malloc(1024); ``` #### Resource Semantics (Move by Default) @@ -566,7 +566,7 @@ fn peek(r: Resource*) { ... } // 'r' is borrowed (reference) If you *do* want two copies of a resource, make it explicit: ```zc -var b = a.clone(); // Calls the 'clone' method from the Clone trait +let b = a.clone(); // Calls the 'clone' method from the Clone trait ``` **Opt-in Copy (Value Types)**: @@ -577,8 +577,8 @@ struct Point { x: int; y: int; } impl Copy for Point {} // Opt-in to implicit duplication fn main() { - var p1 = Point { x: 1, y: 2 }; - var p2 = p1; // Copied. p1 stays valid. + let p1 = Point { x: 1, y: 2 }; + let p2 = p1; // Copied. p1 stays valid. } ``` @@ -623,8 +623,8 @@ impl Drawable for Circle { fn draw(self) { ... } } -var circle = Circle{}; -var drawable: Drawable = &circle; +let circle = Circle{}; +let drawable: Drawable = &circle; ``` #### Standard Traits @@ -699,8 +699,8 @@ Marker trait to opt-in to `Copy` behavior (implicit duplication) instead of Move struct Point { x: int; y: int; } fn main() { - var p1 = Point{x: 1, y: 2}; - var p2 = p1; // Copied! p1 remains valid. + let p1 = Point{x: 1, y: 2}; + let p2 = p1; // Copied! p1 remains valid. } ``` @@ -720,8 +720,8 @@ impl Clone for MyBox { } fn main() { - var b1 = MyBox{val: 42}; - var b2 = b1.clone(); // Explicit copy + let b1 = MyBox{val: 42}; + let b2 = b1.clone(); // Explicit copy } ``` @@ -777,8 +777,8 @@ async fn fetch_data() -> string { } fn main() { - var future = fetch_data(); - var result = await future; + let future = fetch_data(); + let result = await future; } ``` @@ -789,7 +789,7 @@ Run code at compile-time to generate source or print messages. ```zc comptime { // Generate code at compile-time (written to stdout) - println "var build_date = \"2024-01-01\";"; + println "let build_date = \"2024-01-01\";"; } println "Build Date: {build_date}"; @@ -799,19 +799,19 @@ println "Build Date: {build_date}"; Embed files as specified types. ```zc // Default (Slice_char) -var data = embed "assets/logo.png"; +let data = embed "assets/logo.png"; // Typed Embed -var text = embed "shader.glsl" as string; // Embbed as C-string -var rom = embed "bios.bin" as u8[1024]; // Embed as fixed array -var wav = embed "sound.wav" as u8[]; // Embed as Slice_u8 +let text = embed "shader.glsl" as string; // Embbed as C-string +let rom = embed "bios.bin" as u8[1024]; // Embed as fixed array +let wav = embed "sound.wav" as u8[]; // Embed as Slice_u8 ``` #### Plugins Import compiler plugins to extend syntax. ```zc import plugin "regex" -var re = regex! { ^[a-z]+$ }; +let re = regex! { ^[a-z]+$ }; ``` #### Generic C Macros @@ -876,11 +876,11 @@ asm volatile { Zen C simplifies the complex GCC constraint syntax with named bindings. ```zc -// Syntax: : out(var) : in(var) : clobber(reg) -// Uses {var} placeholder syntax for readability +// Syntax: : out(variable) : in(variable) : clobber(reg) +// Uses {variable} placeholder syntax for readability fn add(a: int, b: int) -> int { - var result: int; + let result: int; asm { "add {result}, {a}, {b}" : out(result) @@ -893,8 +893,8 @@ fn add(a: int, b: int) -> int { | Type | Syntax | GCC Equivalent | |:---|:---|:---| -| **Output** | `: out(var)` | `"=r"(var)` | -| **Input** | `: in(var)` | `"r"(var)` | +| **Output** | `: out(variable)` | `"=r"(variable)` | +| **Input** | `: in(variable)` | `"r"(variable)` | | **Clobber** | `: clobber("rax")` | `"rax"` | | **Memory** | `: clobber("memory")` | `"memory"` | @@ -1080,7 +1080,7 @@ raw { } fn main() { - var v = make_vec(1, 2); + let v = make_vec(1, 2); raw { std::cout << "Size: " << v.size() << std::endl; } } ``` @@ -1132,7 +1132,7 @@ import "std/cuda.zc" @global fn add_kernel(a: float*, b: float*, c: float*, n: int) { - var i = thread_id(); + let i = thread_id(); if i < n { c[i] = a[i] + b[i]; } @@ -1140,9 +1140,9 @@ fn add_kernel(a: float*, b: float*, c: float*, n: int) { fn main() { const N = 1024; - var d_a = cuda_alloc<float>(N); - var d_b = cuda_alloc<float>(N); - var d_c = cuda_alloc<float>(N); + let d_a = cuda_alloc<float>(N); + let d_b = cuda_alloc<float>(N); + let d_c = cuda_alloc<float>(N); defer cuda_free(d_a); defer cuda_free(d_b); defer cuda_free(d_c); @@ -1165,7 +1165,7 @@ Zen C provides a standard library for common CUDA operations to reduce `raw` blo import "std/cuda.zc" // Memory management -var d_ptr = cuda_alloc<float>(1024); +let d_ptr = cuda_alloc<float>(1024); cuda_copy_to_device(d_ptr, h_ptr, 1024 * sizeof(float)); defer cuda_free(d_ptr); @@ -1173,9 +1173,9 @@ defer cuda_free(d_ptr); cuda_sync(); // Thread Indexing (use inside kernels) -var i = thread_id(); // Global index -var bid = block_id(); -var tid = local_id(); +let i = thread_id(); // Global index +let bid = block_id(); +let tid = local_id(); ``` diff --git a/examples/algorithms/binsearch.zc b/examples/algorithms/binsearch.zc index db1a354..bcddef2 100644 --- a/examples/algorithms/binsearch.zc +++ b/examples/algorithms/binsearch.zc @@ -1,11 +1,11 @@ import "std.zc" fn binary_search(arr: int*, size: isize, target: int) -> isize { - var low: isize = 0; - var high: isize = size - 1; + let low: isize = 0; + let high: isize = size - 1; while low <= high { - var mid = low + (high - low) / 2; + let mid = low + (high - low) / 2; if arr[mid] == target { return mid; @@ -29,10 +29,10 @@ fn print_array(arr: int*, size: isize) { } fn main() { - var v = Vec<int>::new(); + let v = Vec<int>::new(); defer v.free(); - var values = [1, 2, 3, 5, 6, 7, 8, 9, 10, 12]; + let values = [1, 2, 3, 5, 6, 7, 8, 9, 10, 12]; for i in 0..10 { v.push(values[i]); } @@ -40,8 +40,8 @@ fn main() { "Array: "..; print_array(v.data, (int)v.len); - var target = 7; - var result = binary_search(v.data, (isize)v.len, target); + let target = 7; + let result = binary_search(v.data, (isize)v.len, target); "Found {target} at index {result}"; } diff --git a/examples/algorithms/dfs.zc b/examples/algorithms/dfs.zc index 054a9d4..2d4670c 100644 --- a/examples/algorithms/dfs.zc +++ b/examples/algorithms/dfs.zc @@ -7,7 +7,7 @@ struct Graph { impl Graph { fn new(vertices: int) -> Graph { - var g = Graph { + let g = Graph { num_vertices: vertices, adj_list: Vec<Vec<int>>::new() }; @@ -32,10 +32,10 @@ impl Graph { visited[vertex] = true; order.push(vertex); - var neighbors = self.adj_list.data[vertex]; - var neighbor_count = (int)neighbors.len; + let neighbors = self.adj_list.data[vertex]; + let neighbor_count = (int)neighbors.len; for i in 0..neighbor_count { - var neighbor = neighbors.data[i]; + let neighbor = neighbors.data[i]; if !visited[neighbor] { self._dfs_recursive(neighbor, visited, order); } @@ -43,12 +43,12 @@ impl Graph { } fn dfs_recursive(self, start: int) -> Vec<int> { - var order = Vec<int>::new(); + let order = Vec<int>::new(); if start < 0 || start >= self.num_vertices { return order; } - var visited = Vec<bool>::new(); + let visited = Vec<bool>::new(); defer visited.free(); for i in 0..self.num_vertices { visited.push(false); @@ -59,23 +59,23 @@ impl Graph { } fn dfs(self, start: int) -> Vec<int> { - var order = Vec<int>::new(); + let order = Vec<int>::new(); if start < 0 || start >= self.num_vertices { return order; } - var visited = Vec<bool>::new(); + let visited = Vec<bool>::new(); defer visited.free(); for i in 0..self.num_vertices { visited.push(false); } - var stack = Vec<int>::new(); + let stack = Vec<int>::new(); defer stack.free(); stack.push(start); while !stack.is_empty() { - var vertex = stack.pop(); + let vertex = stack.pop(); if visited.data[vertex] { continue; } @@ -83,10 +83,10 @@ impl Graph { visited.data[vertex] = true; order.push(vertex); - var neighbors = self.adj_list.data[vertex]; - var i = (int)neighbors.len - 1; + let neighbors = self.adj_list.data[vertex]; + let i = (int)neighbors.len - 1; while i >= 0 { - var neighbor = neighbors.data[i]; + let neighbor = neighbors.data[i]; if !visited.data[neighbor] { stack.push(neighbor); } @@ -106,7 +106,7 @@ impl Graph { } fn main() { - var g = Graph::new(6); + let g = Graph::new(6); defer g.free(); g.add_edge(0, 1); @@ -115,9 +115,9 @@ fn main() { g.add_edge(1, 4); g.add_edge(3, 5); - var order_rec = g.dfs_recursive(0); + let order_rec = g.dfs_recursive(0); defer order_rec.free(); - var order_it = g.dfs(0); + let order_it = g.dfs(0); defer order_it.free(); "DFS recursive order: "..; diff --git a/examples/algorithms/quicksort.zc b/examples/algorithms/quicksort.zc index adef038..53395be 100644 --- a/examples/algorithms/quicksort.zc +++ b/examples/algorithms/quicksort.zc @@ -2,14 +2,14 @@ import "std.zc" fn swap(arr: int*, i: isize, j: isize) { - var temp = arr[i]; + let temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } fn partition(arr: int*, low: isize, high: isize) -> isize { - var pivot = arr[high]; - var i = low - 1; + let pivot = arr[high]; + let i = low - 1; for j in low..high { if arr[j] < pivot { @@ -23,7 +23,7 @@ fn partition(arr: int*, low: isize, high: isize) -> isize { fn quicksort(arr: int*, low: isize, high: isize) { if low < high { - var pi = partition(arr, low, high); + let pi = partition(arr, low, high); quicksort(arr, low, pi - 1); quicksort(arr, pi + 1, high); } @@ -39,10 +39,10 @@ fn print_array(arr: int*, size: isize) { } fn main() { - var v = Vec<int>::new(); + let v = Vec<int>::new(); defer v.free(); - var values = [10, 7, 8, 9, 1, 5, 3, 12, 2, 6]; + let values = [10, 7, 8, 9, 1, 5, 3, 12, 2, 6]; for i in 0..10 { v.push(values[i]); } diff --git a/examples/algorithms/sieve.zc b/examples/algorithms/sieve.zc index 25e2c5a..2f5680e 100644 --- a/examples/algorithms/sieve.zc +++ b/examples/algorithms/sieve.zc @@ -4,7 +4,7 @@ import "std.zc" fn main() { const LIMIT = 50; - var is_prime: bool[LIMIT]; + let is_prime: bool[LIMIT]; for i in 0..LIMIT { is_prime[i] = true; } is_prime[0] = false; @@ -12,7 +12,7 @@ fn main() { for p in 2..LIMIT { if is_prime[p] { - for (var i = p * p; i < LIMIT; i += p) { + for (let i = p * p; i < LIMIT; i += p) { is_prime[i] = false; } } diff --git a/examples/collections/word_freq.zc b/examples/collections/word_freq.zc index 781842c..d025542 100644 --- a/examples/collections/word_freq.zc +++ b/examples/collections/word_freq.zc @@ -2,19 +2,19 @@ import "std/map.zc" fn main() { - var text = "apple banana apple cherry banana apple"; - var delim = " "; + let text = "apple banana apple cherry banana apple"; + let delim = " "; - var counts = Map<int>::new(); + let counts = Map<int>::new(); defer counts.free(); - var temp = strdup(text); + let temp = strdup(text); defer free(temp); - var token = strtok(temp, delim); + let token = strtok(temp, delim); while token != NULL { if counts.contains(token) { - var val = counts.get(token).unwrap(); + let val = counts.get(token).unwrap(); counts.put(token, val + 1); } else { counts.put(token, 1); @@ -27,8 +27,8 @@ fn main() { for i in 0..counts.capacity() { if counts.is_slot_occupied(i) { - var k = counts.key_at(i); - var v = counts.val_at(i); + let k = counts.key_at(i); + let v = counts.val_at(i); println "{k}: {v}"; } } diff --git a/examples/cpp_interop.zc b/examples/cpp_interop.zc index 2f2e033..3db0ea7 100644 --- a/examples/cpp_interop.zc +++ b/examples/cpp_interop.zc @@ -25,8 +25,8 @@ fn main() { cpp_print("Hello from C++!"); - var vec = cpp_make_vector(10, 20, 30); - var result = cpp_sum_vector(vec); + let vec = cpp_make_vector(10, 20, 30); + let result = cpp_sum_vector(vec); "Sum of C++ vector: {result}"; raw { diff --git a/examples/data/json_config.zc b/examples/data/json_config.zc index ccfb1a2..d8604d7 100644 --- a/examples/data/json_config.zc +++ b/examples/data/json_config.zc @@ -17,24 +17,24 @@ struct Config { } fn main() { - var path = "examples/data/config.json"; + let path = "examples/data/config.json"; - var content_res = File::read_all(path); + let content_res = File::read_all(path); if content_res.is_err() { !"Failed to read config file: {content_res.err}"; return 1; } - var json_str = content_res.unwrap(); + let json_str = content_res.unwrap(); - var json_res = JsonValue::parse(json_str.c_str()); + let json_res = JsonValue::parse(json_str.c_str()); if json_res.is_err() { !"JSON Parse Error: {json_res.err}"; json_str.free(); return 1; } - var root = json_res.unwrap(); + let root = json_res.unwrap(); defer { json_str.free(); @@ -47,17 +47,17 @@ fn main() { return 1; } - var config = Config { + let config = Config { server_name: String::new("Unknown"), port: 0, logging: false }; - var obj_map = (*root).object_val; + let obj_map = (*root).object_val; if Map<JsonValue*>::contains(obj_map, "server_name") { - var opt = Map<JsonValue*>::get(obj_map, "server_name"); - var val = opt.unwrap(); + let opt = Map<JsonValue*>::get(obj_map, "server_name"); + let val = opt.unwrap(); if (*val).kind.tag == JsonType::JSON_STRING().tag { config.server_name.free(); config.server_name = String::new((*val).string_val); @@ -65,21 +65,21 @@ fn main() { } if Map<JsonValue*>::contains(obj_map, "port") { - var opt = Map<JsonValue*>::get(obj_map, "port"); - var val = opt.unwrap(); + let opt = Map<JsonValue*>::get(obj_map, "port"); + let val = opt.unwrap(); if (*val).kind.tag == JsonType::JSON_NUMBER().tag { config.port = (int)(*val).number_val; } } if Map<JsonValue*>::contains(obj_map, "features") { - var opt = Map<JsonValue*>::get(obj_map, "features"); - var features = opt.unwrap(); + let opt = Map<JsonValue*>::get(obj_map, "features"); + let features = opt.unwrap(); if (*features).kind.tag == JsonType::JSON_OBJECT().tag { - var f_obj = (*features).object_val; + let f_obj = (*features).object_val; if Map<JsonValue*>::contains(f_obj, "logging") { - var l_opt = Map<JsonValue*>::get(f_obj, "logging"); - var l = l_opt.unwrap(); + let l_opt = Map<JsonValue*>::get(f_obj, "logging"); + let l = l_opt.unwrap(); if (*l).kind.tag == JsonType::JSON_BOOL().tag { config.logging = (*l).bool_val; } @@ -88,7 +88,7 @@ fn main() { } "Configuration Loaded:"; - var s_name = config.server_name.c_str(); + let s_name = config.server_name.c_str(); "Server: {s_name}"; "Port: {config.port}"; "Logging: {config.logging}"; diff --git a/examples/data_structures/binary_tree.zc b/examples/data_structures/binary_tree.zc index 14e7b3d..86acb21 100644 --- a/examples/data_structures/binary_tree.zc +++ b/examples/data_structures/binary_tree.zc @@ -8,7 +8,7 @@ struct Node { impl Node { fn new(v: int) -> Self* { - var n = alloc<Self>(); + let n = alloc<Self>(); n.value = v; n.left = NULL; n.right = NULL; @@ -71,7 +71,7 @@ impl BST { } fn main() { - var tree = BST::new(); + let tree = BST::new(); defer tree.free(); "Inserting: 50, 30, 20, 40, 70, 60, 80"; diff --git a/examples/data_structures/linked_list.zc b/examples/data_structures/linked_list.zc index cb85554..cd16bf5 100644 --- a/examples/data_structures/linked_list.zc +++ b/examples/data_structures/linked_list.zc @@ -8,7 +8,7 @@ struct Node { impl Node { fn new(v: int) -> Self* { - var n = alloc<Node>(); + let n = alloc<Node>(); guard n != NULL else { "Out of memory!"; return NULL; @@ -29,7 +29,7 @@ impl LinkedList { } fn push(self, v: int) { - var new_node = Node::new(v); + let new_node = Node::new(v); guard new_node != NULL else { return; } new_node.next = self.head; @@ -37,7 +37,7 @@ impl LinkedList { } fn print_list(self) { - var current: Node* = self.head; + let current: Node* = self.head; "["..; while current != NULL { "{current.value}"..; @@ -50,17 +50,17 @@ impl LinkedList { } fn free(self) { - var current: Node* = self.head; + let current: Node* = self.head; while current != NULL { - autofree var temp = current; + autofree let temp = current; current = current.next; } self.head = NULL; } fn len(self) -> int { - var count = 0; - var current: Node* = self.head; + let count = 0; + let current: Node* = self.head; while current != NULL { count++; current = current.next; @@ -70,7 +70,7 @@ impl LinkedList { } fn main() { - var list = LinkedList::new(); + let list = LinkedList::new(); defer list.free(); "Pushing: 10, 20, 30..."; diff --git a/examples/data_structures/stack.zc b/examples/data_structures/stack.zc index 8f1fea5..4a8593a 100644 --- a/examples/data_structures/stack.zc +++ b/examples/data_structures/stack.zc @@ -43,7 +43,7 @@ impl Stack<T> { fn main() { "[Integer Stack]"; - var int_stack = Stack<int>::new(); + let int_stack = Stack<int>::new(); defer int_stack.free(); "Pushing: 10, 20, 30"; @@ -52,19 +52,19 @@ fn main() { int_stack.push(30); "Size: {int_stack.size()}"; - var p = int_stack.peek(); + let p = int_stack.peek(); "Peek: {p.unwrap()}"; "Popping: "..; while !int_stack.is_empty() { - var opt = int_stack.pop(); + let opt = int_stack.pop(); "{opt.unwrap()} "..; } ""; ""; "[String Stack]"; - var str_stack = Stack<String>::new(); + let str_stack = Stack<String>::new(); defer str_stack.free(); str_stack.push(String::new("First")); @@ -73,8 +73,8 @@ fn main() { "Popping: "..; while !str_stack.is_empty() { - var opt_s = str_stack.pop(); - var s: String = opt_s.unwrap(); + let opt_s = str_stack.pop(); + let s: String = opt_s.unwrap(); "{s.c_str()} "..; } ""; diff --git a/examples/features/composition.zc b/examples/features/composition.zc index 883c348..64fb8e0 100644 --- a/examples/features/composition.zc +++ b/examples/features/composition.zc @@ -21,11 +21,11 @@ struct Rigidbody { fn main() { // Mixin usage - flattened fields - var t = Transform{ x: 10.0, y: 5.0, rotation: 90.0 }; + let t = Transform{ x: 10.0, y: 5.0, rotation: 90.0 }; println "Transform pos: ({t.x}, {t.y})"; // Named usage - nested fields - var rb = Rigidbody{ + let rb = Rigidbody{ position: Vector2{x: 0.0, y: 10.0}, velocity: Vector2{x: 1.0, y: 0.0}, mass: 50.0 diff --git a/examples/features/comptime_fib.zc b/examples/features/comptime_fib.zc index 1ad2898..278ae9f 100644 --- a/examples/features/comptime_fib.zc +++ b/examples/features/comptime_fib.zc @@ -1,17 +1,17 @@ fn main() { comptime { - var N = 20; - var fib: long[20]; + let N = 20; + let fib: long[20]; fib[0] = (long)0; fib[1] = (long)1; - for var i=2; i<N; i+=1 { + for let i=2; i<N; i+=1 { fib[i] = fib[i-1] + fib[i-2]; } printf("// Generated Fibonacci Sequence\n"); - printf("var fibs: int[%d] = [", N); - for var i=0; i<N; i+=1 { + printf("let fibs: int[%d] = [", N); + for let i=0; i<N; i+=1 { printf("%ld", fib[i]); if (i < N-1) printf(", "); } diff --git a/examples/features/showcase.zc b/examples/features/showcase.zc index eca5480..d03fe81 100644 --- a/examples/features/showcase.zc +++ b/examples/features/showcase.zc @@ -66,20 +66,20 @@ fn main() { defer { println "Cleaning up resources..."; } println "=> Generics and traits."; - var btn = Button { + let btn = Button { label: "Submit", width: 120, height: 40 }; - var container = Container<Button> { item: btn }; + let container = Container<Button> { item: btn }; - var b = container.get(); + let b = container.get(); b.draw(); println ""; println "=> Enums and pattern matching."; - var events: Event[4] = [ + let events: Event[4] = [ Event::Click(Point { x: 150, y: 300 }), Event::KeyPress('Z'), Event::Click(Point { x: 42, y: 0 }), @@ -92,7 +92,7 @@ fn main() { println ""; println "=> Lambdas"; - var sum = run_op(10, 20, (a, b) -> a + b); + let sum = run_op(10, 20, (a, b) -> a + b); println "10 + 20 = {sum}"; println ""; } diff --git a/examples/games/zen_craft/main.zc b/examples/games/zen_craft/main.zc index 7f86c19..c130e72 100644 --- a/examples/games/zen_craft/main.zc +++ b/examples/games/zen_craft/main.zc @@ -30,12 +30,12 @@ extern fn GenImagePerlinNoise(width: int, height: int, offsetX: int, offsetY: in impl Chunk { static fn new(x: int, z: int) -> Chunk { - var c: Chunk; + let c: Chunk; c.x = x; c.z = z; // Generate Heightmap - var heights: int[16][16]; + let heights: int[16][16]; raw { Image noise = GenImagePerlinNoise(16, 16, x * 16, z * 16, 0.5f); @@ -62,7 +62,7 @@ impl Chunk { for cx in 0..16 { for cz in 0..16 { - var h = heights[cx][cz]; + let h = heights[cx][cz]; for cy in 0..16 { if cy < h - 1 { c.blocks[cx][cy][cz] = BLOCK_STONE; // Stone base @@ -83,11 +83,11 @@ impl Chunk { for x in 0..16 { for y in 0..16 { for z in 0..16 { - var btype = self.blocks[x][y][z]; + let btype = self.blocks[x][y][z]; if btype != BLOCK_AIR { - var _world_x = (float)(self.x * 16 + x); - var _world_y = (float)y; - var _world_z = (float)(self.z * 16 + z); + let _world_x = (float)(self.x * 16 + x); + let _world_y = (float)y; + let _world_z = (float)(self.z * 16 + z); match btype { BLOCK_DIRT => rl::DrawModel(model_dirt, rl::Vector3{x: _world_x + 0.5, y: _world_y + 0.5, z: _world_z + 0.5}, 1.0, rl::WHITE), BLOCK_STONE => rl::DrawModel(model_stone, rl::Vector3{x: _world_x + 0.5, y: _world_y + 0.5, z: _world_z + 0.5}, 1.0, rl::WHITE), @@ -109,12 +109,12 @@ fn get_block(chunks: Chunk*, num_chunks: int, x: int, y: int, z: int) -> int { if z < 0 || z >= 32 { return BLOCK_AIR; } // Determine chunk coordinates - var cx = x / 16; - var cz = z / 16; + let cx = x / 16; + let cz = z / 16; // Determine local block coordinates - var lx = x % 16; - var lz = z % 16; + let lx = x % 16; + let lz = z % 16; // Find the right chunk for i in 0..num_chunks { @@ -129,10 +129,10 @@ fn get_block(chunks: Chunk*, num_chunks: int, x: int, y: int, z: int) -> int { fn set_block(chunks: Chunk*, num_chunks: int, x: int, y: int, z: int, type: int) { if y < 0 || y >= 16 { return; } - var cx = x / 16; - var cz = z / 16; - var lx = x % 16; - var lz = z % 16; + let cx = x / 16; + let cz = z / 16; + let lx = x % 16; + let lz = z % 16; for i in 0..num_chunks { if chunks[i].x == cx && chunks[i].z == cz { @@ -153,19 +153,19 @@ struct RaycastHit { } fn raycast(chunks: Chunk*, num_chunks: int, ox: float, oy: float, oz: float, dx: float, dy: float, dz: float, max_dist: float) -> RaycastHit { - var r: RaycastHit; + let r: RaycastHit; r.hit = 0; - var x = ox; - var y = oy; - var z = oz; + let x = ox; + let y = oy; + let z = oz; - var step = 0.05; - var dist = 0.0; + let step = 0.05; + let dist = 0.0; - var last_x = (int)floor(x); - var last_y = (int)floor(y); - var last_z = (int)floor(z); + let last_x = (int)floor(x); + let last_y = (int)floor(y); + let last_z = (int)floor(z); while dist < max_dist { x += dx * step; @@ -173,9 +173,9 @@ fn raycast(chunks: Chunk*, num_chunks: int, ox: float, oy: float, oz: float, dx: z += dz * step; dist += step; - var ix = (int)floor(x); - var iy = (int)floor(y); - var iz = (int)floor(z); + let ix = (int)floor(x); + let iy = (int)floor(y); + let iz = (int)floor(z); if get_block(chunks, num_chunks, ix, iy, iz) != BLOCK_AIR { r.hit = 1; @@ -210,14 +210,14 @@ fn raycast(chunks: Chunk*, num_chunks: int, ox: float, oy: float, oz: float, dx: extern fn DrawCubeTexture(texture: rl::Texture2D, position: rl::Vector3, width: float, height: float, length: float, color: rl::Color); // Textures & Models -var model_dirt: rl::Model; -var model_grass: rl::Model; -var model_stone: rl::Model; -var tex_sun: rl::Texture2D; -var tex_moon: rl::Texture2D; +let model_dirt: rl::Model; +let model_grass: rl::Model; +let model_stone: rl::Model; +let tex_sun: rl::Texture2D; +let tex_moon: rl::Texture2D; fn load_texture_from_memory(_data: char*, _len: int) -> rl::Texture2D { - var tex: rl::Texture2D; + let tex: rl::Texture2D; raw { Image img = LoadImageFromMemory(".png", (unsigned char*)_data, _len); tex = LoadTextureFromImage(img); @@ -227,20 +227,20 @@ fn load_texture_from_memory(_data: char*, _len: int) -> rl::Texture2D { } fn init_textures() { - var dirt_data = embed "examples/games/zen_craft/assets/dirt.png"; - var grass_data = embed "examples/games/zen_craft/assets/grass_side.png"; - var stone_data = embed "examples/games/zen_craft/assets/stone.png"; - var sun_data = embed "examples/games/zen_craft/assets/sun.png"; - var moon_data = embed "examples/games/zen_craft/assets/moon.png"; - - var _tex_dirt = load_texture_from_memory(dirt_data.data, dirt_data.len); - var _tex_grass = load_texture_from_memory(grass_data.data, grass_data.len); - var _tex_stone = load_texture_from_memory(stone_data.data, stone_data.len); + let dirt_data = embed "examples/games/zen_craft/assets/dirt.png"; + let grass_data = embed "examples/games/zen_craft/assets/grass_side.png"; + let stone_data = embed "examples/games/zen_craft/assets/stone.png"; + let sun_data = embed "examples/games/zen_craft/assets/sun.png"; + let moon_data = embed "examples/games/zen_craft/assets/moon.png"; + + let _tex_dirt = load_texture_from_memory(dirt_data.data, dirt_data.len); + let _tex_grass = load_texture_from_memory(grass_data.data, grass_data.len); + let _tex_stone = load_texture_from_memory(stone_data.data, stone_data.len); tex_sun = load_texture_from_memory(sun_data.data, sun_data.len); tex_moon = load_texture_from_memory(moon_data.data, moon_data.len); // Create Models - var mesh = rl::GenMeshCube(1.0, 1.0, 1.0); + let mesh = rl::GenMeshCube(1.0, 1.0, 1.0); model_dirt = rl::LoadModelFromMesh(mesh); model_grass = rl::LoadModelFromMesh(mesh); model_stone = rl::LoadModelFromMesh(mesh); @@ -256,7 +256,7 @@ fn draw_sky(camera: rl::Camera3D) { // Disable Depth Mask to draw sky behind everything rl::BeginMode3D(camera); // Simple Fixed Sun Position or billboard - var sun_pos = rl::Vector3{x: camera.position.x + 20.0, y: camera.position.y + 40.0, z: camera.position.z + 20.0}; + let sun_pos = rl::Vector3{x: camera.position.x + 20.0, y: camera.position.y + 40.0, z: camera.position.z + 20.0}; raw { DrawBillboard(camera, tex_sun, sun_pos, 10.0f, WHITE); @@ -277,12 +277,12 @@ struct Player { } fn check_collision(chunks: Chunk*, num_chunks: int, x: float, y: float, z: float, w: float, h: float) -> int { - var min_x = (int)floor(x - w/2.0); - var max_x = (int)floor(x + w/2.0); - var min_y = (int)floor(y); - var max_y = (int)floor(y + h); - var min_z = (int)floor(z - w/2.0); - var max_z = (int)floor(z + w/2.0); + let min_x = (int)floor(x - w/2.0); + let max_x = (int)floor(x + w/2.0); + let min_y = (int)floor(y); + let max_y = (int)floor(y + h); + let min_z = (int)floor(z - w/2.0); + let max_z = (int)floor(z + w/2.0); for ix in min_x..max_x+1 { for iy in min_y..max_y+1 { @@ -298,7 +298,7 @@ fn check_collision(chunks: Chunk*, num_chunks: int, x: float, y: float, z: float impl Player { static fn new(x: float, y: float, z: float) -> Player { - var p: Player; + let p: Player; p.x = x; p.y = y; p.z = z; @@ -320,7 +320,7 @@ impl Player { fn update(self, chunks: Chunk*, num_chunks: int, dt: float) { // Mouse look - var mouse_delta = rl::GetMouseDelta(); + let mouse_delta = rl::GetMouseDelta(); self.yaw += mouse_delta.x * 0.003; self.pitch += mouse_delta.y * 0.003; @@ -328,22 +328,22 @@ impl Player { if self.pitch < -1.5 { self.pitch = -1.5; } // Movement input - var dx = 0.0; - var dz = 0.0; + let dx = 0.0; + let dz = 0.0; if rl::IsKeyDown(rl::KEY_W) { dx += 1.0; } if rl::IsKeyDown(rl::KEY_S) { dx -= 1.0; } if rl::IsKeyDown(rl::KEY_A) { dz -= 1.0; } if rl::IsKeyDown(rl::KEY_D) { dz += 1.0; } - var fx = cos(self.yaw); - var fz = sin(self.yaw); - var rx = -sin(self.yaw); - var rz = cos(self.yaw); + let fx = cos(self.yaw); + let fz = sin(self.yaw); + let rx = -sin(self.yaw); + let rz = cos(self.yaw); - var move_x = fx * dx + rx * dz; - var move_z = fz * dx + rz * dz; + let move_x = fx * dx + rx * dz; + let move_z = fz * dx + rz * dz; - var mlen = sqrt(move_x*move_x + move_z*move_z); + let mlen = sqrt(move_x*move_x + move_z*move_z); if mlen > 0.001 { move_x /= mlen; move_z /= mlen; @@ -365,8 +365,8 @@ impl Player { } // Physics integration (Separate Axes) - var box_w = 0.6; - var box_h = 1.8; + let box_w = 0.6; + let box_h = 1.8; // X axis self.x += self.vx * dt; @@ -396,9 +396,9 @@ impl Player { } // Sync Camera - var view_x = cos(self.yaw) * cos(self.pitch); - var view_z = sin(self.yaw) * cos(self.pitch); - var view_y = -sin(self.pitch); + let view_x = cos(self.yaw) * cos(self.pitch); + let view_z = sin(self.yaw) * cos(self.pitch); + let view_y = -sin(self.pitch); self.camera.position.x = self.x; self.camera.position.y = self.y + 1.6; @@ -421,11 +421,11 @@ fn main() { init_textures(); // Initialize Player - var p = Player::new(10.0, 10.0, 10.0); - var selected_block = BLOCK_STONE; + let p = Player::new(10.0, 10.0, 10.0); + let selected_block = BLOCK_STONE; // Generate Chunks - var chunks: Chunk[4]; + let chunks: Chunk[4]; chunks[0] = Chunk::new(0, 0); chunks[1] = Chunk::new(1, 0); chunks[2] = Chunk::new(0, 1); @@ -434,7 +434,7 @@ fn main() { rl::DisableCursor(); // Capture mouse while !rl::WindowShouldClose() { - var dt: float = rl::GetFrameTime(); + let dt: float = rl::GetFrameTime(); (&p).update(&chunks[0], 4, dt); // Block selection input @@ -452,25 +452,25 @@ fn main() { // Render chunks for i in 0..4 { - var c: Chunk* = &chunks[i]; + let c: Chunk* = &chunks[i]; c.draw(); } // Block interaction - var screen_center = rl::Vector2{ + let screen_center = rl::Vector2{ x: (float)rl::GetScreenWidth() / 2.0, y: (float)rl::GetScreenHeight() / 2.0 }; - var pick_ray = rl::GetScreenToWorldRay(screen_center, p.camera); + let pick_ray = rl::GetScreenToWorldRay(screen_center, p.camera); - var hit = raycast(&chunks[0], 4, pick_ray.position.x, pick_ray.position.y, pick_ray.position.z, + let hit = raycast(&chunks[0], 4, pick_ray.position.x, pick_ray.position.y, pick_ray.position.z, pick_ray.direction.x, pick_ray.direction.y, pick_ray.direction.z, 5.0); if hit.hit != 0 { // Draw selection - var hx = (float)hit.x; - var hy = (float)hit.y; - var hz = (float)hit.z; + let hx = (float)hit.x; + let hy = (float)hit.y; + let hz = (float)hit.z; // Draw slight offset wireframe rl::DrawCubeWires(rl::Vector3{x: hx + 0.5, y: hy + 0.5, z: hz + 0.5}, 1.01, 1.01, 1.01, rl::BLACK); @@ -480,14 +480,14 @@ fn main() { set_block(&chunks[0], 4, hit.x, hit.y, hit.z, BLOCK_AIR); } else if rl::IsMouseButtonPressed(rl::MOUSE_BUTTON_RIGHT) { - var nx = hit.x + hit.face_x; - var ny = hit.y + hit.face_y; - var nz = hit.z + hit.face_z; + let nx = hit.x + hit.face_x; + let ny = hit.y + hit.face_y; + let nz = hit.z + hit.face_z; // Don't place inside player (Simple check) - var dist_x = p.x - ((float)nx + 0.5); - var dist_y = p.y + 1.6 - ((float)ny + 0.5); // Eye pos vs block center - var dist_z = p.z - ((float)nz + 0.5); + let dist_x = p.x - ((float)nx + 0.5); + let dist_y = p.y + 1.6 - ((float)ny + 0.5); // Eye pos vs block center + let dist_z = p.z - ((float)nz + 0.5); if (dist_x*dist_x + dist_y*dist_y + dist_z*dist_z) > 2.0 { set_block(&chunks[0], 4, nx, ny, nz, selected_block); } @@ -497,8 +497,8 @@ fn main() { rl::EndMode3D(); // Draw HUD - var sw = rl::GetScreenWidth(); - var sh = rl::GetScreenHeight(); + let sw = rl::GetScreenWidth(); + let sh = rl::GetScreenHeight(); rl::DrawRectangle(sw/2 - 5, sh/2 - 1, 10, 2, rl::RED); // Horizontal rl::DrawRectangle(sw/2 - 1, sh/2 - 5, 2, 10, rl::RED); // Vertical diff --git a/examples/gpu/cuda-benchmark.zc b/examples/gpu/cuda-benchmark.zc index d426e10..cea326e 100644 --- a/examples/gpu/cuda-benchmark.zc +++ b/examples/gpu/cuda-benchmark.zc @@ -11,11 +11,11 @@ import "std/mem.zc" @global fn matrix_multiply_kernel(A: float*, B: float*, C: float*, N: int) { - var row = block_id_y() * block_dim_y() + thread_id_y(); - var col = block_id_x() * block_dim_x() + thread_id_x(); + let row = block_id_y() * block_dim_y() + thread_id_y(); + let col = block_id_x() * block_dim_x() + thread_id_x(); if row < N && col < N { - var sum = 0.0f; + let sum = 0.0f; for k in 0..N { sum = sum + A[row * N + k] * B[k * N + col]; } @@ -29,26 +29,26 @@ fn matrix_multiply_kernel(A: float*, B: float*, C: float*, N: int) { @global fn monte_carlo_pi_kernel(results: float*, num_samples: u64, seed: u64) { - var idx = block_id_x() * block_dim_x() + thread_id_x(); - var total_threads = grid_dim_x() * block_dim_x(); + let idx = block_id_x() * block_dim_x() + thread_id_x(); + let total_threads = grid_dim_x() * block_dim_x(); - var local_count: u64 = 0; - var samples_per_thread = num_samples / total_threads; + let local_count: u64 = 0; + let samples_per_thread = num_samples / total_threads; // Simple random number generator - var rand_state = seed + idx; + let rand_state = seed + idx; for i in 0..samples_per_thread { // Generate random x and y in [0, 1] - var a: u64 = 1103515245u64; - var b: u64 = 12345u64; - var m: u64 = 2147483648u64; + let a: u64 = 1103515245u64; + let b: u64 = 12345u64; + let m: u64 = 2147483648u64; rand_state = (a * rand_state + b) % m; - var x = (float)rand_state / 2147483648.0f; + let x = (float)rand_state / 2147483648.0f; rand_state = (a * rand_state + b) % m; - var y = (float)rand_state / 2147483648.0f; + let y = (float)rand_state / 2147483648.0f; // Check if point is inside quarter circle if x * x + y * y <= 1.0f { @@ -66,30 +66,30 @@ fn monte_carlo_pi_kernel(results: float*, num_samples: u64, seed: u64) { fn nbody_kernel(x: float*, y: float*, z: float*, vx: float*, vy: float*, vz: float*, N: int, dt: float) { - var i = thread_id(); + let i = thread_id(); if i < N { - var ax = 0.0f; - var ay = 0.0f; - var az = 0.0f; - var xi = x[i]; - var yi = y[i]; - var zi = z[i]; + let ax = 0.0f; + let ay = 0.0f; + let az = 0.0f; + let xi = x[i]; + let yi = y[i]; + let zi = z[i]; // Calculate gravitational forces from all other bodies for j in 0..N { if i != j { - var dx = x[j] - xi; - var dy = y[j] - yi; - var dz = z[j] - zi; - - var dx2 = dx * dx; - var dy2 = dy * dy; - var dz2 = dz * dz; - var softening: float = 0.0000000001f; - var dist_sqr = dx2 + dy2 + dz2 + softening; - var dist = sqrtf(dist_sqr); - var force = 1.0f / (dist_sqr * dist); + let dx = x[j] - xi; + let dy = y[j] - yi; + let dz = z[j] - zi; + + let dx2 = dx * dx; + let dy2 = dy * dy; + let dz2 = dz * dz; + let softening: float = 0.0000000001f; + let dist_sqr = dx2 + dy2 + dz2 + softening; + let dist = sqrtf(dist_sqr); + let force = 1.0f / (dist_sqr * dist); ax = ax + (force * dx); ay = ay + (force * dy); @@ -115,27 +115,27 @@ fn nbody_kernel(x: float*, y: float*, z: float*, @global fn mandelbrot_kernel(output: int*, width: int, height: int, max_iter: int) { - var px = block_id_x() * block_dim_x() + thread_id_x(); - var py = block_id_y() * block_dim_y() + thread_id_y(); + let px = block_id_x() * block_dim_x() + thread_id_x(); + let py = block_id_y() * block_dim_y() + thread_id_y(); if px < width && py < height { // Map pixel to complex plane - var x0 = ((float)px / (float)width) * 3.5f - 2.5f; - var y0 = ((float)py / (float)height) * 2.0f - 1.0f; + let x0 = ((float)px / (float)width) * 3.5f - 2.5f; + let y0 = ((float)py / (float)height) * 2.0f - 1.0f; - var x = 0.0f; - var y = 0.0f; - var iter = 0; + let x = 0.0f; + let y = 0.0f; + let iter = 0; // Iterate z = z^2 + c for i in 0..max_iter { - var x2 = x * x; - var y2 = y * y; + let x2 = x * x; + let y2 = y * y; if (x2 + y2) > 4.0f { break; } - var xtemp = x2 - y2 + x0; - var xy2 = 2.0f * x * y; + let xtemp = x2 - y2 + x0; + let xy2 = 2.0f * x * y; y = xy2 + y0; x = xtemp; iter = iter + 1; @@ -150,7 +150,7 @@ fn mandelbrot_kernel(output: int*, width: int, height: int, max_iter: int) { fn print_gpu_info() { - var device_count = cuda_device_count(); + let device_count = cuda_device_count(); "Found {device_count} CUDA device(s)\n"; } @@ -161,13 +161,13 @@ fn print_gpu_info() { fn benchmark_matrix_multiply(N: int) { "Benchmark 1: Matrix Multiplication ({N}x{N}) "; - var size = N * N; + let size = N * N; // Allocate host memory "-> Allocating host memory..."; - var h_A = alloc_n<float>(size); - var h_B = alloc_n<float>(size); - var h_C = alloc_n<float>(size); + let h_A = alloc_n<float>(size); + let h_B = alloc_n<float>(size); + let h_C = alloc_n<float>(size); defer free(h_A); defer free(h_B); defer free(h_C); @@ -181,9 +181,9 @@ fn benchmark_matrix_multiply(N: int) { // Allocate device memory "-> Allocating device memory..."; - var d_A = cuda_alloc<float>(size); - var d_B = cuda_alloc<float>(size); - var d_C = cuda_alloc<float>(size); + let d_A = cuda_alloc<float>(size); + let d_B = cuda_alloc<float>(size); + let d_C = cuda_alloc<float>(size); defer cuda_free(d_A); defer cuda_free(d_B); defer cuda_free(d_C); @@ -195,12 +195,12 @@ fn benchmark_matrix_multiply(N: int) { // Configure grid const BLOCK_SIZE = 16; - var blocks_per_grid = (N + BLOCK_SIZE - 1) / BLOCK_SIZE; + let blocks_per_grid = (N + BLOCK_SIZE - 1) / BLOCK_SIZE; "-> Launching kernel: {blocks_per_grid}x{blocks_per_grid} blocks, {BLOCK_SIZE}x{BLOCK_SIZE} threads each"; " GPU IS NOW WORKING HARD - Check nvtop!\n"; - var start = clock(); + let start = clock(); // Run multiple iterations to keep GPU busy for iter in 0..10 { @@ -212,7 +212,7 @@ fn benchmark_matrix_multiply(N: int) { " Iteration {iter + 1}/10 complete"; } - var elapsed = (clock() - start) / CLOCKS_PER_SEC; + let elapsed = (clock() - start) / CLOCKS_PER_SEC; " Completed in {elapsed} seconds\n"; // Copy result back @@ -234,23 +234,23 @@ fn benchmark_monte_carlo_pi(num_samples: u64) { const BLOCK_SIZE = 256; const NUM_BLOCKS = 1024; - var total_threads = BLOCK_SIZE * NUM_BLOCKS; + let total_threads = BLOCK_SIZE * NUM_BLOCKS; // Allocate memory - var h_results = alloc_n<float>(total_threads); + let h_results = alloc_n<float>(total_threads); defer free(h_results); - var d_results = cuda_alloc<float>(total_threads); + let d_results = cuda_alloc<float>(total_threads); defer cuda_free(d_results); "-> Launching kernel: {NUM_BLOCKS} blocks x {BLOCK_SIZE} threads"; " GPU IS NOW WORKING HARD - Check nvtop!\n"; - var start = clock(); + let start = clock(); // Run many iterations for iter in 0..100 { - var seed = (u64)time(NULL) + (u64)iter; + let seed = (u64)time(NULL) + (u64)iter; launch monte_carlo_pi_kernel(d_results, num_samples, seed) with { grid: NUM_BLOCKS, @@ -263,19 +263,19 @@ fn benchmark_monte_carlo_pi(num_samples: u64) { } } - var elapsed = (clock() - start) / CLOCKS_PER_SEC; + let elapsed = (clock() - start) / CLOCKS_PER_SEC; "\n Completed in {elapsed} seconds\n"; // Copy results and calculate Pi cuda_copy_to_host(h_results, d_results, total_threads * sizeof(float)); - var total_inside: u64 = 0; + let total_inside: u64 = 0; for i in 0..total_threads { total_inside = total_inside + (u64)h_results[i]; } - var pi_estimate = 4.0 * (double)total_inside / (double)num_samples; - var error = fabs(pi_estimate - 3.14159265359); + let pi_estimate = 4.0 * (double)total_inside / (double)num_samples; + let error = fabs(pi_estimate - 3.14159265359); "-> Results:"; " Estimated Pi: {pi_estimate}"; @@ -294,12 +294,12 @@ fn benchmark_nbody(num_bodies: int, num_steps: int) { "-> Simulating {num_bodies} bodies for {num_steps} steps"; // Allocate host memory - var h_x = alloc_n<float>(num_bodies); - var h_y = alloc_n<float>(num_bodies); - var h_z = alloc_n<float>(num_bodies); - var h_vx = alloc_n<float>(num_bodies); - var h_vy = alloc_n<float>(num_bodies); - var h_vz = alloc_n<float>(num_bodies); + let h_x = alloc_n<float>(num_bodies); + let h_y = alloc_n<float>(num_bodies); + let h_z = alloc_n<float>(num_bodies); + let h_vx = alloc_n<float>(num_bodies); + let h_vy = alloc_n<float>(num_bodies); + let h_vz = alloc_n<float>(num_bodies); defer free(h_x); defer free(h_y); defer free(h_z); @@ -321,12 +321,12 @@ fn benchmark_nbody(num_bodies: int, num_steps: int) { // Allocate device memory "-> Allocating device memory..."; - var d_x = cuda_alloc<float>(num_bodies); - var d_y = cuda_alloc<float>(num_bodies); - var d_z = cuda_alloc<float>(num_bodies); - var d_vx = cuda_alloc<float>(num_bodies); - var d_vy = cuda_alloc<float>(num_bodies); - var d_vz = cuda_alloc<float>(num_bodies); + let d_x = cuda_alloc<float>(num_bodies); + let d_y = cuda_alloc<float>(num_bodies); + let d_z = cuda_alloc<float>(num_bodies); + let d_vx = cuda_alloc<float>(num_bodies); + let d_vy = cuda_alloc<float>(num_bodies); + let d_vz = cuda_alloc<float>(num_bodies); defer cuda_free(d_x); defer cuda_free(d_y); defer cuda_free(d_z); @@ -343,13 +343,13 @@ fn benchmark_nbody(num_bodies: int, num_steps: int) { cuda_copy_to_device(d_vz, h_vz, num_bodies * sizeof(float)); const BLOCK_SIZE = 256; - var num_blocks = (num_bodies + BLOCK_SIZE - 1) / BLOCK_SIZE; - var dt = 0.01f; + let num_blocks = (num_bodies + BLOCK_SIZE - 1) / BLOCK_SIZE; + let dt = 0.01f; "-> Launching simulation: {num_blocks} blocks x {BLOCK_SIZE} threads"; " GPU IS NOW WORKING HARD - Check nvtop!\n"; - var start = clock(); + let start = clock(); for step in 0..num_steps { launch nbody_kernel(d_x, d_y, d_z, d_vx, d_vy, d_vz, num_bodies, dt) with { @@ -363,7 +363,7 @@ fn benchmark_nbody(num_bodies: int, num_steps: int) { } } - var elapsed = (clock() - start) / CLOCKS_PER_SEC; + let elapsed = (clock() - start) / CLOCKS_PER_SEC; "\n Completed in {elapsed} seconds\n"; // Copy results back diff --git a/examples/gpu/cuda_info.zc b/examples/gpu/cuda_info.zc index 7e832d1..55d2042 100644 --- a/examples/gpu/cuda_info.zc +++ b/examples/gpu/cuda_info.zc @@ -3,13 +3,13 @@ import "std/cuda.zc" import "std/string.zc" fn main() { - var count = cuda_device_count(); + let count = cuda_device_count(); "---------------------------"; "CUDA Device Count: {count}"; "---------------------------"; if (count > 0) { - var props = cuda_device_properties(0); + let props = cuda_device_properties(0); "Device Name: {props.name.vec.data}"; "Total Global Mem: {props.total_global_mem}"; @@ -20,13 +20,13 @@ fn main() { props.name.free(); - var driver = cuda_driver_version(); - var runtime = cuda_runtime_version(); + let driver = cuda_driver_version(); + let runtime = cuda_runtime_version(); "Driver Version: {driver}"; "Runtime Version: {runtime}"; - var mem = cuda_mem_info(); + let mem = cuda_mem_info(); "Free Mem: {mem.free}"; "Total Mem: {mem.total}"; } diff --git a/examples/gpu/cuda_vector_add.zc b/examples/gpu/cuda_vector_add.zc index de75a74..d1f896a 100644 --- a/examples/gpu/cuda_vector_add.zc +++ b/examples/gpu/cuda_vector_add.zc @@ -8,7 +8,7 @@ import "std/mem.zc" @global fn add_kernel(a: float*, b: float*, c: float*, n: int) { - var i = thread_id(); + let i = thread_id(); if i < n { c[i] = a[i] + b[i]; } @@ -20,9 +20,9 @@ fn main() { "=> Zen C CUDA Vector Addition"; "-> Vector size: {N} elements"; - var h_a = alloc_n<float>(N); - var h_b = alloc_n<float>(N); - var h_c = alloc_n<float>(N); + let h_a = alloc_n<float>(N); + let h_b = alloc_n<float>(N); + let h_c = alloc_n<float>(N); defer free(h_a); defer free(h_b); defer free(h_c); @@ -33,9 +33,9 @@ fn main() { } "-> Allocating device memory..."; - var d_a = cuda_alloc<float>(N); - var d_b = cuda_alloc<float>(N); - var d_c = cuda_alloc<float>(N); + let d_a = cuda_alloc<float>(N); + let d_b = cuda_alloc<float>(N); + let d_c = cuda_alloc<float>(N); defer cuda_free(d_a); defer cuda_free(d_b); defer cuda_free(d_c); @@ -44,7 +44,7 @@ fn main() { cuda_copy_to_device(d_b, h_b, N * sizeof(float)); const BLOCK_SIZE = 256; - var num_blocks = (N + BLOCK_SIZE - 1) / BLOCK_SIZE; + let num_blocks = (N + BLOCK_SIZE - 1) / BLOCK_SIZE; "-> Launching: {num_blocks} blocks x {BLOCK_SIZE} threads"; @@ -58,9 +58,9 @@ fn main() { cuda_copy_to_host(h_c, d_c, N * sizeof(float)); "-> Verifying..."; - var ok: int = 1; + let ok: int = 1; for i in 0..10 { - var expected = h_a[i] + h_b[i]; + let expected = h_a[i] + h_b[i]; if h_c[i] != expected { !"-> Mismatch at {i}"; ok = 0; diff --git a/examples/graphics/mandelbrot.zc b/examples/graphics/mandelbrot.zc index f3fa4bd..aca94ba 100644 --- a/examples/graphics/mandelbrot.zc +++ b/examples/graphics/mandelbrot.zc @@ -31,8 +31,8 @@ fn pick_char(iter: int, max_iter: int, edge_chars: char[], edge_count: int) -> c if (iter >= max_iter) { return ' '; } if (iter <= 0) { return edge_chars[0]; } - var t: float = ((float)iter) / ((float)max_iter); - var idx: int = (int)(t * ((float)(edge_count - 1))); + let t: float = ((float)iter) / ((float)max_iter); + let idx: int = (int)(t * ((float)(edge_count - 1))); if (idx < 0) { idx = 0; } if (idx >= edge_count) { idx = edge_count - 1; } @@ -41,36 +41,36 @@ fn pick_char(iter: int, max_iter: int, edge_chars: char[], edge_count: int) -> c } fn main() { - var width: int = 120; - var height: int = 40; - var max_iter: int = 200; + let width: int = 120; + let height: int = 40; + let max_iter: int = 200; - var edge_chars: char[12] = [ '#', '@', '%', '8', '&', '*', '+', '=', '-', ':', '.', ',' ]; - var edge_count: int = 12; + let edge_chars: char[12] = [ '#', '@', '%', '8', '&', '*', '+', '=', '-', ':', '.', ',' ]; + let edge_count: int = 12; - var min_re: float = -2.2; - var max_re: float = 1.0; - var min_im: float = -1.2; - var max_im: float = 1.2; + let min_re: float = -2.2; + let max_re: float = 1.0; + let min_im: float = -1.2; + let max_im: float = 1.2; for y in 0..height { - var im: float = + let im: float = max_im - (max_im - min_im) * ( ((float)y) / ((float)(height - 1)) ); for x in 0..width { - var re: float = + let re: float = min_re + (max_re - min_re) * ( ((float)x) / ((float)(width - 1)) ); - var c: Complex = complex_make(re, im); - var z: Complex = complex_make(0.0, 0.0); + let c: Complex = complex_make(re, im); + let z: Complex = complex_make(0.0, 0.0); - var iter: int = 0; + let iter: int = 0; while (iter < max_iter and complex_abs2(z) <= 4.0) { z = complex_add(complex_mul(z, z), c); iter += 1; } - var pixel = pick_char(iter, max_iter, edge_chars, edge_count); + let pixel = pick_char(iter, max_iter, edge_chars, edge_count); print "{pixel}"; } print "\n"; diff --git a/examples/graphics/raylib_demo.zc b/examples/graphics/raylib_demo.zc index 77b661e..f0e4f57 100644 --- a/examples/graphics/raylib_demo.zc +++ b/examples/graphics/raylib_demo.zc @@ -8,11 +8,11 @@ fn main() { raylib::SetTargetFPS(60); - var x = 400; - var y = 300; - var dx = 5; - var dy = 4; - var radius = 30; + let x = 400; + let y = 300; + let dx = 5; + let dy = 4; + let radius = 30; while !raylib::WindowShouldClose() { diff --git a/examples/networking/echo_server.zc b/examples/networking/echo_server.zc index 1cecb74..072c3a2 100644 --- a/examples/networking/echo_server.zc +++ b/examples/networking/echo_server.zc @@ -4,27 +4,27 @@ import "std/net.zc" fn main() { "Starting Echo Server on 127.0.0.1:8080..."; - var listener_res = TcpListener::bind("127.0.0.1", 8080); + let listener_res = TcpListener::bind("127.0.0.1", 8080); if listener_res.is_err() { !"Failed to bind: {listener_res.err}"; return 1; } - var listener = listener_res.unwrap(); + let listener = listener_res.unwrap(); defer listener.close(); loop { - var client_res = listener.accept(); + let client_res = listener.accept(); if client_res.is_ok() { - var stream = client_res.unwrap(); + let stream = client_res.unwrap(); defer stream.close(); - var buf: char[1024]; + let buf: char[1024]; - var read_res = stream.read(buf, 1024); + let read_res = stream.read(buf, 1024); if read_res.is_ok() { - var bytes = read_res.unwrap(); + let bytes = read_res.unwrap(); if bytes > 0 { stream.write(buf, bytes); "Echoed {bytes} bytes."; diff --git a/examples/process/env.zc b/examples/process/env.zc index 1506229..0ea7437 100644 --- a/examples/process/env.zc +++ b/examples/process/env.zc @@ -4,11 +4,11 @@ import "std/env.zc" fn main() -> int { // ---- - // get: Retrieves the env-var as borrowed string (char *) (no alloc) + // get: Retrieves the env-let as borrowed string (char *) (no alloc) // --- // @Example usage: On Linux (and some variants) PATH is already defined. // --- - var path = Env::get("PATH"); + let path = Env::get("PATH"); if (path.is_some()) { println "PATH is: {path.unwrap()}"; @@ -17,18 +17,18 @@ fn main() -> int { } // ---- - // set: Sets an env-var variable - // get_dup: Retrieves the env-var as caller-owned String() (heap alloc) + // set: Sets an env-let variable + // get_dup: Retrieves the env-let as caller-owned String() (heap alloc) // --- // @Example usage: In your terminal type "export HELLO=world" or use Env::set() // --- - var res = Env::set("HELLO", "world"); + let res = Env::set("HELLO", "world"); //=> check res against EnvRes::OK() - var hello = Env::get_dup("HELLO"); + let hello = Env::get_dup("HELLO"); if (hello.is_some()) { - var hello_str = hello.unwrap(); + let hello_str = hello.unwrap(); defer hello_str.free(); println "HELLO is: {hello_str.c_str()}"; @@ -37,11 +37,11 @@ fn main() -> int { } // ---- - // unset: Unsets an existing env-var + // unset: Unsets an existing env-let // --- Env::unset("HELLO"); - var hello_now2 = Env::get("HELLO"); + let hello_now2 = Env::get("HELLO"); if (hello_now2.is_none()) { println "HELLO is now unset"; diff --git a/examples/scripting/lua/lua.zc b/examples/scripting/lua/lua.zc index 74403bb..a8463fa 100644 --- a/examples/scripting/lua/lua.zc +++ b/examples/scripting/lua/lua.zc @@ -14,7 +14,7 @@ fn l_zenc_hello(L: lua_State*) -> int { } fn main() { - var L: lua_State* = luaL_newstate(); + let L: lua_State* = luaL_newstate(); if (!L) return !"Could not initialize LUA."; diff --git a/examples/tools/mini_grep.zc b/examples/tools/mini_grep.zc index 827b73a..39fec07 100644 --- a/examples/tools/mini_grep.zc +++ b/examples/tools/mini_grep.zc @@ -21,22 +21,22 @@ fn str_find_case(haystack: string, needle: string, ignore_case: bool) -> Option< { if (!ignore_case) { - var res = (string)strstr(haystack, needle); + let res = (string)strstr(haystack, needle); if (res != NULL) return Option<string>::Some(res); return Option<string>::None(); } - var h = haystack; - var n = needle; - var n_len = strlen(needle); + let h = haystack; + let n = needle; + let n_len = strlen(needle); while (*h != 0) { - var is_match: bool = true; + let is_match: bool = true; for i in 0..n_len { - var hc = to_lower(*(h + i)); - var nc = to_lower(*(n + i)); + let hc = to_lower(*(h + i)); + let nc = to_lower(*(n + i)); if (hc != nc) { is_match = false; @@ -59,7 +59,7 @@ fn print_highlight(line: string, match_ptr: string, match_len: usize, config: Gr return; } - var current = line; + let current = line; while (current < match_ptr) { "{*current}"..; @@ -85,15 +85,15 @@ fn print_highlight(line: string, match_ptr: string, match_len: usize, config: Gr } fn grep_file(path: string, config: GrepConfig) -> Result<int> { - var content_str: String = File::read_all(path)?; + let content_str: String = File::read_all(path)?; defer content_str.destroy(); - var content = content_str.c_str(); + let content = content_str.c_str(); - var line_num = 1; - var ptr = content; - var line_start = content; + let line_num = 1; + let ptr = content; + let line_start = content; - var q_len = strlen(config.query); + let q_len = strlen(config.query); while (*ptr != 0) { @@ -101,8 +101,8 @@ fn grep_file(path: string, config: GrepConfig) -> Result<int> { { *ptr = 0; - var match_opt = str_find_case(line_start, config.query, config.ignore_case); - var found_str = ""; + let match_opt = str_find_case(line_start, config.query, config.ignore_case); + let found_str = ""; if (match_opt.is_some()) found_str = match_opt.unwrap(); if ((match_opt.is_some() and !config.invert) || (!match_opt.is_some() and config.invert)) @@ -142,8 +142,8 @@ fn grep_file(path: string, config: GrepConfig) -> Result<int> { if (ptr > line_start) { - var match_opt = str_find_case(line_start, config.query, config.ignore_case); - var found_str = ""; + let match_opt = str_find_case(line_start, config.query, config.ignore_case); + let found_str = ""; if (match_opt.is_some()) found_str = match_opt.unwrap(); if ((match_opt.is_some() and !config.invert) || (!match_opt.is_some() and config.invert)) @@ -164,17 +164,17 @@ fn grep_file(path: string, config: GrepConfig) -> Result<int> { } fn visit_dir(path: string, config: GrepConfig) { - var entries_res = File::read_dir(path); + let entries_res = File::read_dir(path); guard entries_res.is_ok() else return; - var entries = entries_res.unwrap(); - var p_base = Path::new(path); + let entries = entries_res.unwrap(); + let p_base = Path::new(path); for i in 0..entries.length() { - var entry: DirEntry = entries.get(i); - var full_path_obj = p_base.join(entry.name.c_str()); - var full_path = full_path_obj.c_str(); + let entry: DirEntry = entries.get(i); + let full_path_obj = p_base.join(entry.name.c_str()); + let full_path = full_path_obj.c_str(); if (entry.is_dir) { @@ -209,7 +209,7 @@ fn main(argc: int, argv: string*) return 0; } - var config = GrepConfig { + let config = GrepConfig { query: NULL, path: NULL, ignore_case: false, @@ -219,10 +219,10 @@ fn main(argc: int, argv: string*) color: false }; - var arg_idx = 1; + let arg_idx = 1; while (arg_idx < argc) { - var arg = argv[arg_idx]; + let arg = argv[arg_idx]; if (arg[0] == '-') { if (arg[1] == '-') @@ -240,10 +240,10 @@ fn main(argc: int, argv: string*) } else { - var len = strlen(arg); + let len = strlen(arg); for i in 1..len { - var c = arg[i]; + let c = arg[i]; match c { 'i' => config.ignore_case = true, 'n' => config.line_numbers = true, @@ -275,13 +275,13 @@ fn main(argc: int, argv: string*) if (File::exists(config.path)) { - var meta_res = File::metadata(config.path); + let meta_res = File::metadata(config.path); if (meta_res.is_err()) { !"grep: {config.path}: Error reading metadata"; return 1; } - var meta = meta_res.unwrap(); + let meta = meta_res.unwrap(); if (meta.is_dir) { @@ -296,7 +296,7 @@ fn main(argc: int, argv: string*) } else { - var res = grep_file(config.path, config); + let res = grep_file(config.path, config); if (res.is_err()) { !"Error: {res.err}"; return 1; diff --git a/src/parser/parser_core.c b/src/parser/parser_core.c index 7468bfb..746fc38 100644 --- a/src/parser/parser_core.c +++ b/src/parser/parser_core.c @@ -341,14 +341,14 @@ ASTNode *parse_program_nodes(ParserContext *ctx, Lexer *l) { s = parse_var_decl(ctx, l); } - else if (t.len == 3 && strncmp(t.start, "def", 3) == 0) + else if (t.len == 3 && strncmp(t.start, "let", 3) == 0) { - s = parse_def(ctx, l); + s = parse_var_decl(ctx, l); } else if (t.len == 5 && strncmp(t.start, "const", 5) == 0) { zpanic_at(t, "'const' for declarations is deprecated. Use 'def' for constants or " - "'var x: const T' for read-only variables."); + "'let x: const T' for read-only variables."); } else if (t.len == 6 && strncmp(t.start, "extern", 6) == 0) { diff --git a/src/parser/parser_stmt.c b/src/parser/parser_stmt.c index 4b09c83..6441161 100644 --- a/src/parser/parser_stmt.c +++ b/src/parser/parser_stmt.c @@ -1278,7 +1278,7 @@ ASTNode *parse_for(ParserContext *ctx, Lexer *l) ASTNode *init = NULL; if (lexer_peek(l).type != TOK_SEMICOLON) { - if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "var", 3) == 0) + if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "let", 3) == 0) { init = parse_var_decl(ctx, l); } @@ -1922,9 +1922,9 @@ ASTNode *parse_statement(ParserContext *ctx, Lexer *l) if (tk.type == TOK_AUTOFREE) { lexer_next(l); - if (lexer_peek(l).type != TOK_IDENT || strncmp(lexer_peek(l).start, "var", 3) != 0) + if (lexer_peek(l).type != TOK_IDENT || strncmp(lexer_peek(l).start, "let", 3) != 0) { - zpanic_at(lexer_peek(l), "Expected 'var' after autofree"); + zpanic_at(lexer_peek(l), "Expected 'let' after autofree"); } s = parse_var_decl(ctx, l); s->var_decl.is_autofree = 1; @@ -2063,28 +2063,28 @@ ASTNode *parse_statement(ParserContext *ctx, Lexer *l) return parse_plugin(ctx, l); } - if (strncmp(tk.start, "var", 3) == 0 && tk.len == 3) + if (strncmp(tk.start, "let", 3) == 0 && tk.len == 3) { return parse_var_decl(ctx, l); } - // Static local variable: static var x = 0; + // Static local variable: static let x = 0; if (strncmp(tk.start, "static", 6) == 0 && tk.len == 6) { lexer_next(l); // eat 'static' Token next = lexer_peek(l); - if (strncmp(next.start, "var", 3) == 0 && next.len == 3) + if (strncmp(next.start, "let", 3) == 0 && next.len == 3) { ASTNode *v = parse_var_decl(ctx, l); v->var_decl.is_static = 1; return v; } - zpanic_at(next, "Expected 'var' after 'static'"); + zpanic_at(next, "Expected 'let' after 'static'"); } if (strncmp(tk.start, "const", 5) == 0 && tk.len == 5) { - zpanic_at(tk, "'const' for declarations is deprecated. Use 'def' for constants or 'var " + zpanic_at(tk, "'const' for declarations is deprecated. Use 'def' for constants or 'let " "x: const T' for read-only variables."); } if (strncmp(tk.start, "return", 6) == 0 && tk.len == 6) diff --git a/std/core.zc b/std/core.zc index 910bfa6..f450517 100644 --- a/std/core.zc +++ b/std/core.zc @@ -5,7 +5,7 @@ include <stdio.h> include <stdbool.h> include <stdarg.h> -var __zen_hash_seed: usize = 14695981039346656037; +let __zen_hash_seed: usize = 14695981039346656037; raw { void _zen_panic(const char* file, int line, const char* func, const char* msg) { diff --git a/std/cuda.zc b/std/cuda.zc index dbb1fe6..c6a9403 100644 --- a/std/cuda.zc +++ b/std/cuda.zc @@ -7,7 +7,7 @@ import "./mem.zc" /// Allocate device memory for n elements of type T. fn cuda_alloc<T>(n: usize) -> T* { - var ptr: T* = NULL; + let ptr: T* = NULL; cudaMalloc((void**)&ptr, n * sizeof(T)); return ptr; } @@ -76,7 +76,7 @@ fn cuda_sync() { /// Get the number of CUDA devices. fn cuda_device_count() -> int { - var count: int = 0; + let count: int = 0; cudaGetDeviceCount(&count); return count; } @@ -90,7 +90,7 @@ fn cuda_set_device(id: int) { /// Get the last CUDA error code. fn cuda_last_error() -> int { - var err: int; + let err: int; err = (int)cudaGetLastError(); return err; } @@ -134,19 +134,19 @@ struct CudaMemInfo { } fn cuda_device_properties(device_id: int) -> CudaDeviceProp { - var mem: usize = 0; - var sm: int = 0; - var maj: int = 0; - var min: int = 0; - var max_t: int = 0; - var warp: int = 0; + let mem: usize = 0; + let sm: int = 0; + let maj: int = 0; + let min: int = 0; + let max_t: int = 0; + let warp: int = 0; - var name_ptr = alloc_n<char>(256); + let name_ptr = alloc_n<char>(256); name_ptr[0] = 0; _z_cuda_get_props(device_id, name_ptr, &mem, &sm, &maj, &min, &max_t, &warp); - var s = String::new(name_ptr); + let s = String::new(name_ptr); free(name_ptr); return CudaDeviceProp { @@ -161,20 +161,20 @@ fn cuda_device_properties(device_id: int) -> CudaDeviceProp { } fn cuda_driver_version() -> int { - var d: int = 0; + let d: int = 0; cudaDriverGetVersion(&d); return d; } fn cuda_runtime_version() -> int { - var r: int = 0; + let r: int = 0; cudaRuntimeGetVersion(&r); return r; } fn cuda_mem_info() -> CudaMemInfo { - var f: usize = 0; - var t: usize = 0; + let f: usize = 0; + let t: usize = 0; cudaMemGetInfo(&f, &t); return CudaMemInfo { free: f, total: t }; } @@ -30,7 +30,7 @@ struct Env {} impl Env { fn get(name: string) -> Option<string> { - var value: string = _z_env_get(name); + let value: string = _z_env_get(name); if (value == NULL) { return Option<string>::None(); } @@ -39,26 +39,26 @@ impl Env { } fn get_dup(name: string) -> Option<String> { - var value: string = _z_env_get(name); + let value: string = _z_env_get(name); if (value == NULL) { return Option<String>::None(); } - var v = String::from(value); - var o = Option<String>::Some(v); + let v = String::from(value); + let o = Option<String>::Some(v); v.forget(); return o; } fn set(name: string, value: string) -> EnvRes { - var ret: int = _z_env_set(name, value, 1); + let ret: int = _z_env_set(name, value, 1); return (ret == 0) ? EnvRes::OK() : EnvRes::ERR(); } fn unset(name: string) -> EnvRes { - var ret: int = _z_env_unset(name); + let ret: int = _z_env_unset(name); return (ret == 0) ? EnvRes::OK() : EnvRes::ERR(); } @@ -130,7 +130,7 @@ struct DirEntry { impl File { fn open(path: char*, mode: char*) -> Result<File> { - var h = _z_fs_fopen(path, mode); + let h = _z_fs_fopen(path, mode); if (h == NULL) { return Result<File>::Err("Failed to open file"); } @@ -150,39 +150,39 @@ impl File { } _z_fs_fseek(self.handle, 0, Z_SEEK_END); - var size = _z_fs_ftell(self.handle); + let size = _z_fs_ftell(self.handle); _z_fs_fseek(self.handle, 0, Z_SEEK_SET); - var buffer: char* = _z_fs_malloc((usize)size + 1); + let buffer: char* = _z_fs_malloc((usize)size + 1); if (buffer == NULL) { return Result<String>::Err("Out of memory"); } - var read = _z_fs_fread(buffer, 1, size, self.handle); + let read = _z_fs_fread(buffer, 1, size, self.handle); buffer[read] = 0; - var s = String::new(buffer); + let s = String::new(buffer); _z_fs_free(buffer); - var res = Result<String>::Ok(s); + let res = Result<String>::Ok(s); s.forget(); - var ret = res; + let ret = res; res.forget(); return ret; } fn read_all(path: char*) -> Result<String> { - var res = File::open(path, "rb"); + let res = File::open(path, "rb"); if (res.is_err()) { return Result<String>::Err(res.err); } - var f: File = res.unwrap(); - var s_res = f.read_to_string(); + let f: File = res.unwrap(); + let s_res = f.read_to_string(); f.close(); - var ret = s_res; + let ret = s_res; s_res.forget(); return ret; } @@ -192,8 +192,8 @@ impl File { return Result<bool>::Err("File not open"); } - var len = strlen(content); - var written = _z_fs_fwrite(content, 1, len, self.handle); + let len = strlen(content); + let written = _z_fs_fwrite(content, 1, len, self.handle); if (written != len) { return Result<bool>::Err("Write incomplete"); } @@ -205,9 +205,9 @@ impl File { } fn metadata(path: char*) -> Result<Metadata> { - var size: uint64_t; - var is_d: int; - var is_f: int; + let size: uint64_t; + let is_d: int; + let is_f: int; if (_z_fs_get_metadata(path, &size, &is_d, &is_f) != 0) { return Result<Metadata>::Err("Failed to get metadata"); @@ -242,28 +242,28 @@ impl File { } fn read_dir(path: char*) -> Result< Vec<DirEntry> > { - var dir = _z_fs_opendir(path); + let dir = _z_fs_opendir(path); if (dir == NULL) { return Result< Vec<DirEntry> >::Err("Failed to open directory"); } - var entries = Vec<DirEntry>::new(); - var name_buf: char* = _z_fs_malloc(256); + let entries = Vec<DirEntry>::new(); + let name_buf: char* = _z_fs_malloc(256); if (name_buf == NULL) { _z_fs_closedir(dir); return Result< Vec<DirEntry> >::Err("Out of memory"); } - var is_d: int = 0; + let is_d: int = 0; while (_z_fs_read_entry(dir, name_buf, 256, &is_d)) { if (strcmp(name_buf, ".") == 0 || strcmp(name_buf, "..") == 0) { continue; } - var s = String::new(name_buf); - var ent = DirEntry { + let s = String::new(name_buf); + let ent = DirEntry { name: s, is_dir: is_d != 0 }; @@ -280,9 +280,9 @@ impl File { _z_fs_free(name_buf); _z_fs_closedir(dir); - var res = Result< Vec<DirEntry> >::Ok(entries); + let res = Result< Vec<DirEntry> >::Ok(entries); entries.forget(); - var ret = res; + let ret = res; res.forget(); return ret; } @@ -20,8 +20,8 @@ extern fn _z_vprintf(fmt: char*, ap: va_list) -> int; extern fn _z_vsnprintf(str: char*, size: usize, fmt: char*, ap: va_list) -> int; fn format(fmt: char*, ...) -> char* { - static var buffer: char[1024]; - var ap: va_list; + static let buffer: char[1024]; + let ap: va_list; va_start(ap, fmt); _z_vsnprintf(buffer, 1024, fmt, ap); va_end(ap); @@ -29,18 +29,18 @@ fn format(fmt: char*, ...) -> char* { } fn format_into(buffer: char*, size: usize, fmt: char*, ...) -> int { - var ap: va_list; + let ap: va_list; va_start(ap, fmt); - var ret = _z_vsnprintf(buffer, size, fmt, ap); + let ret = _z_vsnprintf(buffer, size, fmt, ap); va_end(ap); return ret; } fn format_new(fmt: char*, ...) -> char* { - var buffer: char* = malloc(1024); + let buffer: char* = malloc(1024); if buffer == NULL return NULL; - var ap: va_list; + let ap: va_list; va_start(ap, fmt); _z_vsnprintf(buffer, 1024, fmt, ap); va_end(ap); @@ -48,31 +48,31 @@ fn format_new(fmt: char*, ...) -> char* { } fn print(fmt: char*, ...) -> int { - var ap: va_list; + let ap: va_list; va_start(ap, fmt); - var ret = _z_vprintf(fmt, ap); + let ret = _z_vprintf(fmt, ap); va_end(ap); return ret; } fn println(fmt: char*, ...) -> int { - var ap: va_list; + let ap: va_list; va_start(ap, fmt); - var ret = _z_vprintf(fmt, ap); + let ret = _z_vprintf(fmt, ap); va_end(ap); puts(""); return ret + 1; } fn readln() -> char* { - var cap: usize = 64; - var len: usize = 0; - var line: char* = malloc(cap); + let cap: usize = 64; + let len: usize = 0; + let line: char* = malloc(cap); if (line == NULL) return NULL; - var c: int; - var std_in = _z_get_stdin(); - var eof_val = _z_get_eof(); + let c: int; + let std_in = _z_get_stdin(); + let eof_val = _z_get_eof(); while (true) { c = _z_fgetc(std_in); @@ -81,7 +81,7 @@ fn readln() -> char* { if (len + 1 >= cap) { cap = cap * 2; - var n = realloc(line, cap); + let n = realloc(line, cap); if (n == NULL) { free(line); return NULL; diff --git a/std/json.zc b/std/json.zc index cfef2c3..848c0e0 100644 --- a/std/json.zc +++ b/std/json.zc @@ -191,33 +191,33 @@ impl JsonValue { } fn array() -> JsonValue { - var v: Vec<JsonValue*>* = malloc(sizeof(Vec_JsonValuePtr)); + let v: Vec<JsonValue*>* = malloc(sizeof(Vec_JsonValuePtr)); *v = Vec_JsonValuePtr::new(); return JsonValue { kind: JsonType::JSON_ARRAY(), string_val: 0, number_val: 0, bool_val: false, array_val: v, object_val: 0 }; } fn object() -> JsonValue { - var m: Map<JsonValue*>* = malloc(sizeof(Map_JsonValuePtr)); + let m: Map<JsonValue*>* = malloc(sizeof(Map_JsonValuePtr)); *m = Map_JsonValuePtr::new(); return JsonValue { kind: JsonType::JSON_OBJECT(), string_val: 0, number_val: 0, bool_val: false, array_val: 0, object_val: m }; } fn push(self, val: JsonValue) { if (self.kind.tag != JsonType::JSON_ARRAY().tag) return; - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = val; self.array_val.push(p); } fn set(self, key: char*, val: JsonValue) { if (self.kind.tag != JsonType::JSON_OBJECT().tag) return; - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = val; self.object_val.put(key, p); } fn parse(json: char*) -> Result<JsonValue*> { - var result: JsonValue* = _json_do_parse(json); + let result: JsonValue* = _json_do_parse(json); if (result != NULL) { return Result<JsonValue*>::Ok(result); } @@ -227,9 +227,9 @@ impl JsonValue { fn free(self) { if (self.kind.tag == JsonType::JSON_STRING().tag) free(self.string_val); if (self.kind.tag == JsonType::JSON_ARRAY().tag) { - var v: Vec<JsonValue*>* = self.array_val; - for (var i: usize = 0; i < v.length(); i = i + 1) { - var item: JsonValue* = v.get(i); + let v: Vec<JsonValue*>* = self.array_val; + for (let i: usize = 0; i < v.length(); i = i + 1) { + let item: JsonValue* = v.get(i); item.free(); free(item); } @@ -238,10 +238,10 @@ impl JsonValue { free(v); } if (self.kind.tag == JsonType::JSON_OBJECT().tag) { - var m: Map<JsonValue*>* = self.object_val; - for (var i: usize = 0; i < m.capacity(); i = i + 1) { + let m: Map<JsonValue*>* = self.object_val; + for (let i: usize = 0; i < m.capacity(); i = i + 1) { if (m.is_slot_occupied(i)) { - var child: JsonValue* = m.val_at(i); + let child: JsonValue* = m.val_at(i); child.free(); free(child); } @@ -59,11 +59,11 @@ impl MapIterResult<V> { impl MapIter<V> { fn next(self) -> MapIterResult<V> { while self.idx < self.cap { - var i = self.idx; + let i = self.idx; self.idx = self.idx + 1; if (self.occupied[i] && !self.deleted[i]) { - var entry = MapEntry<V> { + let entry = MapEntry<V> { key: self.keys[i], val: self.vals[i] }; @@ -74,7 +74,7 @@ impl MapIter<V> { } } // Empty entry for None - var empty = MapEntry<V> { key: 0, val: self.vals[0] }; // Should be 0-init if possible + let empty = MapEntry<V> { key: 0, val: self.vals[0] }; // Should be 0-init if possible return MapIterResult<V> { entry: empty, has_val: false }; } } @@ -85,11 +85,11 @@ impl Map<V> { } fn _resize(self, new_cap: usize) { - var old_keys = self.keys; - var old_vals = self.vals; - var old_occupied = self.occupied; - var old_deleted = self.deleted; - var old_cap = self.cap; + let old_keys = self.keys; + let old_vals = self.vals; + let old_occupied = self.occupied; + let old_deleted = self.deleted; + let old_cap = self.cap; self.cap = new_cap; self.keys = calloc(new_cap, sizeof(char*)); @@ -98,7 +98,7 @@ impl Map<V> { self.deleted = calloc(new_cap, sizeof(bool)); self.len = 0; - for (var i: usize = 0; i < old_cap; i = i + 1) { + for (let i: usize = 0; i < old_cap; i = i + 1) { if (old_occupied[i] && !old_deleted[i]) { self.put(old_keys[i], old_vals[i]); } @@ -113,13 +113,13 @@ impl Map<V> { fn put(self, key: char*, val: V) { if (self.len >= self.cap * 0.75) { - var new_cap = self.cap * 2; + let new_cap = self.cap * 2; if (new_cap < 8) new_cap = 8; self._resize(new_cap); } - var hash = _map_hash_str(key); - var idx = hash % self.cap; + let hash = _map_hash_str(key); + let idx = hash % self.cap; while (true) { if (!self.occupied[idx] || (self.occupied[idx] && !self.deleted[idx] && strcmp(self.keys[idx], key) == 0)) { @@ -144,9 +144,9 @@ impl Map<V> { return Option<V>::None(); } - var hash = _map_hash_str(key); - var idx = hash % self.cap; - var start_idx = idx; + let hash = _map_hash_str(key); + let idx = hash % self.cap; + let start_idx = idx; while (true) { if (!self.occupied[idx]) { @@ -165,15 +165,15 @@ impl Map<V> { } fn contains(self, key: char*) -> bool { - var opt: Option<V> = self.get(key); + let opt: Option<V> = self.get(key); return opt.is_some(); } fn remove(self, key: char*) { if (self.cap == 0) return; - var hash = _map_hash_str(key); - var idx = hash % self.cap; + let hash = _map_hash_str(key); + let idx = hash % self.cap; while (true) { if (!self.occupied[idx]) return; @@ -199,7 +199,7 @@ impl Map<V> { fn free(self) { if (self.keys) { - for (var i: usize = 0; i < self.cap; i = i + 1) { + for (let i: usize = 0; i < self.cap; i = i + 1) { if (self.occupied[i] && !self.deleted[i]) { free(self.keys[i]); } @@ -81,7 +81,7 @@ fn mem_copy<T>(dst: T*, src: T*, count: usize) { } fn swap<T>(a: T*, b: T*) { - var tmp = *a; + let tmp = *a; *a = *b; *b = tmp; } @@ -66,13 +66,13 @@ struct TcpStream { impl TcpStream { fn read(self, buf: char*, len: usize) -> Result<usize> { - var n = _z_net_read(self.fd, buf, len); + let n = _z_net_read(self.fd, buf, len); if (n < 0) return Result<usize>::Err("Read failed"); return Result<usize>::Ok((usize)n); } fn write(self, buf: char*, len: usize) -> Result<usize> { - var n = _z_net_write(self.fd, buf, len); + let n = _z_net_write(self.fd, buf, len); if (n < 0) return Result<usize>::Err("Write failed"); return Result<usize>::Ok((usize)n); } @@ -85,10 +85,10 @@ impl TcpStream { } fn connect(host: char*, port: int) -> Result<TcpStream> { - var fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0); + let fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0); if (fd < 0) return Result<TcpStream>::Err("Failed to create socket"); - var res = _z_net_connect(fd, host, port); + let res = _z_net_connect(fd, host, port); if (res == -1) { close(fd); return Result<TcpStream>::Err("Invalid address"); } if (res == -2) { close(fd); return Result<TcpStream>::Err("Connection failed"); } @@ -102,10 +102,10 @@ struct TcpListener { impl TcpListener { fn bind(host: char*, port: int) -> Result<TcpListener> { - var fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0); + let fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0); if (fd < 0) return Result<TcpListener>::Err("Failed to create socket"); - var res = _z_net_bind(fd, host, port); + let res = _z_net_bind(fd, host, port); if (res == -1) { close(fd); return Result<TcpListener>::Err("Invalid address"); } if (res == -2) { close(fd); return Result<TcpListener>::Err("Bind failed"); } if (res == -3) { close(fd); return Result<TcpListener>::Err("Listen failed"); } @@ -114,7 +114,7 @@ impl TcpListener { } fn accept(self) -> Result<TcpStream> { - var client_fd = _z_net_accept(self.fd); + let client_fd = _z_net_accept(self.fd); if (client_fd < 0) return Result<TcpStream>::Err("Accept failed"); return Result<TcpStream>::Ok(TcpStream { fd: client_fd }); } diff --git a/std/option.zc b/std/option.zc index 11b4428..4098c99 100644 --- a/std/option.zc +++ b/std/option.zc @@ -32,7 +32,7 @@ impl Option<T> { !"Panic: unwrap called on None"; exit(1); } - var v = self.val; + let v = self.val; memset(&self.val, 0, sizeof(T)); return v; } diff --git a/std/path.zc b/std/path.zc index 7055880..b5c39ad 100644 --- a/std/path.zc +++ b/std/path.zc @@ -26,18 +26,18 @@ impl Path { } fn join(self, other: char*) -> Path { - var base_len = self.str.length(); - var new_s = String::from(self.str.c_str()); + let base_len = self.str.length(); + let new_s = String::from(self.str.c_str()); if (base_len > 0) { - var last = self.str.vec.get(base_len - 1); + let last = self.str.vec.get(base_len - 1); if (last != '/' && last != '\\') { - var sep = String::new("/"); + let sep = String::new("/"); new_s.append(&sep); } } - var other_str = String::new(other); + let other_str = String::new(other); new_s.append(&other_str); return Path { str: new_s }; @@ -45,11 +45,11 @@ impl Path { fn extension(self) -> Option<String> { - var s = self.c_str(); - var len = self.str.length(); + let s = self.c_str(); + let len = self.str.length(); - for (var i: usize = len; i > 0; i = i - 1) { - var c = s[i-1]; + for (let i: usize = len; i > 0; i = i - 1) { + let c = s[i-1]; if (c == '.') { // Check if we hit a separator before element // e.g. /d.ir/file - found dot @@ -64,19 +64,19 @@ impl Path { } fn file_name(self) -> Option<String> { - var s = self.c_str(); - var len = self.str.length(); + let s = self.c_str(); + let len = self.str.length(); if (len == 0) return Option<String>::None(); // Remove trailing separators - var end = len; + let end = len; while (end > 0 && (s[end-1] == '/' || s[end-1] == '\\')) { end = end - 1; } if (end == 0) return Option<String>::None(); // Root - var start = end; + let start = end; while (start > 0 && s[start-1] != '/' && s[start-1] != '\\') { start = start - 1; } @@ -85,12 +85,12 @@ impl Path { } fn parent(self) -> Option<Path> { - var s = self.c_str(); - var len = self.str.length(); + let s = self.c_str(); + let len = self.str.length(); if (len == 0) return Option<Path>::None(); // Trim trailing separators - var end = len; + let end = len; while (end > 0 && (s[end-1] == '/' || s[end-1] == '\\')) { end = end - 1; } @@ -111,7 +111,7 @@ impl Path { return Option<Path>::Some(Path::new("/")); } - var parent_str = self.str.substring(0, end); + let parent_str = self.str.substring(0, end); return Option<Path>::Some(Path { str: parent_str }); } } diff --git a/std/queue.zc b/std/queue.zc index 0b00ee2..c2fcd32 100644 --- a/std/queue.zc +++ b/std/queue.zc @@ -26,15 +26,15 @@ impl Queue<T> { } fn _grow(self) { - var new_cap = (self.cap == 0) ? 8 : self.cap * 2; - var new_data = malloc(sizeof(T) * new_cap); + let new_cap = (self.cap == 0) ? 8 : self.cap * 2; + let new_data = malloc(sizeof(T) * new_cap); if (self.count > 0) { if (self.tail > self.head) { memcpy(new_data, self.data + self.head, sizeof(T) * self.count); } else { - var first_part = self.cap - self.head; - var second_part = self.tail; + let first_part = self.cap - self.head; + let second_part = self.tail; memcpy(new_data, self.data + self.head, sizeof(T) * first_part); memcpy(new_data + first_part, self.data, sizeof(T) * second_part); } @@ -48,7 +48,7 @@ impl Queue<T> { } fn clone(self) -> Queue<T> { - var new_queue = Queue<T>::new(); + let new_queue = Queue<T>::new(); new_queue.data = malloc(sizeof(T) * self.cap); new_queue.cap = self.cap; new_queue.head = 0; @@ -60,8 +60,8 @@ impl Queue<T> { memcpy(new_queue.data, self.data + self.head, sizeof(T) * self.count); } else { - var first_part = self.cap - self.head; - var second_part = self.tail; + let first_part = self.cap - self.head; + let second_part = self.tail; memcpy(new_queue.data, self.data + self.head, sizeof(T) * first_part); memcpy(new_queue.data + first_part, self.data, sizeof(T) * second_part); } @@ -85,7 +85,7 @@ impl Queue<T> { return Option<T>::None(); } - var value = self.data[self.head]; + let value = self.data[self.head]; self.head = (self.head + 1) % self.cap; self.count = self.count - 1; diff --git a/std/result.zc b/std/result.zc index 1d10b1a..12c974c 100644 --- a/std/result.zc +++ b/std/result.zc @@ -32,7 +32,7 @@ impl Result<T> { !"Panic: unwrap called on Err: {self.err}"; exit(1); } - var v = self.val; + let v = self.val; memset(&self.val, 0, sizeof(T)); return v; } @@ -29,10 +29,10 @@ impl Set<T> { } fn _resize(self, new_cap: usize) { - var old_data = self.data; - var old_occupied = self.occupied; - var old_deleted = self.deleted; - var old_cap = self.cap; + let old_data = self.data; + let old_occupied = self.occupied; + let old_deleted = self.deleted; + let old_cap = self.cap; self.cap = new_cap; self.data = calloc(new_cap, sizeof(T)); @@ -40,7 +40,7 @@ impl Set<T> { self.deleted = calloc(new_cap, sizeof(bool)); self.len = 0; - for (var i: usize = 0; i < old_cap; i = i + 1) { + for (let i: usize = 0; i < old_cap; i = i + 1) { if (old_occupied[i] && !old_deleted[i]) { self.add(old_data[i]); } @@ -57,13 +57,13 @@ impl Set<T> { } if (self.len >= self.cap * 0.75) { - var new_cap = self.cap * 2; + let new_cap = self.cap * 2; if (new_cap < 8) new_cap = 8; self._resize(new_cap); } - var hash = _set_hash(&val, sizeof(T)); - var idx = hash % self.cap; + let hash = _set_hash(&val, sizeof(T)); + let idx = hash % self.cap; while (self.occupied[idx] && !self.deleted[idx]) { idx = (idx + 1) % self.cap; @@ -81,9 +81,9 @@ impl Set<T> { return false; } - var hash = _set_hash(&val, sizeof(T)); - var idx = hash % self.cap; - var start_idx = idx; + let hash = _set_hash(&val, sizeof(T)); + let idx = hash % self.cap; + let start_idx = idx; while (self.occupied[idx]) { if (!self.deleted[idx] && self.data[idx] == val) { @@ -101,9 +101,9 @@ impl Set<T> { fn remove(self, val: T) -> bool { if (self.cap == 0) return false; - var hash = _set_hash(&val, sizeof(T)); - var idx = hash % self.cap; - var start_idx = idx; + let hash = _set_hash(&val, sizeof(T)); + let idx = hash % self.cap; + let start_idx = idx; while (self.occupied[idx]) { if (!self.deleted[idx] && self.data[idx] == val) { @@ -155,7 +155,7 @@ impl Set<T> { return Option<T>::Some(self.data[idx]); } fn clear(self) { - for (var i: usize = 0; i < self.cap; i = i + 1) { + for (let i: usize = 0; i < self.cap; i = i + 1) { self.occupied[i] = false; self.deleted[i] = false; } diff --git a/std/stack.zc b/std/stack.zc index db02f2d..9b4d375 100644 --- a/std/stack.zc +++ b/std/stack.zc @@ -21,7 +21,7 @@ impl Stack<T> { } fn clone(self) -> Stack<T> { - var new_stack = Stack<T>::new(); + let new_stack = Stack<T>::new(); new_stack.len = self.len; new_stack.cap = self.cap; new_stack.data = malloc(sizeof(T) * new_stack.cap); @@ -44,7 +44,7 @@ impl Stack<T> { fn pop(self) -> Option<T> { if (self.len > 0) { - var value = self.data[self.len - 1]; + let value = self.data[self.len - 1]; self.len = self.len - 1; return Option<T>::Some(value); } diff --git a/std/string.zc b/std/string.zc index a7dd6ce..fe5b0ad 100644 --- a/std/string.zc +++ b/std/string.zc @@ -8,18 +8,18 @@ struct String { impl String { fn new(s: char*) -> String { - var len = strlen(s); - var v = Vec<char>::new(); + let len = strlen(s); + let v = Vec<char>::new(); // Manual copy for now - for (var i = 0; i < len; i = i + 1) { + for (let i = 0; i < len; i = i + 1) { v.push(s[i]); } v.push(0); // Extract fields to transfer ownership - var d = v.data; - var l = v.len; - var c = v.cap; + let d = v.data; + let l = v.len; + let c = v.cap; // Forget the local vector so it doesn't free the memory v.forget(); @@ -49,19 +49,19 @@ impl String { self.vec.len = self.vec.len - 1; } - var other_len = (*other).vec.len; - for (var i = 0; i < other_len; i = i + 1) { + let other_len = (*other).vec.len; + for (let i = 0; i < other_len; i = i + 1) { self.vec.push((*other).vec.get(i)); } } fn add(self, other: String*) -> String { - var new_s = String::from(self.c_str()); + let new_s = String::from(self.c_str()); new_s.append(other); - var d = new_s.vec.data; - var l = new_s.vec.len; - var c = new_s.vec.cap; + let d = new_s.vec.data; + let l = new_s.vec.len; + let c = new_s.vec.cap; new_s.forget(); return String { vec: Vec<char> { data: d, len: l, cap: c } }; @@ -80,23 +80,23 @@ impl String { if (start + len > self.length()) { panic("substring out of bounds"); } - var v = Vec<char>::new(); - for (var i: usize = 0; i < len; i = i + 1) { + let v = Vec<char>::new(); + for (let i: usize = 0; i < len; i = i + 1) { v.push(self.vec.get(start + i)); } v.push(0); - var d = v.data; - var l = v.len; - var c = v.cap; + let d = v.data; + let l = v.len; + let c = v.cap; v.forget(); return String { vec: Vec<char> { data: d, len: l, cap: c } }; } fn find(self, target: char) -> Option<usize> { - var len = self.length(); - for (var i: usize = 0; i < len; i = i + 1) { + let len = self.length(); + for (let i: usize = 0; i < len; i = i + 1) { if (self.vec.get(i) == target) { return Option<usize>::Some(i); } @@ -122,16 +122,16 @@ impl String { } fn starts_with(self, prefix: char*) -> bool { - var plen = strlen(prefix); + let plen = strlen(prefix); if plen > self.length() { return false; } return strncmp(self.c_str(), prefix, plen) == 0; } fn ends_with(self, suffix: char*) -> bool { - var slen = strlen(suffix); - var len = self.length(); + let slen = strlen(suffix); + let len = self.length(); if slen > len { return false; } - var offset = (int)(len - slen); + let offset = (int)(len - slen); return strcmp(self.c_str() + offset, suffix) == 0; } @@ -140,7 +140,7 @@ impl String { } fn _utf8_seq_len(first_byte: char) -> usize { - var b = (int)first_byte; + let b = (int)first_byte; if ((b & 0x80) == 0) { return 1; } if ((b & 0xE0) == 0xC0) { return 2; } if ((b & 0xF0) == 0xE0) { return 3; } @@ -149,11 +149,11 @@ impl String { } fn utf8_len(self) -> usize { - var count: usize = 0; - var i: usize = 0; - var len = self.length(); + let count: usize = 0; + let i: usize = 0; + let len = self.length(); while i < len { - var c = self.vec.get(i); + let c = self.vec.get(i); i = i + String::_utf8_seq_len(c); count = count + 1; } @@ -161,12 +161,12 @@ impl String { } fn utf8_at(self, idx: usize) -> String { - var count: usize = 0; - var i: usize = 0; - var len = self.length(); + let count: usize = 0; + let i: usize = 0; + let len = self.length(); while i < len { - var c = self.vec.get(i); - var seq = String::_utf8_seq_len(c); + let c = self.vec.get(i); + let seq = String::_utf8_seq_len(c); if (count == idx) { return self.substring(i, seq); @@ -181,13 +181,13 @@ impl String { fn utf8_substr(self, start_idx: usize, num_chars: usize) -> String { if (num_chars == 0) { return String::new(""); } - var byte_start: usize = 0; - var byte_len: usize = 0; + let byte_start: usize = 0; + let byte_len: usize = 0; - var count: usize = 0; - var i: usize = 0; - var len = self.length(); - var found_start = false; + let count: usize = 0; + let i: usize = 0; + let len = self.length(); + let found_start = false; while i < len { // Check if we reached the start char @@ -198,7 +198,7 @@ impl String { count = 0; } else if (!found_start) { // Still seeking start - var c = self.vec.get(i); + let c = self.vec.get(i); i = i + String::_utf8_seq_len(c); count = count + 1; continue; @@ -206,8 +206,8 @@ impl String { // If we are here, we are collecting chars if (count < num_chars) { - var c = self.vec.get(i); - var seq = String::_utf8_seq_len(c); + let c = self.vec.get(i); + let seq = String::_utf8_seq_len(c); byte_len = byte_len + seq; i = i + seq; count = count + 1; @@ -221,12 +221,12 @@ impl String { return self.substring(byte_start, byte_len); } fn split(self, delim: char) -> Vec<String> { - var parts = Vec<String>::new(); - var len = self.length(); + let parts = Vec<String>::new(); + let len = self.length(); if (len == 0) { return parts; } - var start: usize = 0; - var i: usize = 0; + let start: usize = 0; + let i: usize = 0; while i < len { if (self.vec.get(i) == delim) { @@ -246,13 +246,13 @@ impl String { } fn trim(self) -> String { - var start: usize = 0; - var len = self.length(); - var end = len; + let start: usize = 0; + let len = self.length(); + let end = len; // Find start while (start < len) { - var c = self.vec.get(start); + let c = self.vec.get(start); if (c != ' ' && c != '\t' && c != '\n' && c != '\r') { break; } @@ -265,7 +265,7 @@ impl String { // Find end while (end > start) { - var c = self.vec.get(end - 1); + let c = self.vec.get(end - 1); if (c != ' ' && c != '\t' && c != '\n' && c != '\r') { break; } @@ -276,20 +276,20 @@ impl String { } fn replace(self, target: char*, replacement: char*) -> String { - var t_len = strlen(target); + let t_len = strlen(target); if (t_len == 0) return self.substring(0, self.length()); // clone - var s_len = self.length(); - var result = String::new(""); + let s_len = self.length(); + let result = String::new(""); - var i: usize = 0; + let i: usize = 0; while (i < s_len) { // Check if match if (i + t_len <= s_len) { - var is_match = true; + let is_match = true; // Manual strncmp against vec data - for (var k: usize = 0; k < t_len; k = k + 1) { + for (let k: usize = 0; k < t_len; k = k + 1) { if (self.vec.get(i + k) != target[k]) { is_match = false; break; @@ -297,7 +297,7 @@ impl String { } if (is_match) { - var r_str = String::new(replacement); + let r_str = String::new(replacement); result.append(&r_str); i = i + t_len; continue; @@ -305,10 +305,10 @@ impl String { } // Append single char - var v = Vec<char>::new(); + let v = Vec<char>::new(); v.push(self.vec.get(i)); v.push(0); - var ch_s = String::new(v.data); + let ch_s = String::new(v.data); result.append(&ch_s); v.free(); i = i + 1; diff --git a/std/thread.zc b/std/thread.zc index 0ebcd03..e90943b 100644 --- a/std/thread.zc +++ b/std/thread.zc @@ -73,14 +73,14 @@ struct Thread { impl Thread { fn spawn(func: fn()) -> Result<Thread> { - var t: usize = 0; + let t: usize = 0; - var ctx_copy = malloc(16); // z_closure_T is 16 bytes + let ctx_copy = malloc(16); // z_closure_T is 16 bytes if (ctx_copy == NULL) return Result<Thread>::Err("OOM"); memcpy(ctx_copy, &func, 16); - var ret = _z_thread_spawn(ctx_copy, &t); + let ret = _z_thread_spawn(ctx_copy, &t); if (ret != 0) { free(ctx_copy); @@ -91,7 +91,7 @@ impl Thread { } fn join(self) -> Result<bool> { - var ret = _z_thread_join(self.handle); + let ret = _z_thread_join(self.handle); if (ret != 0) return Result<bool>::Err("Join failed"); return Result<bool>::Ok(true); } @@ -103,7 +103,7 @@ struct Mutex { impl Mutex { fn new() -> Mutex { - var ptr = malloc(64); + let ptr = malloc(64); _z_mutex_init(ptr); return Mutex { handle: ptr }; } @@ -41,7 +41,7 @@ struct VecIterRef<T> { impl VecIter<T> { fn next(self) -> Option<T> { if (self.idx < self.count) { - var item = self.data[self.idx]; + let item = self.data[self.idx]; self.idx = self.idx + 1; return Option<T>::Some(item); } @@ -56,7 +56,7 @@ impl VecIter<T> { impl VecIterRef<T> { fn next(self) -> VecIterResult<T> { if (self.idx < self.count) { - var item = &self.data[self.idx]; + let item = &self.data[self.idx]; self.idx = self.idx + 1; return VecIterResult<T> { ptr: item }; } @@ -165,7 +165,7 @@ impl Vec<T> { !"Panic: Remove index out of bounds"; exit(1); } - var item = self.data[idx]; + let item = self.data[idx]; // Shift elements left if (idx < self.len - 1) { memmove(self.data + idx, self.data + idx + 1, (self.len - idx - 1) * sizeof(T)); @@ -175,7 +175,7 @@ impl Vec<T> { } fn append(self, other: Vec<T>) { - var new_len = self.len + other.len; + let new_len = self.len + other.len; self.grow_to_fit(new_len); memcpy(self.data + self.len, other.data, other.len * sizeof(T)); @@ -203,7 +203,7 @@ impl Vec<T> { } fn contains(self, item: T) -> bool { - var i: usize = 0; + let i: usize = 0; while i < self.len { if memcmp(&self.data[i], &item, sizeof(T)) == 0 { return true; } i++; @@ -243,10 +243,10 @@ impl Vec<T> { } fn reverse(self) { - var i: usize = 0; - var j = self.len - 1; + let i: usize = 0; + let j = self.len - 1; while i < j { - var tmp = self.data[i]; + let tmp = self.data[i]; self.data[i] = self.data[j]; self.data[j] = tmp; i++; @@ -256,7 +256,7 @@ impl Vec<T> { fn eq(self, other: Vec<T>) -> bool { if self.len != other.len { return false; } - var i: usize = 0; + let i: usize = 0; while i < self.len { if memcmp(&self.data[i], &other.data[i], sizeof(T)) != 0 { return false; } i = i + 1; @@ -275,8 +275,8 @@ impl Vec<T> { if (self.len == 0) { return Vec<T> { data: 0, len: 0, cap: 0 }; } - var new_data = (T*)malloc(self.len * sizeof(T)); - var i: usize = 0; + let new_data = (T*)malloc(self.len * sizeof(T)); + let i: usize = 0; while i < self.len { new_data[i] = self.data[i]; i = i + 1; diff --git a/tests/basic/test_basics.zc b/tests/basic/test_basics.zc index 57dbb4e..8cc2e6b 100644 --- a/tests/basic/test_basics.zc +++ b/tests/basic/test_basics.zc @@ -4,8 +4,8 @@ test "test_hello" { } test "test_vars" { - var x = 10; - var y: int = 20; + let x = 10; + let y: int = 20; println "Sum: {x + y}"; } @@ -14,11 +14,11 @@ fn take_const_arg(x: const int) -> int { } test "test_const_args" { - var x = take_const_arg(10); + let x = take_const_arg(10); assert(x == 10, "Failed const arg"); - var y: const int = 20; - assert(y == 20, "Failed const var"); + let y: const int = 20; + assert(y == 20, "Failed const let"); println "Const args work!"; } diff --git a/tests/codegen/dedup_typedefs.zc b/tests/codegen/dedup_typedefs.zc index c6e8099..6e32346 100644 --- a/tests/codegen/dedup_typedefs.zc +++ b/tests/codegen/dedup_typedefs.zc @@ -9,10 +9,10 @@ struct Node { } fn main() { - var v: Vec2f; + let v: Vec2f; v.x = 1.0; v.y = 2.0; - var n: Node; + let n: Node; n.val = 1; } diff --git a/tests/collections/test_string_suite.zc b/tests/collections/test_string_suite.zc index a3f608d..afe08af 100644 --- a/tests/collections/test_string_suite.zc +++ b/tests/collections/test_string_suite.zc @@ -7,9 +7,9 @@ test "test_string_methods" { println "Testing String methods..."; // Substring - var s1: String = String::from("Hello World"); - var sub: String = s1.substring(0, 5); - var expected1: String = String::from("Hello"); + let s1: String = String::from("Hello World"); + let sub: String = s1.substring(0, 5); + let expected1: String = String::from("Hello"); if (sub.eq(&expected1)) { println " -> substring(0, 5): Passed"; } else { @@ -17,8 +17,8 @@ test "test_string_methods" { } // Substring middle - var sub2: String = s1.substring(6, 5); - var expected2: String = String::from("World"); + let sub2: String = s1.substring(6, 5); + let expected2: String = String::from("World"); if (sub2.eq(&expected2)) { println " -> substring(6, 5): Passed"; } else { @@ -26,9 +26,9 @@ test "test_string_methods" { } // Find character - found - var pos: Option<usize> = s1.find('W'); + let pos: Option<usize> = s1.find('W'); if (pos.is_some()) { - var idx: usize = pos.unwrap(); + let idx: usize = pos.unwrap(); assert(idx == (usize)6, "find('W') index mismatch"); println " -> find('W'): Passed (found at index 6)"; } else { @@ -36,7 +36,7 @@ test "test_string_methods" { } // Find character - not found - var pos2: Option<usize> = s1.find('Z'); + let pos2: Option<usize> = s1.find('Z'); if (pos2.is_none()) { println " -> find('Z'): Passed (not found)"; } else { @@ -44,7 +44,7 @@ test "test_string_methods" { } // Length - var len: usize = s1.length(); + let len: usize = s1.length(); if (len == (usize)11) { println " -> length(): Passed (11)"; } else { @@ -65,10 +65,10 @@ test "test_string_methods" { } // Append - var s2: String = String::from("Hello"); - var s3: String = String::from(" World"); + let s2: String = String::from("Hello"); + let s3: String = String::from(" World"); s2.append(&s3); - var expected6: String = String::from("Hello World"); + let expected6: String = String::from("Hello World"); if (s2.eq(&expected6)) { println " -> append(): Passed"; } else { @@ -80,33 +80,33 @@ test "test_string_methods" { test "test_fstrings_return" { println "Testing F-Strings and Returns..."; - var x = 100; - var y = 50; + let x = 100; + let y = 50; println "Direct F-String: x={x}"; - var nested = f"y is {y}"; + let nested = f"y is {y}"; println "Argument F-String: {nested}"; println "Math inside: 100 + 50 = {x + y}"; - var inner = f"Inner({x})"; - var outer = f"Outer({inner})"; + let inner = f"Inner({x})"; + let outer = f"Outer({inner})"; println "Composed: {outer}"; assert(strcmp(outer, "Outer(Inner(100))") == 0, "Composed f-string failed"); } test "test_string_std_ops" { println "Testing String Std Ops..."; - var s1 = String::from("Hello"); - var s2 = String::from(" World"); + let s1 = String::from("Hello"); + let s2 = String::from(" World"); - var s3 = s1.add(&s2); + let s3 = s1.add(&s2); print "Concatenated: "; s3.println(); assert(s3.length() == 11, "Length mismatch"); - var s4 = String::from("Hello World"); + let s4 = String::from("Hello World"); if (s3.eq(&s4)) { println "Equality check passed: Strings are identical."; } else { diff --git a/tests/control_flow/test_computed_goto.zc b/tests/control_flow/test_computed_goto.zc index 12b484c..7144132 100644 --- a/tests/control_flow/test_computed_goto.zc +++ b/tests/control_flow/test_computed_goto.zc @@ -1,9 +1,9 @@ test "test_computed_goto" -> int { - var x = 0; + let x = 0; // Get address of label using && unary operator - var target = &&label_B; + let target = &&label_B; // Jump to label A first goto label_A; diff --git a/tests/control_flow/test_goto.zc b/tests/control_flow/test_goto.zc index 9a90139..dc6ab98 100644 --- a/tests/control_flow/test_goto.zc +++ b/tests/control_flow/test_goto.zc @@ -1,6 +1,6 @@ test "test_goto" -> int { - var x = 0; + let x = 0; goto skip; x = 100; @@ -8,7 +8,7 @@ test "test_goto" -> int { skip: assert x == 0; - var resource = 1; + let resource = 1; if resource == 1 { goto cleanup; diff --git a/tests/control_flow/test_guard_unless.zc b/tests/control_flow/test_guard_unless.zc index d759551..5d58c82 100644 --- a/tests/control_flow/test_guard_unless.zc +++ b/tests/control_flow/test_guard_unless.zc @@ -17,7 +17,7 @@ test "test_guard_unless" { println "Testing guard and unless..."; // Unless with true condition (should NOT enter block) - var res1 = check_positive(10); + let res1 = check_positive(10); if (res1 == 20) { println " -> unless (pass condition): Passed"; } else { @@ -26,7 +26,7 @@ test "test_guard_unless" { } // Unless with false condition (should enter block) - var res2 = check_positive(-5); + let res2 = check_positive(-5); if (res2 == -1) { println " -> unless (fail condition): Passed"; } else { @@ -35,9 +35,9 @@ test "test_guard_unless" { } // Guard with valid pointer - var val = 42; - var p = &val; - var res3 = safe_access(p); + let val = 42; + let p = &val; + let res3 = safe_access(p); if (res3 == 42) { println " -> guard (valid ptr): Passed"; } else { @@ -46,7 +46,7 @@ test "test_guard_unless" { } // Guard with null pointer - var res4 = safe_access(NULL); + let res4 = safe_access(NULL); if (res4 == -999) { println " -> guard (null ptr): Passed"; } else { diff --git a/tests/control_flow/test_if.zc b/tests/control_flow/test_if.zc index 463405a..ed0f43d 100644 --- a/tests/control_flow/test_if.zc +++ b/tests/control_flow/test_if.zc @@ -1,10 +1,10 @@ test "test_if" { - var x = 10; + let x = 10; if (x > 5) { printf("X is big\n"); - var y = x * 2; + let y = x * 2; if (y > 15) { printf("Y is very big\n"); } @@ -12,7 +12,7 @@ test "test_if" { printf("X is small\n"); } - var i = 0; + let i = 0; while (i < 3) { println "Loop {i}"; i++; diff --git a/tests/control_flow/test_labeled_break.zc b/tests/control_flow/test_labeled_break.zc index 1900a99..f5ae5c0 100644 --- a/tests/control_flow/test_labeled_break.zc +++ b/tests/control_flow/test_labeled_break.zc @@ -1,7 +1,7 @@ test "test_labeled_break" -> int { // Test basic goto-based loop exit - var result = 0; + let result = 0; for i in 0..10 { for j in 0..10 { @@ -16,7 +16,7 @@ done_search: assert result == 3; // Test do-while - var x = 0; + let x = 0; do { x++; } while x < 3; diff --git a/tests/control_flow/test_loop_edge_cases.zc b/tests/control_flow/test_loop_edge_cases.zc index b5ab0ce..5bd8b07 100644 --- a/tests/control_flow/test_loop_edge_cases.zc +++ b/tests/control_flow/test_loop_edge_cases.zc @@ -3,7 +3,7 @@ test "test_loop_edge_cases" { println "Testing loop edge cases..."; // Empty range (0..0 should not iterate) - var count1 = 0; + let count1 = 0; for i in 0..0 { count1++; } @@ -15,7 +15,7 @@ test "test_loop_edge_cases" { } // Single iteration range (0..1) - var count2 = 0; + let count2 = 0; for i in 0..1 { count2++; } @@ -27,7 +27,7 @@ test "test_loop_edge_cases" { } // Repeat 0 times (should not execute) - var count3 = 0; + let count3 = 0; repeat 0 { count3++; } @@ -39,7 +39,7 @@ test "test_loop_edge_cases" { } // Repeat 1 time - var count4 = 0; + let count4 = 0; repeat 1 { count4++; } @@ -51,7 +51,7 @@ test "test_loop_edge_cases" { } // Nested loops - var total = 0; + let total = 0; for i in 0..3 { for j in 0..2 { total = total + 1; @@ -65,10 +65,10 @@ test "test_loop_edge_cases" { } // Break in nested loop - var outer_count = 0; + let outer_count = 0; for i in 0..3 { outer_count = outer_count + 1; - var inner_done = 0; + let inner_done = 0; loop { inner_done = inner_done + 1; if (inner_done >= 2) { @@ -84,7 +84,7 @@ test "test_loop_edge_cases" { } // Large step value - var count7 = 0; + let count7 = 0; for i in 0..100 step 25 { count7++; } diff --git a/tests/control_flow/test_loops.zc b/tests/control_flow/test_loops.zc index 60ccc50..64579d3 100644 --- a/tests/control_flow/test_loops.zc +++ b/tests/control_flow/test_loops.zc @@ -3,7 +3,7 @@ test "test_loops" { println "Testing loop constructs..."; // for-in range - var sum1 = 0; + let sum1 = 0; for i in 0..5 { sum1 += i; } @@ -11,7 +11,7 @@ test "test_loops" { println " -> for-in range (0..5): Passed"; // for-in with step - var sum2 = 0; + let sum2 = 0; for i in 0..10 step 2 { sum2 += i; } @@ -19,7 +19,7 @@ test "test_loops" { println " -> for-in with step: Passed"; // Repeat n times - var count = 0; + let count = 0; repeat 7 { count++; } @@ -27,7 +27,7 @@ test "test_loops" { println " -> repeat 7: Passed"; // loop with break - var i = 0; + let i = 0; loop { i++; if (i >= 5) { @@ -38,7 +38,7 @@ test "test_loops" { println " -> loop with break: Passed"; // While loop - var j = 0; + let j = 0; while j < 3 { j++; } @@ -46,16 +46,16 @@ test "test_loops" { println " -> while loop: Passed"; // C-style for loop - var sum3 = 0; - for (var k = 0; k < 4; k = k + 1) { + let sum3 = 0; + for (let k = 0; k < 4; k = k + 1) { sum3 += k; } assert(sum3 == 6, "C-style for loop failed"); println " -> C-style for loop: Passed"; // loop with continue - var sum4 = 0; - var m = 0; + let sum4 = 0; + let m = 0; loop { m++; if (m == 3) { @@ -76,7 +76,7 @@ test "test_loops" { } fn print_nums(list: [int]) { - var i = 0; + let i = 0; while (i < list.len) { println "Num: {list.data[i]}"; i++; @@ -85,12 +85,12 @@ fn print_nums(list: [int]) { test "test_arrays_loop" { // Array literal transformation - var nums: [int] = [10, 20, 30]; + let nums: [int] = [10, 20, 30]; print_nums(nums); } test "test_do_while" { - var x = 0; + let x = 0; // Basic do-while (runs at least once) do { @@ -100,7 +100,7 @@ test "test_do_while" { assert(x == 5, "do-while x expected 5"); // Do-while with false condition (still runs once) - var y = 0; + let y = 0; do { y = 100; } while false; @@ -112,17 +112,17 @@ test "test_range_loops_generic" { println "Testing range loops with different types..."; // Test with isize variables - var sum_isize: isize = 0; - var start: isize = 0; - var end: isize = 5; - for var i: isize = start; i < end; i++ { + let sum_isize: isize = 0; + let start: isize = 0; + let end: isize = 5; + for let i: isize = start; i < end; i++ { sum_isize += i; } println "isize range (0..5): sum = {sum_isize}"; assert(sum_isize == 10, "isize range failed"); // Test with regular int - var sum_int = 0; + let sum_int = 0; for i in 0..5 { sum_int += i; } @@ -133,7 +133,7 @@ test "test_range_loops_generic" { } test "inclusive range basic" { - var count1 = 0 + let count1 = 0 for i in 0..=5 { count1 += 1 } @@ -141,7 +141,7 @@ test "inclusive range basic" { } test "inclusive range single" { - var count2 = 0 + let count2 = 0 for i in 0..=0 { count2 += 1 } @@ -149,7 +149,7 @@ test "inclusive range single" { } test "inclusive range with step" { - var sum = 0 + let sum = 0 for i in 0..=10 step 2 { sum += i } @@ -158,7 +158,7 @@ test "inclusive range with step" { } test "exclusive range regression check" { - var count3 = 0 + let count3 = 0 for i in 0..5 { count3 += 1 } @@ -166,7 +166,7 @@ test "exclusive range regression check" { } test "explicit exclusive range (..<)" { - var count4 = 0 + let count4 = 0 for i in 0..<5 { count4 += 1 } diff --git a/tests/control_flow/test_match.zc b/tests/control_flow/test_match.zc index ca185ae..00c62e3 100644 --- a/tests/control_flow/test_match.zc +++ b/tests/control_flow/test_match.zc @@ -35,7 +35,7 @@ test "test_match" { println "Testing match expressions..."; // Match with exact value (0) - var res1 = classify_number(0); + let res1 = classify_number(0); if (res1 == 100) { println " -> match 0: Passed"; } else { @@ -44,7 +44,7 @@ test "test_match" { } // Match with exact value (1) - var res2 = classify_number(1); + let res2 = classify_number(1); if (res2 == 200) { println " -> match 1: Passed"; } else { @@ -53,7 +53,7 @@ test "test_match" { } // Match with exact value (2) - var res3 = classify_number(2); + let res3 = classify_number(2); if (res3 == 300) { println " -> match 2: Passed"; } else { @@ -62,7 +62,7 @@ test "test_match" { } // Match with default case - var res4 = classify_number(99); + let res4 = classify_number(99); if (res4 == -1) { println " -> match default: Passed"; } else { @@ -71,7 +71,7 @@ test "test_match" { } // Match with complex body (zero) - var sign1 = get_sign(0); + let sign1 = get_sign(0); if (strcmp(sign1, "zero") == 0) { println " -> match complex (zero): Passed"; } else { @@ -80,7 +80,7 @@ test "test_match" { } // Match with complex body (positive) - var sign2 = get_sign(42); + let sign2 = get_sign(42); if (strcmp(sign2, "positive") == 0) { println " -> match complex (positive): Passed"; } else { @@ -89,7 +89,7 @@ test "test_match" { } // Match with complex body (negative) - var sign3 = get_sign(-10); + let sign3 = get_sign(-10); if (strcmp(sign3, "negative") == 0) { println " -> match complex (negative): Passed"; } else { @@ -98,8 +98,8 @@ test "test_match" { } // OR pattern with || - var or1 = classify_extended(1); - var or2 = classify_extended(2); + let or1 = classify_extended(1); + let or2 = classify_extended(2); if (or1 == 100 && or2 == 100) { println " -> match OR (||): Passed"; } else { @@ -108,8 +108,8 @@ test "test_match" { } // OR pattern with 'or' - var or3 = classify_extended(3); - var or4 = classify_extended(4); + let or3 = classify_extended(3); + let or4 = classify_extended(4); if (or3 == 200 && or4 == 200) { println " -> match OR (or): Passed"; } else { @@ -118,9 +118,9 @@ test "test_match" { } // Range exclusive (5..8 matches 5, 6, 7) - var r5 = classify_extended(5); - var r7 = classify_extended(7); - var r8 = classify_extended(8); // Should NOT match + let r5 = classify_extended(5); + let r7 = classify_extended(7); + let r8 = classify_extended(8); // Should NOT match if (r5 == 300 && r7 == 300 && r8 == -1) { println " -> match range exclusive: Passed"; } else { @@ -129,9 +129,9 @@ test "test_match" { } // Range inclusive (10..=15 matches 10-15) - var r10 = classify_extended(10); - var r15 = classify_extended(15); - var r16 = classify_extended(16); // Should NOT match + let r10 = classify_extended(10); + let r15 = classify_extended(15); + let r16 = classify_extended(16); // Should NOT match if (r10 == 400 && r15 == 400 && r16 == -1) { println " -> match range inclusive: Passed"; } else { diff --git a/tests/control_flow/test_ternary.zc b/tests/control_flow/test_ternary.zc index cfac28b..39f066f 100644 --- a/tests/control_flow/test_ternary.zc +++ b/tests/control_flow/test_ternary.zc @@ -5,8 +5,8 @@ enum Result { } fn test_unwrap() -> Result { - var res = Result_Ok(42); - var val = res?; + let res = Result_Ok(42); + let val = res?; if (val == 42) println " Unwrap: Success"; else println " Unwrap: Failed"; return res; @@ -16,7 +16,7 @@ test "test_ternary" { println "Testing Ternary..."; // Simple Ternary - var x = 1 ? 10 : 20; + let x = 1 ? 10 : 20; if (x == 10) println " Simple Ternary: Success"; else println " Simple Ternary: Failed"; @@ -25,6 +25,6 @@ test "test_ternary" { // Ambiguity / Precredence // 1 ? 2 : 3 - var y = 0 ? 100 : 200; + let y = 0 ? 100 : 200; if (y == 200) println " False Branch: Success"; } diff --git a/tests/features/test_alias.zc b/tests/features/test_alias.zc index 5ec14f1..e3f71b3 100644 --- a/tests/features/test_alias.zc +++ b/tests/features/test_alias.zc @@ -39,18 +39,18 @@ alias Vec2f = Vec2<f32>; alias Vec2i = Vec2<int>; test "alias basic" { - var x: MyInt = 10; - var ptr: MyIntPtr = &x; + let x: MyInt = 10; + let ptr: MyIntPtr = &x; assert(x == 10, "Basic alias failed"); assert(*ptr == 10, "Pointer alias failed"); - var res = process(x); + let res = process(x); assert(res == 11, "Function with alias arg failed"); } test "alias struct" { - var p: Point = Point{x: 0, y: 0}; + let p: Point = Point{x: 0, y: 0}; p.x = 100; p.y = 200; @@ -58,30 +58,30 @@ test "alias struct" { } test "alias generic struct" { - var v = Vec2f{x: 1.5, y: 2.5}; + let v = Vec2f{x: 1.5, y: 2.5}; assert(v.x > 1.0, "Generic alias field access failed"); assert(v.y > 2.0, "Generic alias field access failed"); - var vi = Vec2i{x: 10, y: 20}; + let vi = Vec2i{x: 10, y: 20}; assert(vi.x == 10, "Generic int alias failed"); assert(vi.y == 20, "Generic int alias failed"); } test "alias fstring" { - var v = Vec2f{x: 3.14, y: 6.28}; + let v = Vec2f{x: 3.14, y: 6.28}; // This tests that f-string interpolation correctly resolves the alias println "v.x = {v.x}, v.y = {v.y}"; } test "alias function pointer" { - // var op: BinOp; + // let op: BinOp; // Assignment currently not supported for function types without casting // op = add; // assert(op(1, 2) == 3, "Function alias"); } test "alias operator overloading" { - var v = Vec2f{x: 1.0, y: 1.0}; + let v = Vec2f{x: 1.0, y: 1.0}; v = -v; // Should call __neg assert(v.x == -1.0, "Unary operator generic alias failed"); @@ -89,7 +89,7 @@ test "alias operator overloading" { assert(v.x == -2.0, "Compound assignment generic alias failed"); // Control - var v2 = Vec2<f32>{x: 1.0, y: 1.0}; + let v2 = Vec2<f32>{x: 1.0, y: 1.0}; v2 = -v2; v2 += v2; assert(v2.x == -2.0, "Control generic operator overloading failed"); @@ -97,11 +97,11 @@ test "alias operator overloading" { test "alias static methods" { - var v1 = Vec2f::zero(); + let v1 = Vec2f::zero(); assert(v1.x == 0.0, "Direct static call on alias failed"); println "Static call in f-string: {Vec2f::zero().x}"; - var v2 = Vec2<f32>::zero(); + let v2 = Vec2<f32>::zero(); assert(v2.x == 0.0, "Direct static call on generic failed"); } diff --git a/tests/features/test_asm.zc b/tests/features/test_asm.zc index 01f35d5..02d268d 100644 --- a/tests/features/test_asm.zc +++ b/tests/features/test_asm.zc @@ -32,7 +32,7 @@ test "test_asm" { } fn add_five(x: int) -> int { - var result: int; + let result: int; asm { "mov {x}, {result}" "add $5, {result}" @@ -44,7 +44,7 @@ fn add_five(x: int) -> int { test "test_asm_params" { println "Testing assembly parameters..."; - var val = add_five(10); + let val = add_five(10); if (val == 15) { println "-> Success! add_five(10) = 15"; } else { diff --git a/tests/features/test_auto_deref.zc b/tests/features/test_auto_deref.zc index b7b0c51..5d1cf40 100644 --- a/tests/features/test_auto_deref.zc +++ b/tests/features/test_auto_deref.zc @@ -5,8 +5,8 @@ struct Point { } test "auto_deref" { - var p = Point { x: 10, y: 20 }; - var ptr = &p; + let p = Point { x: 10, y: 20 }; + let ptr = &p; // This uses the dot operator on a pointer // In standard C, this requires ->. In Zen-C w/ Auto-Deref, . should work. @@ -17,9 +17,9 @@ test "auto_deref" { assert(ptr.y == 30, "read ptr.y after write failed"); - var i = Inner { val: 42 }; - var o = Outer { inner: i }; - var p_out = &o; + let i = Inner { val: 42 }; + let o = Outer { inner: i }; + let p_out = &o; // Nested access: p.inner.val -> p->inner.val assert(p_out.inner.val == 42, "Nested access failed"); diff --git a/tests/features/test_bool_mutability.zc b/tests/features/test_bool_mutability.zc index 553e871..5426b6f 100644 --- a/tests/features/test_bool_mutability.zc +++ b/tests/features/test_bool_mutability.zc @@ -1,7 +1,7 @@ test "boolean_mutability" { - // Regression test for issue where 'var b = true' was inferred as const - var b = true; + // Regression test for issue where 'let b = true' was inferred as const + let b = true; assert(b, "Expected true"); // This assignment should be valid (previously failed with 'Cannot assign to const variable') @@ -9,7 +9,7 @@ test "boolean_mutability" { assert(!b, "Expected false after assignment"); // Verify explicit type works too - var c: bool = true; + let c: bool = true; c = false; assert(!c, "Expected false for explicit type"); } diff --git a/tests/features/test_build_directives.zc b/tests/features/test_build_directives.zc index d6e35b3..7edd317 100644 --- a/tests/features/test_build_directives.zc +++ b/tests/features/test_build_directives.zc @@ -6,8 +6,8 @@ extern fn sin(x: double) -> double; test "test_build_directives" { println "Running Build Directives Test..."; - var x = 3.14159 / 2.0; // PI/2 - var s = sin(x); + let x = 3.14159 / 2.0; // PI/2 + let s = sin(x); // sin(PI/2) should be 1.0 println "sin(PI/2) = {s}"; diff --git a/tests/features/test_comptime_suite.zc b/tests/features/test_comptime_suite.zc index b8127ec..677e0ff 100644 --- a/tests/features/test_comptime_suite.zc +++ b/tests/features/test_comptime_suite.zc @@ -17,7 +17,7 @@ test "test_comptime_block" { } test "test_comptime_attr" { - var x = double_ct(21); + let x = double_ct(21); assert(x == 42, "Comptime function failed"); println "Comptime function called successfully"; } diff --git a/tests/features/test_concurrency_suite.zc b/tests/features/test_concurrency_suite.zc index aa7512a..a0b571b 100644 --- a/tests/features/test_concurrency_suite.zc +++ b/tests/features/test_concurrency_suite.zc @@ -29,48 +29,48 @@ struct Counter { } test "test_async_basics" { - var future1 = double_slowly(21); - var future2 = add_async(10, 20); + let future1 = double_slowly(21); + let future2 = add_async(10, 20); - var result1 = await future1; - var result2 = await future2; + let result1 = await future1; + let result2 = await future2; assert(result1 == 42, "Async double failed"); assert(result2 == 30, "Async add failed"); } test "test_async_struct_return" { - var f = make_point(5, 7); - var p = await f; + let f = make_point(5, 7); + let p = await f; assert(p.x == 5, "Async struct x failed"); assert(p.y == 7, "Async struct y failed"); } test "test_async_void" { - var f = say_hello(); + let f = say_hello(); await f; } test "test_thread" { println "Testing Concurrency..."; - var c = (Counter*)malloc(sizeof(Counter)); + let c = (Counter*)malloc(sizeof(Counter)); c.val = 0; c.lock = Mutex::new(); def N = 10000; - var t1_res = Thread::spawn(fn() { - for (var i=0; i<N; ++i) { + let t1_res = Thread::spawn(fn() { + for (let i=0; i<N; ++i) { c.lock.lock(); c.val = c.val + 1; c.lock.unlock(); } }); - var t2_res = Thread::spawn(fn() { - for (var i=0; i<N; ++i) { + let t2_res = Thread::spawn(fn() { + for (let i=0; i<N; ++i) { c.lock.lock(); c.val = c.val + 1; c.lock.unlock(); @@ -80,15 +80,15 @@ test "test_thread" { assert(t1_res.is_err() == false, "T1 failed to spawn"); assert(t2_res.is_err() == false, "T2 failed to spawn"); - var t1 = t1_res.unwrap(); - var t2 = t2_res.unwrap(); + let t1 = t1_res.unwrap(); + let t2 = t2_res.unwrap(); t1.join(); t2.join(); println "Final Count: {c.val} (Expected {2 * N})"; - var final_val = c.val; + let final_val = c.val; c.lock.free(); free(c); diff --git a/tests/features/test_const_def.zc b/tests/features/test_const_def.zc index b104196..8c548ae 100644 --- a/tests/features/test_const_def.zc +++ b/tests/features/test_const_def.zc @@ -6,7 +6,7 @@ test "def_constants" { assert(MAX == 100, "def constant value mismatch"); // PI check (float) - exact match might be tricky but 3.14159 is literal - var x = MAX; + let x = MAX; assert(x == 100, "Assign from def"); } @@ -20,12 +20,12 @@ test "def_scoping" { } test "const_type_qualifier" { - var x: const int = 10; + let x: const int = 10; assert(x == 10, "const Var init"); - // Address of const var should be allowed - var p: const int* = &x; - assert(*p == 10, "Pointer to const var"); + // Address of const let should be allowed + let p: const int* = &x; + assert(*p == 10, "Pointer to const let"); } // Note: Negative tests (compilation failures) are hard to test in this harness currently diff --git a/tests/features/test_default_args.zc b/tests/features/test_default_args.zc index cbeba83..6e98813 100644 --- a/tests/features/test_default_args.zc +++ b/tests/features/test_default_args.zc @@ -16,16 +16,16 @@ fn operation(a: int, b: int = 5 * 2) -> int { } fn main() { - var p1 = Point { x: 5, y: 5 }; - var res1 = add_points(p1); + let p1 = Point { x: 5, y: 5 }; + let res1 = add_points(p1); println "res1.x: {res1.x}, res1.y: {res1.y}"; assert(res1.x == 15, "result is not 15"); assert(res1.y == 15, "result is not 15"); - var p2 = Point { x: 1, y: 1 }; - var p3 = Point { x: 5, y: 5 }; - var res2 = add_points(p3, p2); + let p2 = Point { x: 1, y: 1 }; + let p3 = Point { x: 5, y: 5 }; + let res2 = add_points(p3, p2); println "res2.x: {res2.x}, res2.y: {res2.y}"; assert(res2.x == 6, "result is not 6"); diff --git a/tests/features/test_defer_control_flow.zc b/tests/features/test_defer_control_flow.zc index 40c7f37..e459134 100644 --- a/tests/features/test_defer_control_flow.zc +++ b/tests/features/test_defer_control_flow.zc @@ -1,6 +1,6 @@ test "defer_runs_on_break" { - var result = 0; + let result = 0; for i in 0..5 { defer { result = result + 1; } @@ -14,7 +14,7 @@ test "defer_runs_on_break" { } test "defer_runs_on_continue" { - var result = 0; + let result = 0; for i in 0..5 { defer { result = result + 1; } @@ -28,7 +28,7 @@ test "defer_runs_on_continue" { } fn early_return(x: int) -> int { - var side_effect = 0; + let side_effect = 0; defer { side_effect = 42; } if x > 0 { @@ -39,12 +39,12 @@ fn early_return(x: int) -> int { } test "defer_runs_on_return" { - var result = early_return(10); + let result = early_return(10); assert(result == 10, "early return should work with defer"); } test "defer_lifo_order" { - var result = 0; + let result = 0; for i in 0..2 { defer { result = result * 10 + 1; } @@ -59,8 +59,8 @@ test "defer_lifo_order" { } test "nested_loops_defer" { - var outer_count = 0; - var inner_count = 0; + let outer_count = 0; + let inner_count = 0; for i in 0..3 { defer { outer_count = outer_count + 1; } diff --git a/tests/features/test_destructuring.zc b/tests/features/test_destructuring.zc index b898582..3e24001 100644 --- a/tests/features/test_destructuring.zc +++ b/tests/features/test_destructuring.zc @@ -13,24 +13,24 @@ fn tuple_ret() -> (int, int) { } test "test_destructuring" { - var p = Point{x: 1, y: 2}; + let p = Point{x: 1, y: 2}; // Explicit Struct Destructuring (Shorthand) - var Point{x, y} = p; + let Point{x, y} = p; assert(x == 1, "x is 1"); assert(y == 2, "y is 2"); // Explicit Struct Destructuring (Renamed) - var Point{x: a, y: b} = p; + let Point{x: a, y: b} = p; assert(a == 1, "a is 1"); assert(b == 2, "b is 2"); // Anonymous Struct Destructuring (Inferred) // Note: Anonymous block only supports shorthand {x, y} currently. - // var {x: x2} = p; // Not supported yet in anonymous block parser + // let {x: x2} = p; // Not supported yet in anonymous block parser // Tuple Destructuring - var (t1, t2) = tuple_ret(); + let (t1, t2) = tuple_ret(); assert(t1 == 10, "t1 is 10"); assert(t2 == 20, "t2 is 20"); diff --git a/tests/features/test_embed.zc b/tests/features/test_embed.zc index 33acef2..ad7247c 100644 --- a/tests/features/test_embed.zc +++ b/tests/features/test_embed.zc @@ -2,22 +2,22 @@ test "test_embed" { "=> Static File Analyzer"; - var data = embed "std.zc"; + let data = embed "std.zc"; "Target File: 'std.zc'"; "File Size: {data.len} bytes"; ""; - var lines: I32 = 1; - var words: I32 = 0; - var sum: U64 = 0; - var in_word: bool = 0; + let lines: I32 = 1; + let words: I32 = 0; + let sum: U64 = 0; + let in_word: bool = 0; "Analyzing content..."; - var i: int = 0; + let i: int = 0; while (i < data.len) { - var c: char = data.data[i]; + let c: char = data.data[i]; match c { '\n' => { @@ -37,7 +37,7 @@ test "test_embed" { } } - var b: U8 = c; + let b: U8 = c; sum = sum + b; i++; @@ -57,7 +57,7 @@ test "test_embed" { test "typed_embed" { // String - var s = embed "tests/features/embed_data.txt" as string; + let s = embed "tests/features/embed_data.txt" as string; // "Hello World!\n" ? No newline in my file creation? // echo "Hello World!" > ... likely adds newline. // My previous tool 'write_to_file' wrote "Hello World!". It usually doesn't add newline unless specified? @@ -65,17 +65,17 @@ test "typed_embed" { if (s[0] != 'H') exit(101); // Fixed array - var arr = embed "tests/features/embed_data.txt" as u8[5]; + let arr = embed "tests/features/embed_data.txt" as u8[5]; if (arr[0] != 'H') exit(102); if (arr[4] != 'o') exit(103); // Slice - var sl = embed "tests/features/embed_data.txt" as u8[]; + let sl = embed "tests/features/embed_data.txt" as u8[]; if (sl.len < 5) exit(104); if (sl.data[0] != 'H') exit(105); // Untyped regression - var raw = embed "tests/features/embed_data.txt"; + let raw = embed "tests/features/embed_data.txt"; if (raw.len < 5) exit(106); if (raw.data[0] != 'H') exit(107); diff --git a/tests/features/test_enum_tuples.zc b/tests/features/test_enum_tuples.zc index 12d9088..7e43bad 100644 --- a/tests/features/test_enum_tuples.zc +++ b/tests/features/test_enum_tuples.zc @@ -5,9 +5,9 @@ enum Shape { } fn main() { - var r = Shape.Rect(10.0, 20.0); + let r = Shape.Rect(10.0, 20.0); - var matched = 0; + let matched = 0; match r { Shape::Rect(w, h) => { assert(w == 10.0, "w == 10.0"); @@ -20,7 +20,7 @@ fn main() { } assert(matched == 1, "Matched Rect"); - var c = Shape.Circle(5.0); + let c = Shape.Circle(5.0); match c { Shape::Circle(val) => { assert(val == 5.0, "val == 5.0"); diff --git a/tests/features/test_fstring.zc b/tests/features/test_fstring.zc index b2a8f36..cb46cda 100644 --- a/tests/features/test_fstring.zc +++ b/tests/features/test_fstring.zc @@ -2,7 +2,7 @@ import "tests/features/_fstring_mod.zc" as Mod; test "alias namespace fstring" { // Tests that {Mod::get_val()} is parsed correctly (Mod_get_val) - var res = f"{Mod::get_val()}"; + let res = f"{Mod::get_val()}"; assert(res == "42", "Import namespace in f-string failed"); // Check local string formatting via println (compile check) @@ -15,7 +15,7 @@ test "alias C header fstring" { // Tests that {Lib::lib_val()} resolves to lib_val() (no mangling/prefix) // parser_expr.c strips alias for C headers. // parser_utils.c rewrite_expr_methods needs to do the same. - var res = f"{Lib::lib_val()}"; + let res = f"{Lib::lib_val()}"; assert(res == "99", "C header namespace in f-string failed"); // Verify println (rewrite_expr_methods path) diff --git a/tests/features/test_intel.zc b/tests/features/test_intel.zc index 8547501..3b88178 100644 --- a/tests/features/test_intel.zc +++ b/tests/features/test_intel.zc @@ -1,7 +1,7 @@ //> cflags: -masm=intel fn add_five_intel(x: int) -> int { - var result: int; + let result: int; asm { "mov {result}, {x}" "add {result}, 5" @@ -12,7 +12,7 @@ fn add_five_intel(x: int) -> int { } test "test_intel" { - var val = add_five_intel(10); + let val = add_five_intel(10); "Sum Intel: 10 + 5 = {val}"; match val { diff --git a/tests/features/test_iterator.zc b/tests/features/test_iterator.zc index 1340a00..6efd413 100644 --- a/tests/features/test_iterator.zc +++ b/tests/features/test_iterator.zc @@ -9,7 +9,7 @@ struct RangeIter { impl RangeIter { fn next(self) -> Option<int> { if (self.current < self.stop) { - var v = self.current; + let v = self.current; self.current += 1; return Option<int>::Some(v); } @@ -32,8 +32,8 @@ impl MyRange { } test "iterator_desugaring" { - var range = MyRange { start: 0, end: 5 }; - var sum = 0; + let range = MyRange { start: 0, end: 5 }; + let sum = 0; // This loop should be desugared by the compiler for i in range { diff --git a/tests/features/test_iterator_drop.zc b/tests/features/test_iterator_drop.zc index 43e22a7..bc513df 100644 --- a/tests/features/test_iterator_drop.zc +++ b/tests/features/test_iterator_drop.zc @@ -1,7 +1,7 @@ import "../../std/iter.zc" import "../../std/mem.zc" -var DROP_CALLED = 0; +let DROP_CALLED = 0; struct DropIter { count: int; @@ -36,10 +36,10 @@ impl DropRange { test "iterator_drop" { { - var range = DropRange { len: 3 }; + let range = DropRange { len: 3 }; for i in range { // Loop runs 3 times - var _ignore = i; + let _ignore = i; } // Iterator should be dropped here } diff --git a/tests/features/test_match_composition.zc b/tests/features/test_match_composition.zc index f25b90f..1015a1f 100644 --- a/tests/features/test_match_composition.zc +++ b/tests/features/test_match_composition.zc @@ -25,13 +25,13 @@ enum MixinResult { // Test match binding with named composition - field access test "match_binding_named_composition" { - var inner = Inner { value: 42 }; - var wrapper = NamedWrapper { inner: inner }; - var result = NamedResult::Ok(wrapper); + let inner = Inner { value: 42 }; + let wrapper = NamedWrapper { inner: inner }; + let result = NamedResult::Ok(wrapper); match result { NamedResult::Ok(w) => { - var val = w.inner.value; + let val = w.inner.value; assert(val == 42, "Named composition field access failed"); }, NamedResult::Err(e) => assert(false, "Should not be Err") @@ -40,12 +40,12 @@ test "match_binding_named_composition" { // Test match binding with mixin composition - field access test "match_binding_mixin_composition" { - var wrapper = MixinWrapper { value: 77 }; - var result = MixinResult::Ok(wrapper); + let wrapper = MixinWrapper { value: 77 }; + let result = MixinResult::Ok(wrapper); match result { MixinResult::Ok(w) => { - var val = w.value; + let val = w.value; assert(val == 77, "Mixin composition field access failed"); }, MixinResult::Err(e) => assert(false, "Should not be Err") @@ -54,8 +54,8 @@ test "match_binding_mixin_composition" { // Test match binding with mixin - f-string interpolation test "match_binding_mixin_fstring" { - var wrapper = MixinWrapper { value: 88 }; - var result = MixinResult::Ok(wrapper); + let wrapper = MixinWrapper { value: 88 }; + let result = MixinResult::Ok(wrapper); match result { MixinResult::Ok(w) => { @@ -68,8 +68,8 @@ test "match_binding_mixin_fstring" { // Test match binding with ref - mixin composition test "match_binding_ref_mixin" { - var wrapper = MixinWrapper { value: 33 }; - var result = MixinResult::Ok(wrapper); + let wrapper = MixinWrapper { value: 33 }; + let result = MixinResult::Ok(wrapper); match result { MixinResult::Ok(ref w) => { @@ -90,9 +90,9 @@ test "match_binding_ref_mixin" { // Test match binding with ref - named composition test "match_binding_ref_named" { - var inner = Inner { value: 55 }; - var wrapper = NamedWrapper { inner: inner }; - var result = NamedResult::Ok(wrapper); + let inner = Inner { value: 55 }; + let wrapper = NamedWrapper { inner: inner }; + let result = NamedResult::Ok(wrapper); match result { NamedResult::Ok(ref w) => { diff --git a/tests/features/test_match_ref.zc b/tests/features/test_match_ref.zc index 0442dc7..45ab0f4 100644 --- a/tests/features/test_match_ref.zc +++ b/tests/features/test_match_ref.zc @@ -5,7 +5,7 @@ enum MyOption<T> { } test "match_ref_int" { - var r = MyOption<int>::Some(42); + let r = MyOption<int>::Some(42); match r { MyOption::Some(ref i) => { // i is int* @@ -21,9 +21,9 @@ struct Mover { } test "match_ref_mover" { - var m = Mover { val: 100 }; + let m = Mover { val: 100 }; // MyOption<Mover> instantiation - var opt = MyOption<Mover>::Some(m); + let opt = MyOption<Mover>::Some(m); match opt { MyOption::Some(ref x) => { @@ -50,9 +50,9 @@ enum Test { } test "match ref binding concrete" { - var t = Test::ONE(Hello{ world: 123 }); + let t = Test::ONE(Hello{ world: 123 }); - var val = 0; + let val = 0; match t { Test::ONE(ref o) => { // o should be Hello* diff --git a/tests/features/test_mixin_methods.zc b/tests/features/test_mixin_methods.zc index 0932429..f69ae7c 100644 --- a/tests/features/test_mixin_methods.zc +++ b/tests/features/test_mixin_methods.zc @@ -19,11 +19,11 @@ struct Bar { } test "test_mixin_methods" { - var b: Bar; + let b: Bar; b.i = 42; b.f = 3.14; - var val = b.get_i(); + let val = b.get_i(); assert(val == 42, "Mixin method get_i() should return 42"); b.set_i(100); diff --git a/tests/features/test_operators_suite.zc b/tests/features/test_operators_suite.zc index cf0f4c2..f4d18d8 100644 --- a/tests/features/test_operators_suite.zc +++ b/tests/features/test_operators_suite.zc @@ -54,10 +54,10 @@ fn make_err(e: int) -> Result { } fn process_result(fail: int) -> Result { - var val = make_ok(10)?; + let val = make_ok(10)?; if (fail) { - var v2 = make_err(500)?; + let v2 = make_err(500)?; return Result_Ok(v2 + 1000); } @@ -74,8 +74,8 @@ fn twice(x: int) -> int { test "test_operator_overloading" { "=> Bitwise Primitives"; - var a = 0b1100; - var b = 0b1010; + let a = 0b1100; + let b = 0b1010; "{a} | {b} = {a | b} (Expected 14)"; "{a} & {b} = {a & b} (Expected 8)"; @@ -83,13 +83,13 @@ test "test_operator_overloading" { "{a} << 1 = {a << 1} (Expected 24)"; "=> Compound Assignment Desugaring"; - var x = 10; + let x = 10; x += 5; // 15 x <<= 1; // 30 "=> Struct Overloading + Compound (|=)"; - var f1 = Flags::new(1); - var f2 = Flags::new(4); + let f1 = Flags::new(1); + let f2 = Flags::new(4); f1 |= f2; "Result bits: {f1.bits} (Expected 5)"; @@ -97,7 +97,7 @@ test "test_operator_overloading" { } test "test_extended_overloading" { - var c = Container::new(10); + let c = Container::new(10); // Index Get assert(c[5] == 15, "Get Failed"); @@ -111,34 +111,34 @@ test "test_extended_overloading" { assert(c.val == 27, "Compound Set Failed"); // Unary Neg - var n = -c; + let n = -c; assert(n.val == -27, "Neg Failed"); // Unary Not assert(!c == false, "Not Operator Failed"); // Unary Bitnot - var b = ~c; + let b = ~c; assert(b.val == ~27, "Bitnot Failed"); } test "test_pipe_operator" { - var res = 5 |> twice; + let res = 5 |> twice; assert(res == 10, "Pipe twice failed"); - var res2 = 10 |> add(20); + let res2 = 10 |> add(20); assert(res2 == 30, "Pipe add failed"); - var res3 = 5 |> twice |> add(10); // 20 + let res3 = 5 |> twice |> add(10); // 20 assert(res3 == 20, "Multi-pipe failed"); } test "test_try_operator" { - var res_ok = process_result(0); + let res_ok = process_result(0); assert(res_ok.tag == Result_Ok_Tag, "Expected Ok"); assert(res_ok.data.Ok == 30, "Expected 30"); - var res_err = process_result(1); + let res_err = process_result(1); assert(res_err.tag == Result_Err_Tag, "Expected Err"); assert(res_err.data.Err == 500, "Expected Err(500)"); } diff --git a/tests/features/test_smart_derive.zc b/tests/features/test_smart_derive.zc index 705a12f..b005080 100644 --- a/tests/features/test_smart_derive.zc +++ b/tests/features/test_smart_derive.zc @@ -6,8 +6,8 @@ struct Container { // Ensure derived eq uses pointers by trying to use 'c2' after comparison test "eq_moves" { - var c1 = Container { val: 10 }; - var c2 = Container { val: 10 }; + let c1 = Container { val: 10 }; + let c2 = Container { val: 10 }; // This should call Container__eq(&c1, &c2) // If it passed by value, c2 would be moved here diff --git a/tests/features/test_traits_suite.zc b/tests/features/test_traits_suite.zc index 8410de8..205bdf6 100644 --- a/tests/features/test_traits_suite.zc +++ b/tests/features/test_traits_suite.zc @@ -61,19 +61,19 @@ fn print_shape_info(s: Shape) { } test "basic_traits" { - var r: Robot = Robot { id: 42 }; - var g: Greeter = &r; + let r: Robot = Robot { id: 42 }; + let g: Greeter = &r; g.greet("Hello World"); g.shout(); } test "advanced_traits" { - var c = Circle { radius: 5.0 }; - var r = Rectangle { width: 4.0, height: 6.0 }; + let c = Circle { radius: 5.0 }; + let r = Rectangle { width: 4.0, height: 6.0 }; - var s_c: Shape = &c; - var s_r: Shape = &r; + let s_c: Shape = &c; + let s_r: Shape = &r; print_shape_info(s_c); print_shape_info(s_r); @@ -86,33 +86,33 @@ test "advanced_traits" { } test "test_derive" { - var p1 = Point{x: 10, y: 20}; + let p1 = Point{x: 10, y: 20}; // Debug - var s = p1.to_string(); + let s = p1.to_string(); assert(strcmp(s, "Point { ... }") == 0, "Debug string matches"); // Clone - var p2 = p1.clone(); + let p2 = p1.clone(); assert(p2.x == 10, "Clone x matches"); // Eq assert(p1.eq(&p2) == true, "Eq works (true)"); - var p3 = Point{x: 10, y: 21}; + let p3 = Point{x: 10, y: 21}; assert(p1.eq(&p3) == false, "Eq works (false)"); } test "implicit_trait_cast" { - var c = Circle { radius: 10.0 }; + let c = Circle { radius: 10.0 }; // This previously required explicit casting: print_shape_info((Shape)(&c)); print_shape_info(&c); - var r = Rectangle { width: 5.0, height: 5.0 }; + let r = Rectangle { width: 5.0, height: 5.0 }; print_shape_info(&r); } -var g_def_circle = Circle { radius: 2.0 }; +let g_def_circle = Circle { radius: 2.0 }; fn print_default_shape(s: Shape = &g_def_circle) { println "Default Shape: {s.name()}"; @@ -137,8 +137,8 @@ impl UnderscoreTest for UnderscoreStruct { } test "trait_underscores" { - var u = UnderscoreStruct { val: 100 }; - var t: UnderscoreTest = &u; + let u = UnderscoreStruct { val: 100 }; + let t: UnderscoreTest = &u; assert(t.method_with_underscores_123() == 100, "Method with underscores call failed"); } diff --git a/tests/features/test_tuples.zc b/tests/features/test_tuples.zc index bc8b8d8..4bab25d 100644 --- a/tests/features/test_tuples.zc +++ b/tests/features/test_tuples.zc @@ -4,31 +4,31 @@ fn get_pair() -> (int, int) { fn main() { // Inferred type tuple literal - var p = (1, 2); + let p = (1, 2); assert(p.0 == 1, "Tuple access 0"); assert(p.1 == 2, "Tuple access 1"); // Function returning tuple - var p2 = get_pair(); + let p2 = get_pair(); assert(p2.0 == 10, "Tuple return 0"); assert(p2.1 == 20, "Tuple return 1"); // Explicit type tuple - var p3: (int, int) = (5, 6); + let p3: (int, int) = (5, 6); assert(p3.0 == 5, "Explicit tuple 0"); assert(p3.1 == 6, "Explicit tuple 1"); // Different types - var mixed: (int, string) = (10, "Hello"); + let mixed: (int, string) = (10, "Hello"); assert(mixed.0 == 10, "Mixed 0"); assert(strcmp(mixed.1, "Hello") == 0, "Mixed 1 (String)"); // Regression for segfault (inferred tuple with string) - var p_str = (1, "World"); + let p_str = (1, "World"); assert(strcmp(p_str.1, "World") == 0, "Inferred tuple string"); // Tuple destructuring - var (a, b) = get_pair(); + let (a, b) = get_pair(); assert(a == 10, "Destructured a"); assert(b == 20, "Destructured b"); } diff --git a/tests/features/test_unions.zc b/tests/features/test_unions.zc index ee9848b..11ee1a6 100644 --- a/tests/features/test_unions.zc +++ b/tests/features/test_unions.zc @@ -14,11 +14,11 @@ union Shape { } test "union_init" { - var c = Circle{ radius: 10.0 }; - var s = Shape{ circle: c }; + let c = Circle{ radius: 10.0 }; + let s = Shape{ circle: c }; assert(s.circle.radius == 10.0, "s.circle.radius != 10.0"); - var s2 = Shape{}; + let s2 = Shape{}; s2.rect = Rect{ width: 5.0, height: 5.0 }; assert(s2.rect.width == 5.0, "s2.rect.width != 5.0"); } diff --git a/tests/features/test_varargs.zc b/tests/features/test_varargs.zc index b06f66e..376a825 100644 --- a/tests/features/test_varargs.zc +++ b/tests/features/test_varargs.zc @@ -9,11 +9,11 @@ test "Variadic Sum" { } fn sum_all(count: int, ...) -> int { - var total = 0; - var ap: va_list; + let total = 0; + let ap: va_list; va_start(ap, count); - for (var i = 0; i < count; i = i + 1) { + for (let i = 0; i < count; i = i + 1) { total = total + va_arg(ap, int); } diff --git a/tests/features/test_vec_iter.zc b/tests/features/test_vec_iter.zc index b7e8dcb..5877c40 100644 --- a/tests/features/test_vec_iter.zc +++ b/tests/features/test_vec_iter.zc @@ -1,12 +1,12 @@ import "../../std/vec.zc" test "vec_int_iteration" { - var v = Vec<int>::new(); + let v = Vec<int>::new(); v.push(10); v.push(20); v.push(30); - var sum = 0; + let sum = 0; for x in v { sum = sum + x; } diff --git a/tests/functions/test_attributes.zc b/tests/functions/test_attributes.zc index 6e52372..36ca3ad 100644 --- a/tests/functions/test_attributes.zc +++ b/tests/functions/test_attributes.zc @@ -50,8 +50,8 @@ struct NormalStruct { b: U32; } -var init_called = 0; -var cleanup_called = 0; +let init_called = 0; +let cleanup_called = 0; @constructor fn my_init() { @@ -79,18 +79,18 @@ fn unused_func() {} test "function attributes" { // @must_use: result used - no warning - var x = compute(); + let x = compute(); assert(x == 42, "compute() failed"); // No must_use - can discard optional_result(); // @inline works - var sum = fast_add(1, 2); + let sum = fast_add(1, 2); assert(sum == 3, "inline add failed"); // Combined attributes - var c = combined(); + let c = combined(); assert(c == 100, "combined failed"); // @must_use: result verified diff --git a/tests/functions/test_implicit_return.zc b/tests/functions/test_implicit_return.zc index bb35134..e82e286 100644 --- a/tests/functions/test_implicit_return.zc +++ b/tests/functions/test_implicit_return.zc @@ -12,7 +12,7 @@ test "test_implicit_return" { println " Done!"; // With variables - var x = 42; + let x = 42; print "Value is: "; println "{x}"; } diff --git a/tests/functions/test_lambda_arrow.zc b/tests/functions/test_lambda_arrow.zc index 111487d..b4c8edc 100644 --- a/tests/functions/test_lambda_arrow.zc +++ b/tests/functions/test_lambda_arrow.zc @@ -4,24 +4,24 @@ fn compute(op: fn(I32, I32) -> I32, a: I32, b: I32) -> I32 { } test "test_lambda_arrow" { - var doubler = x -> x * 2; - var res1 = doubler(5); + let doubler = x -> x * 2; + let res1 = doubler(5); "doubler(5) = {res1}"; if res1 != 10 { exit(1); } - var add = (x, y) -> x + y; - var res2 = add(10, 20); + let add = (x, y) -> x + y; + let res2 = add(10, 20); "add(10, 20) = {res2}"; if res2 != 30 { exit(1); } - var res3 = compute((a, b) -> a * b, 3, 4); + let res3 = compute((a, b) -> a * b, 3, 4); "compute((a, b) -> a * b, 3, 4) = {res3}"; if res3 != 12 { exit(1); } } test "lambda_inference_repro" { - var dble = x -> x * 2.0; - var res = dble(9.0); + let dble = x -> x * 2.0; + let res = dble(9.0); if res != 18.0 { exit(1); } diff --git a/tests/functions/test_lambdas.zc b/tests/functions/test_lambdas.zc index a0daaf1..24cb65b 100644 --- a/tests/functions/test_lambdas.zc +++ b/tests/functions/test_lambdas.zc @@ -12,8 +12,8 @@ test "test_complex_lambdas" { println "Testing complex lambda scenarios..."; // Lambda with multiple parameters - var add_three = (a, b, c) -> a + b + c; - var res1 = add_three(1, 2, 3); + let add_three = (a, b, c) -> a + b + c; + let res1 = add_three(1, 2, 3); if (res1 == 6) { println " -> Multi-param lambda: Passed"; } else { @@ -22,7 +22,7 @@ test "test_complex_lambdas" { } // Higher-order function - var res2 = apply_twice(x -> x * 2, 5); + let res2 = apply_twice(x -> x * 2, 5); if (res2 == 20) { println " -> Higher-order function: Passed"; } else { @@ -31,8 +31,8 @@ test "test_complex_lambdas" { } // Returning a lambda (closure) - var add10 = make_adder(10); - var res3 = add10(5); + let add10 = make_adder(10); + let res3 = add10(5); if (res3 == 15) { println " -> Returned lambda: Passed"; } else { @@ -41,9 +41,9 @@ test "test_complex_lambdas" { } // Lambda composition - var doubler = x -> x * 2; - var add5 = x -> x + 5; - var res4 = add5(doubler(10)); + let doubler = x -> x * 2; + let add5 = x -> x + 5; + let res4 = add5(doubler(10)); if (res4 == 25) { println " -> Lambda composition: Passed"; } else { @@ -52,7 +52,7 @@ test "test_complex_lambdas" { } // Nested application - var res5 = apply_twice(x -> x + 1, apply_twice(x -> x * 2, 3)); + let res5 = apply_twice(x -> x + 1, apply_twice(x -> x * 2, 3)); // (3 * 2) * 2 = 12, then (12 + 1) + 1 = 14 if (res5 == 14) { println " -> Nested application: Passed"; @@ -62,8 +62,8 @@ test "test_complex_lambdas" { } // Lambda with "fn" syntax (eg. block lambda) - var factor = 2; - var full = fn(x: int) -> int { return x * factor }; + let factor = 2; + let full = fn(x: int) -> int { return x * factor }; if (full(3) == 6) { println " -> Lambda fn syntax: Passed"; @@ -73,7 +73,7 @@ test "test_complex_lambdas" { } // Lambda with "fn" syntax (eg. block lambda) + multiple params - var addition = fn(sum1: int, sum2: int) -> int { return sum1 + sum2 }; + let addition = fn(sum1: int, sum2: int) -> int { return sum1 + sum2 }; if (addition(100, 505) == 605) { println " -> Lambda fn syntax: Passed"; @@ -83,7 +83,7 @@ test "test_complex_lambdas" { } // Lambda with "fn" syntax (eg. block lambda) + named args - var substract = fn(arg1: int, arg2: int) -> int { return arg1 - arg2 }; + let substract = fn(arg1: int, arg2: int) -> int { return arg1 - arg2 }; if (substract(arg1: 500, arg2: 100) == 400) { println " -> Lambda fn syntax: Passed"; @@ -98,9 +98,9 @@ test "test_complex_lambdas" { } test "test_basic_closure" { - var whatever = 10; - var closure: fn(I32) -> I32 = x -> x + whatever; - var res = closure(5); + let whatever = 10; + let closure: fn(I32) -> I32 = x -> x + whatever; + let res = closure(5); // "Result: {res}"; if (res != 15) { println "Closure failed: expected 15, got {res}"; diff --git a/tests/functions/test_must_use.zc b/tests/functions/test_must_use.zc index a42b341..98936ea 100644 --- a/tests/functions/test_must_use.zc +++ b/tests/functions/test_must_use.zc @@ -26,7 +26,7 @@ fn optional_result() -> int { test "attributes" { // This should NOT warn (result used) - var x = compute(); + let x = compute(); assert(x == 42, "compute() should return 42"); // This should NOT warn (no must_use attribute) @@ -36,11 +36,11 @@ test "attributes" { compute(); // Test inline works - var sum = fast_add(1, 2); + let sum = fast_add(1, 2); assert(sum == 3, "inline add failed"); // Combined attributes - var c = combined(); + let c = combined(); assert(c == 100, "combined failed"); "Attributes test completed"; diff --git a/tests/functions/test_raw_func_ptr.zc b/tests/functions/test_raw_func_ptr.zc index 16ec7df..115e421 100644 --- a/tests/functions/test_raw_func_ptr.zc +++ b/tests/functions/test_raw_func_ptr.zc @@ -16,12 +16,12 @@ test "raw_func_ptr_basic" { } test "raw_func_ptr_return_explicit" { - var p: fn*(char*) = get_printer(); + let p: fn*(char*) = get_printer(); p("Returned Ptr Explicit works"); } test "fn_ptr_ptr" { - var p: fn*(char*) = print_msg; - var pp: fn**(char*) = &p; + let p: fn*(char*) = print_msg; + let pp: fn**(char*) = &p; (*pp)("Double Pointer works"); } diff --git a/tests/functions/test_varargs.zc b/tests/functions/test_varargs.zc index b05e168..9b004db 100644 --- a/tests/functions/test_varargs.zc +++ b/tests/functions/test_varargs.zc @@ -4,7 +4,7 @@ test "test_varargs" { println "Testing Varargs..."; printf(" Direct Printf: %d, %f, %s\n", 42, 3.14, "Hello"); - var buf = malloc(100); + let buf = malloc(100); sprintf(buf, "Formatted: %d", 123); println " {buf}"; } diff --git a/tests/generics/test_generic_empty_struct.zc b/tests/generics/test_generic_empty_struct.zc index f3e3c39..40a691a 100644 --- a/tests/generics/test_generic_empty_struct.zc +++ b/tests/generics/test_generic_empty_struct.zc @@ -65,7 +65,7 @@ impl Stack<T> { fn pop(self) -> Optional<T> { if (self.len > 0) { - var result = Optional<T>{}; + let result = Optional<T>{}; result.emplace(self.data[self.len - 1]); self.len = self.len - 1; return result; @@ -75,10 +75,10 @@ impl Stack<T> { } test "Generic Empty Struct Init" { - var s = Stack<i32>{}; + let s = Stack<i32>{}; defer s.free(); s.push(123); - var result = s.pop(); + let result = s.pop(); assert(result.has_value(), "Result should have value"); assert(result.get() == 123, "Result value should be 123"); diff --git a/tests/generics/test_generic_operators.zc b/tests/generics/test_generic_operators.zc index 8578d50..cd73999 100644 --- a/tests/generics/test_generic_operators.zc +++ b/tests/generics/test_generic_operators.zc @@ -13,9 +13,9 @@ impl Foo<T> { } test "generic neq" { - var f1 = Foo<i32>{value: 10}; - var f2 = Foo<i32>{value: 20}; - var f3 = Foo<i32>{value: 10}; + let f1 = Foo<i32>{value: 10}; + let f2 = Foo<i32>{value: 20}; + let f3 = Foo<i32>{value: 10}; assert(f1 != f2, "f1 should not equal f2"); assert(f1 == f3, "f1 should equal f3"); diff --git a/tests/generics/test_generic_ptr.zc b/tests/generics/test_generic_ptr.zc index e08caba..fdcb9db 100644 --- a/tests/generics/test_generic_ptr.zc +++ b/tests/generics/test_generic_ptr.zc @@ -4,15 +4,15 @@ import "std/result.zc" test "generic pointer instantiation" { // Vector of ints (internally int*) nested in Result - var v = Vec<int>::new(); + let v = Vec<int>::new(); v.push(10); v.push(20); v.push(30); - var res = Result<Vec<int>>::Ok(v); + let res = Result<Vec<int>>::Ok(v); // Test unwrapping (signatures involving int*) - var unwrapped = res.unwrap_ref(); + let unwrapped = res.unwrap_ref(); assert(unwrapped.get(0) == 10); assert(unwrapped.get(1) == 20); assert(unwrapped.get(2) == 30); @@ -23,15 +23,15 @@ test "generic pointer instantiation" { test "generic pointer double nesting" { // Double nesting - Result<Vec<int*>> - var v_ptr = Vec<int*>::new(); - var a: int = 100; - var b: int = 200; + let v_ptr = Vec<int*>::new(); + let a: int = 100; + let b: int = 200; v_ptr.push(&a); v_ptr.push(&b); - var res_ptr = Result<Vec<int*>>::Ok(v_ptr); - var unwrapped_ptr = res_ptr.unwrap(); + let res_ptr = Result<Vec<int*>>::Ok(v_ptr); + let unwrapped_ptr = res_ptr.unwrap(); assert(*unwrapped_ptr.get(0) == 100); assert(*unwrapped_ptr.get(1) == 200); diff --git a/tests/generics/test_generic_traits.zc b/tests/generics/test_generic_traits.zc index 8458ba0..5e83f25 100644 --- a/tests/generics/test_generic_traits.zc +++ b/tests/generics/test_generic_traits.zc @@ -14,8 +14,8 @@ impl MyClone for GBox<T> { } test "generic_trait_method_resolution" { - var b = GBox<int>{ val: 10 }; - var res = b.my_clone(); + let b = GBox<int>{ val: 10 }; + let res = b.my_clone(); assert(res == 1, "Generic trait method call failed"); } @@ -34,9 +34,9 @@ impl ValueProvider for Wrapper<T> { } test "generic_trait_resolution_complex" { - var w = Wrapper<bool>{ inner: true }; + let w = Wrapper<bool>{ inner: true }; assert(w.get_value() == 42, "Wrapper<bool> trait call failed"); - var w2 = Wrapper<int>{ inner: 100 }; + let w2 = Wrapper<int>{ inner: 100 }; assert(w2.get_value() == 42, "Wrapper<int> trait call failed"); } diff --git a/tests/generics/test_generics_fn.zc b/tests/generics/test_generics_fn.zc index 03f751a..9343004 100644 --- a/tests/generics/test_generics_fn.zc +++ b/tests/generics/test_generics_fn.zc @@ -16,11 +16,11 @@ impl Box<T> { test "Generics" { // Generic Function - var i = identity<int>(42); + let i = identity<int>(42); assert(i == 42, "Generic function failed"); // Generic Struct & Impl - var b = Box<int> { val: 100 }; + let b = Box<int> { val: 100 }; assert(b.get() == 100, "Generic impl failed"); } @@ -33,7 +33,7 @@ impl Container { } test "Generic Method in Regular Impl" { - var c = Container{}; + let c = Container{}; assert(c.check_size<int>(10) == sizeof(int), "Generic method int size"); assert(c.check_size<double>(3.14) == sizeof(double), "Generic method double size"); } diff --git a/tests/generics/test_generics_struct.zc b/tests/generics/test_generics_struct.zc index ae61e4c..cefe79c 100644 --- a/tests/generics/test_generics_struct.zc +++ b/tests/generics/test_generics_struct.zc @@ -6,7 +6,7 @@ struct Wrapper<T> { test "test_generics_struct" { // Instantiate with int - var w1: Wrapper<int>; + let w1: Wrapper<int>; w1.id = 1; w1.item = 500; diff --git a/tests/generics/test_multi_generics.zc b/tests/generics/test_multi_generics.zc index 00d735e..d29556c 100644 --- a/tests/generics/test_multi_generics.zc +++ b/tests/generics/test_multi_generics.zc @@ -21,7 +21,7 @@ fn make_triple<X, Y, Z>(x: X, y: Y, z: Z) -> Triple<X, Y, Z> { } test "multi-type generics basic" { - var p: Pair<int, float>; + let p: Pair<int, float>; p.first = 42; p.second = 3.14; assert(p.first == 42, "First field failed"); @@ -29,13 +29,13 @@ test "multi-type generics basic" { } test "generic function with 2 params" { - var p = make_pair<int, float>(100, 2.5); + let p = make_pair<int, float>(100, 2.5); assert(p.first == 100, "Pair first failed"); println "2-param generic function passed!"; } test "generic function with 3 params" { - var t = make_triple<int, float, bool>(42, 3.14, true); + let t = make_triple<int, float, bool>(42, 3.14, true); assert(t.first == 42, "Triple first failed"); assert(t.third == true, "Triple third failed"); println "3-param generic function passed!"; diff --git a/tests/generics/test_sizeof_template.zc b/tests/generics/test_sizeof_template.zc index 8390512..bf4dd51 100644 --- a/tests/generics/test_sizeof_template.zc +++ b/tests/generics/test_sizeof_template.zc @@ -3,14 +3,14 @@ struct Struct<T> { } fn hello<T>() { - var s = sizeof(Struct<T>); + let s = sizeof(Struct<T>); println "size: {s}"; } test "sizeof template" { - var _first: Struct<i32>; + let _first: Struct<i32>; hello<i32>(); - var _second: Struct<f64>; + let _second: Struct<f64>; hello<f64>(); } @@ -20,9 +20,9 @@ struct Mixed<T> { } test "sizeof mixed" { - var s1 = sizeof(Mixed<i32>); + let s1 = sizeof(Mixed<i32>); println "i32 mixed: {s1}"; - var s2 = sizeof(Mixed<f64>); + let s2 = sizeof(Mixed<f64>); println "f64 mixed: {s2}"; } @@ -33,8 +33,8 @@ struct PackedMixed<T> { } test "sizeof packed mixed" { - var s1 = sizeof(PackedMixed<i32>); + let s1 = sizeof(PackedMixed<i32>); println "i32 packed mixed: {s1}"; - var s2 = sizeof(PackedMixed<f64>); + let s2 = sizeof(PackedMixed<f64>); println "f64 packed mixed: {s2}"; }
\ No newline at end of file diff --git a/tests/interop/test_c_import.zc b/tests/interop/test_c_import.zc index ed95bc1..207aff0 100644 --- a/tests/interop/test_c_import.zc +++ b/tests/interop/test_c_import.zc @@ -2,7 +2,7 @@ import "math.h" as m; test "test_c_import" { - var x = m::sin(0.0); + let x = m::sin(0.0); if x == 0.0 { println "Success: m::sin(0.0) == 0.0"; @@ -16,8 +16,8 @@ test "test_c_import" { extern fn abs(x: int) -> int; test "test_interop_abs" { - var x = -10; - var y = abs(x); + let x = -10; + let y = abs(x); if (y == 10) println "Abs works"; else { println "Abs failed"; diff --git a/tests/interop/test_c_macros.zc b/tests/interop/test_c_macros.zc index 0b1fc64..b1b9b68 100644 --- a/tests/interop/test_c_macros.zc +++ b/tests/interop/test_c_macros.zc @@ -3,7 +3,7 @@ #define DEBUG_MODE 1 test "test_c_macros" { - var x = MAX(10, 20); + let x = MAX(10, 20); if x == 20 { println "MAX macro worked"; diff --git a/tests/memory/test_copy_trait.zc b/tests/memory/test_copy_trait.zc index 994ccee..c31119c 100644 --- a/tests/memory/test_copy_trait.zc +++ b/tests/memory/test_copy_trait.zc @@ -13,8 +13,8 @@ struct Mover { } test "copy_trait" { - var p1 = Point { x: 10, y: 20 }; - var p2 = p1; // Copy, not move + let p1 = Point { x: 10, y: 20 }; + let p2 = p1; // Copy, not move // Both should be valid assert(p1.x == 10, "p1 invalid after copy"); @@ -29,9 +29,9 @@ test "copy_trait" { } test "move_default" { - var m1 = Mover { val: 1 }; - var m2 = m1; // Moved + let m1 = Mover { val: 1 }; + let m2 = m1; // Moved // Uncommenting this should cause compile error - // var m3 = m1; + // let m3 = m1; } diff --git a/tests/memory/test_drop.zc b/tests/memory/test_drop.zc index 8b34efe..6b1ccdf 100644 --- a/tests/memory/test_drop.zc +++ b/tests/memory/test_drop.zc @@ -1,6 +1,6 @@ import "../../std/mem.zc" -var DROP_CALLED = 0; +let DROP_CALLED = 0; struct MyResource { id: int; @@ -15,7 +15,7 @@ impl Drop for MyResource { test "drop_trait" { { - var res = MyResource { id: 1 }; + let res = MyResource { id: 1 }; // Scope ends here, drop should be called } diff --git a/tests/memory/test_drop_flags.zc b/tests/memory/test_drop_flags.zc index 753fc83..8a25d8d 100644 --- a/tests/memory/test_drop_flags.zc +++ b/tests/memory/test_drop_flags.zc @@ -1,7 +1,7 @@ import "../../std/mem.zc" // Global to track destructor calls -var DTOR_COUNT = 0; +let DTOR_COUNT = 0; struct Buffer { data: int*; @@ -23,9 +23,9 @@ test "drop_flags_variable_move" { DTOR_COUNT = 0; { println "Init"; - var buffer = Buffer { data: malloc(100) }; + let buffer = Buffer { data: malloc(100) }; println "Moved"; - var buf = buffer; // Move occurs + let buf = buffer; // Move occurs // buffer is moved-from. Flag should prevent destructor. // buf owns data. } diff --git a/tests/memory/test_memory_safety.zc b/tests/memory/test_memory_safety.zc index c7ba01d..a5cc960 100644 --- a/tests/memory/test_memory_safety.zc +++ b/tests/memory/test_memory_safety.zc @@ -2,7 +2,7 @@ import "std/mem.zc" // ** Globals ** -var DROP_COUNT = 0; +let DROP_COUNT = 0; // ** Structs & Helpers ** @@ -20,7 +20,7 @@ impl Drop for Resource { } fn create_resource(id: int) { - var r = Resource{id: id}; + let r = Resource{id: id}; println "Created Resource {r.id}"; } @@ -30,14 +30,14 @@ struct Point { } fn distance(p1: Point, p2: Point) -> int { - var dx = p2.x - p1.x; - var dy = p2.y - p1.y; + let dx = p2.x - p1.x; + let dy = p2.y - p1.y; return dx * dx + dy * dy; } fn accumulate(start: int, count: int) -> int { - var sum = start; - var i = 0; + let sum = start; + let i = 0; while (i < count) { sum += i; i++; @@ -46,14 +46,14 @@ fn accumulate(start: int, count: int) -> int { } fn process_point(p: Point) -> Point { - var result = Point { x: p.x * 2, y: p.y * 2 }; + let result = Point { x: p.x * 2, y: p.y * 2 }; return result; } fn counter_immut() { - var count = 0; + let count = 0; { - var inner = 10; + let inner = 10; inner = inner + 5; count = count + inner; } @@ -87,7 +87,7 @@ fn release_resource(id: int) { fn test_defer_logic() { println "start test"; - var x = get_resource() defer release_resource(it); + let x = get_resource() defer release_resource(it); println "using resource {x}"; } @@ -95,14 +95,14 @@ fn test_defer_logic() { test "test_alloc" { "Testing alloc<T>..."; - var p = alloc<int>(); + let p = alloc<int>(); *p = 42; f" alloc<int>(): {*p}"; assert(*p == 42, "alloc failed"); free(p); - var arr = alloc_n<int>(5); - for var i = 0; i < 5; i++ { + let arr = alloc_n<int>(5); + for let i = 0; i < 5; i++ { arr[i] = i * 10; } f" alloc_n<int>(5): [{arr[0]}, {arr[1]}, {arr[2]}, {arr[3]}, {arr[4]}]"; @@ -113,9 +113,9 @@ test "test_alloc" { test "test_box" { "Testing Box<T>..."; - var b = Box<int>::new(); + let b = Box<int>::new(); *b.get() = 100; - var val = *b.get(); + let val = *b.get(); f" Box value: {val}"; assert(val == 100, "Box failed"); b.free(); @@ -124,14 +124,14 @@ test "test_box" { test "test_slice" { "Testing Slice<T>..."; - var data: int[5] = [1, 2, 3, 4, 5]; - var s = Slice<int>::new(&data[0], 5); + let data: int[5] = [1, 2, 3, 4, 5]; + let s = Slice<int>::new(&data[0], 5); f" Slice len: {(int)s.len}"; - var v2 = s.get(2); + let v2 = s.get(2); f" Slice[2]: {v2}"; assert(v2 == 3, "Slice get failed"); s.set(0, 99); - var v0 = s.get(0); + let v0 = s.get(0); f" After set: Slice[0] = {v0}"; assert(v0 == 99, "Slice set failed"); " ✓ Slice works!"; @@ -139,8 +139,8 @@ test "test_slice" { test "test_swap" { "Testing swap<T>..."; - var a = 10; - var b = 20; + let a = 10; + let b = 20; f" Before: a={a}, b={b}"; swap<int>(&a, &b); f" After: a={a}, b={b}"; @@ -151,15 +151,15 @@ test "test_swap" { test "test_autofree" { println "Testing autofree..."; { - autofree var p = malloc(1024); + autofree let p = malloc(1024); if (p == NULL) { eprintln "Malloc failed!"; } strcpy(p, "Auto-freed string"); print f"Allocated: {p}"; println ""; } println "Exited block successfully (hopefully freed)"; { - autofree var p1 = malloc(10); - autofree var p2 = malloc(20); + autofree let p1 = malloc(10); + autofree let p2 = malloc(20); } } @@ -170,20 +170,20 @@ test "test_raii_drop" { "Exited scope."; assert(DROP_COUNT == 1, "Expected Drop to be called once"); { - var r2 = Resource{id: 2}; - var r3 = Resource{id: 3}; + let r2 = Resource{id: 2}; + let r3 = Resource{id: 3}; } assert(DROP_COUNT == 3, "Expected 3 total drops"); } test "test_immutable" { - var p1 = Point { x: 0, y: 0 }; - var p2 = Point { x: 3, y: 4 }; - var dist = distance(p1, p2); + let p1 = Point { x: 0, y: 0 }; + let p2 = Point { x: 3, y: 4 }; + let dist = distance(p1, p2); "Distance: {dist}"; - var sum = accumulate(10, 5); + let sum = accumulate(10, 5); "Accumulate: {sum}"; - var p3 = process_point(Point { x: 0, y: 0 }); + let p3 = process_point(Point { x: 0, y: 0 }); "Processed: ({p3.x}, {p3.y})"; counter_immut(); } @@ -193,11 +193,11 @@ test "test_permissions" { def WRITE : U8 = 0b010; def EXEC : U8 = 0b001; - var p1 = Permissions::new(READ); + let p1 = Permissions::new(READ); "Start: {p1.mask} (Read)"; - var p2 = Permissions::new(WRITE); - var p_rw = p1 | p2; + let p2 = Permissions::new(WRITE); + let p_rw = p1 | p2; "Combined: {p_rw.mask} (Read + Write)"; if (p_rw.has(EXEC)) { " > Has Execute access"; } @@ -205,7 +205,7 @@ test "test_permissions" { if (p_rw.has(READ)) { " > Has Read access"; } - var p_all = p_rw | Permissions::new(EXEC); + let p_all = p_rw | Permissions::new(EXEC); "Final: {p_all.mask} (All)"; } diff --git a/tests/memory/test_move_double_free.zc b/tests/memory/test_move_double_free.zc index 8322bcd..74a794c 100644 --- a/tests/memory/test_move_double_free.zc +++ b/tests/memory/test_move_double_free.zc @@ -1,8 +1,8 @@ import "../../std/mem.zc" // Global counters to track drop calls -var DROP_COUNT = 0; -var DROP_NULL_COUNT = 0; +let DROP_COUNT = 0; +let DROP_NULL_COUNT = 0; struct Resource { data: int*; @@ -32,8 +32,8 @@ test "move_variable" { DROP_NULL_COUNT = 0; { - var r1 = Resource { data: malloc(10), id: 1 }; - var r2 = r1; // Move + let r1 = Resource { data: malloc(10), id: 1 }; + let r2 = r1; // Move // r1 should be nullified // r2 owns data @@ -52,8 +52,8 @@ test "move_function" { DROP_NULL_COUNT = 0; { - var r1 = Resource { data: malloc(10), id: 2 }; - var r2 = pass_through(r1); + let r1 = Resource { data: malloc(10), id: 2 }; + let r2 = pass_through(r1); // r1 moved to arg -> moved to return -> moved to r2 } @@ -73,8 +73,8 @@ test "partial_move_member" { DROP_NULL_COUNT = 0; { - var c = Container { res: Resource { data: malloc(10), id: 3 } }; - var r = c.res; // Partial move + let c = Container { res: Resource { data: malloc(10), id: 3 } }; + let r = c.res; // Partial move // c.res should be nullified // r owns data diff --git a/tests/memory/test_move_semantics.zc b/tests/memory/test_move_semantics.zc index bf0d717..0ccd822 100644 --- a/tests/memory/test_move_semantics.zc +++ b/tests/memory/test_move_semantics.zc @@ -8,29 +8,29 @@ struct Mover { } test "basic_move" { - var p1 = Mover { val: 10 }; - var p2 = p1; // p1 moved to p2 + let p1 = Mover { val: 10 }; + let p2 = p1; // p1 moved to p2 // Valid usage of p2 assert(p2.val == 10, "p2 should be valid"); // Invalid usage of p1 (Uncomment to test compiler error) - // var p3 = p1; + // let p3 = p1; } test "primitive_copy" { - var i = 10; - var j = i; // Copy - var k = i; // Copy again - should be valid + let i = 10; + let j = i; // Copy + let k = i; // Copy again - should be valid assert(k == 10, "Primitive copy failed"); } test "reassignment" { - var m1 = Mover { val: 1 }; - var m2 = m1; // m1 moved + let m1 = Mover { val: 1 }; + let m2 = m1; // m1 moved m1 = Mover { val: 2 }; // Resurrect m1 - var m3 = m1; // Valid now + let m3 = m1; // Valid now assert(m3.val == 2, "Resurrection failed"); } @@ -39,7 +39,7 @@ fn consume(m: Mover) { } test "func_arg" { - var m = Mover { val: 10 }; + let m = Mover { val: 10 }; consume(m); // m moved // 2. Use after move (Call - Negative Test) @@ -49,7 +49,7 @@ test "func_arg" { /* // 3. Use after return (Negative Test) fn fail_return(m: Mover) -> Mover { - var m2 = m; + let m2 = m; return m; // Should fail: Use of moved value 'm' } */ diff --git a/tests/memory/test_resources.zc b/tests/memory/test_resources.zc index dc7b9f9..e21653d 100644 --- a/tests/memory/test_resources.zc +++ b/tests/memory/test_resources.zc @@ -29,12 +29,12 @@ fn take_point(p: Point) { test "Resource Semantics" { "Testing Resource Semantics..."; - var p1 = Point{x: 10, y: 20}; - var p2 = p1; // Copied + let p1 = Point{x: 10, y: 20}; + let p2 = p1; // Copied - var b1 = Box{val: 99}; - var b2 = b1.clone(); - // var b3 = b1; // This would move if uncommented. + let b1 = Box{val: 99}; + let b2 = b1.clone(); + // let b3 = b1; // This would move if uncommented. if b2.val != 99 { !"Clone failed"; @@ -44,11 +44,11 @@ test "Resource Semantics" { // Re-initialization // struct Resource (Global) - var r1 = Resource{ptr: NULL}; - var r2 = r1; // Moved + let r1 = Resource{ptr: NULL}; + let r2 = r1; // Moved r1 = Resource{ptr: NULL}; // Re-init - var r3 = r1; // Valid again + let r3 = r1; // Valid again // Function Param Move (Simulated) take_point(p1); diff --git a/tests/memory/test_unsafe.zc b/tests/memory/test_unsafe.zc index 126404a..fe1150f 100644 --- a/tests/memory/test_unsafe.zc +++ b/tests/memory/test_unsafe.zc @@ -9,46 +9,46 @@ raw { extern fn legacy_add(a: int, b: int) -> int; fn process_arrays(n: int, a: restrict int*, b: restrict int*, out: restrict int*) { - for (var i = 0; i < n; i = i + 1) { + for (let i = 0; i < n; i = i + 1) { out[i] = a[i] + b[i]; } } fn counter() -> int { - static var count = 0; + static let count = 0; count = count + 1; return count; } test "test_raw" { println "Testing Raw C Embedding..."; - var res = legacy_add(10, 20); + let res = legacy_add(10, 20); // Expected: 10 + 20 + 12345 = 12375 assert(res == 12375, "Raw C Code failed"); println " Raw C Code: Success (Result: {res})"; } test "test_restrict" { - var a: int[10]; - var b: int[10]; - var c: int[10]; + let a: int[10]; + let b: int[10]; + let c: int[10]; - for (var i = 0; i < 10; i = i + 1) { + for (let i = 0; i < 10; i = i + 1) { a[i] = i; b[i] = i * 2; } process_arrays(10, a, b, c); - for (var i = 0; i < 10; i = i + 1) { + for (let i = 0; i < 10; i = i + 1) { assert(c[i] == i * 3, "Restrict test failed"); } } test "test_static_local" { - var a = counter(); // 1 - var b = counter(); // 2 - var c = counter(); // 3 + let a = counter(); // 1 + let b = counter(); // 2 + let c = counter(); // 3 assert a == 1; assert b == 2; diff --git a/tests/misc/test_advanced.zc b/tests/misc/test_advanced.zc index 8b5b466..e985758 100644 --- a/tests/misc/test_advanced.zc +++ b/tests/misc/test_advanced.zc @@ -8,7 +8,7 @@ fn fibonacci(n: int) -> int { } fn test_recursion() { - var fib10 = fibonacci(10); + let fib10 = fibonacci(10); if (fib10 != 55) { println "FAIL: fibonacci(10) should be 55"; @@ -23,7 +23,7 @@ fn add_three(a: int, b: int, c: int) -> int { } fn test_multi_params() { - var result = add_three(1, 2, 3); + let result = add_three(1, 2, 3); if (result != 6) { println "FAIL: add_three(1,2,3) should be 6"; @@ -38,7 +38,7 @@ fn double_val(x: int) -> int { } fn test_nested_calls() { - var result = double_val(double_val(double_val(2))); + let result = double_val(double_val(double_val(2))); if (result != 16) { println "FAIL: nested calls failed"; @@ -67,7 +67,7 @@ impl Counter { } fn test_struct_methods() { - var c = Counter::new(); + let c = Counter::new(); c.increment(); c.increment(); c.increment(); @@ -81,16 +81,16 @@ fn test_struct_methods() { } fn test_casting() { - var f: float = 3.7; - var i: int = (int)f; + let f: float = 3.7; + let i: int = (int)f; if (i != 3) { println "FAIL: float to int cast failed"; exit(1); } - var i2: int = 42; - var f2: float = (float)i2; + let i2: int = 42; + let f2: float = (float)i2; if (f2 < 41.9 || f2 > 42.1) { println "FAIL: int to float cast failed"; @@ -101,12 +101,12 @@ fn test_casting() { } fn test_bitwise() { - var a = 0b1010; // 10 - var b = 0b1100; // 12 + let a = 0b1010; // 10 + let b = 0b1100; // 12 - var and_result = a & b; // 0b1000 = 8 - var or_result = a | b; // 0b1110 = 14 - var xor_result = a ^ b; // 0b0110 = 6 + let and_result = a & b; // 0b1000 = 8 + let or_result = a | b; // 0b1110 = 14 + let xor_result = a ^ b; // 0b0110 = 6 if (and_result != 8) { println "FAIL: bitwise AND failed"; @@ -127,16 +127,16 @@ fn test_bitwise() { } fn test_shift() { - var x = 1; - var left = x << 4; // 16 + let x = 1; + let left = x << 4; // 16 if (left != 16) { println "FAIL: left shift failed"; exit(1); } - var y = 32; - var right = y >> 2; // 8 + let y = 32; + let right = y >> 2; // 8 if (right != 8) { println "FAIL: right shift failed"; @@ -147,9 +147,9 @@ fn test_shift() { } fn test_modulo() { - var a = 17; - var b = 5; - var result = a % b; + let a = 17; + let b = 5; + let result = a % b; if (result != 2) { println "FAIL: modulo operation failed"; @@ -160,11 +160,11 @@ fn test_modulo() { } fn test_compound_expr() { - var x = 5; - var y = 10; - var z = 3; + let x = 5; + let y = 10; + let z = 3; - var result = (x + y) * z - (y / 2); + let result = (x + y) * z - (y / 2); // (5 + 10) * 3 - (10 / 2) = 15 * 3 - 5 = 45 - 5 = 40 if (result != 40) { @@ -176,7 +176,7 @@ fn test_compound_expr() { } fn test_increment_style() { - var x = 5; + let x = 5; x = x + 1; if (x != 6) { diff --git a/tests/misc/test_chained.zc b/tests/misc/test_chained.zc index e758db7..a92ae18 100644 --- a/tests/misc/test_chained.zc +++ b/tests/misc/test_chained.zc @@ -2,8 +2,8 @@ import "std/string.zc" test "test_chained" { - var s = String::from("hello"); - var opt = s.find('e'); + let s = String::from("hello"); + let opt = s.find('e'); if opt.is_some() { "Found at index: {opt.unwrap()}"; } diff --git a/tests/misc/test_edge_cases.zc b/tests/misc/test_edge_cases.zc index 0d50744..79a927f 100644 --- a/tests/misc/test_edge_cases.zc +++ b/tests/misc/test_edge_cases.zc @@ -6,8 +6,8 @@ import "std.zc" struct Empty {} fn test_empty_struct() { - var e1 = Empty {}; - var e2 = Empty {}; + let e1 = Empty {}; + let e2 = Empty {}; if (!e1.eq(&e2)) { println "FAIL: Empty struct eq failed"; @@ -31,9 +31,9 @@ struct ManyFields { } fn test_many_fields() { - var m1 = ManyFields { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8 }; - var m2 = ManyFields { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8 }; - var m3 = ManyFields { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 9 }; // h differs + let m1 = ManyFields { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8 }; + let m2 = ManyFields { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8 }; + let m3 = ManyFields { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 9 }; // h differs if (!m1.eq(&m2)) { println "FAIL: equal structs not detected as equal"; @@ -55,11 +55,11 @@ struct Point { } fn test_pointer_equality() { - var p1 = Point { x: 1, y: 2 }; - var ptr1: Point* = &p1; - var ptr2: Point* = &p1; - var p2 = Point { x: 1, y: 2 }; - var ptr3: Point* = &p2; + let p1 = Point { x: 1, y: 2 }; + let ptr1: Point* = &p1; + let ptr2: Point* = &p1; + let p2 = Point { x: 1, y: 2 }; + let ptr3: Point* = &p2; // Same pointer should be equal if (ptr1 != ptr2) { @@ -78,7 +78,7 @@ fn test_pointer_equality() { // Very long string fn test_long_string() { - var s = String::from("This is a very long string that should test the string handling capabilities of the compiler and make sure that buffer allocations are correct and that there are no overflow issues with long strings."); + let s = String::from("This is a very long string that should test the string handling capabilities of the compiler and make sure that buffer allocations are correct and that there are no overflow issues with long strings."); if (s.length() < 100) { println "FAIL: long string length incorrect"; @@ -90,7 +90,7 @@ fn test_long_string() { // Null pointer handling fn test_null_pointer() { - var ptr: int* = NULL; + let ptr: int* = NULL; if (ptr != NULL) { println "FAIL: NULL pointer check failed"; @@ -102,8 +102,8 @@ fn test_null_pointer() { // Numeric edge cases fn test_numeric_edges() { - var max_int: int = 2147483647; - var min_int: int = -1000000000; + let max_int: int = 2147483647; + let min_int: int = -1000000000; if (max_int <= 0) { println "FAIL: max_int is wrong"; @@ -120,8 +120,8 @@ fn test_numeric_edges() { // Boolean operations fn test_boolean_ops() { - var a = true; - var b = false; + let a = true; + let b = false; if (!(a && !b)) { println "FAIL: boolean AND failed"; diff --git a/tests/misc/test_mix.zc b/tests/misc/test_mix.zc index b4edca4..f2880e9 100644 --- a/tests/misc/test_mix.zc +++ b/tests/misc/test_mix.zc @@ -13,12 +13,12 @@ fn square(x: int) -> int { } test "test_result_constructors" { - var res = Result_Ok(42); + let res = Result_Ok(42); assert(res.tag == Result_Ok_Tag, "Expected Ok tag"); assert(res.data.Ok == 42, "Data mismatch"); - var err = Result_Err(500); + let err = Result_Err(500); assert(err.tag == Result_Err_Tag, "Expected Err tag"); } @@ -26,17 +26,17 @@ test "test_pipelines" { // Logic: ((5 + 5) * (5 + 5)) // 5 |> add(5) -> 10 // 10 |> square() -> 100 - var val = 5 |> add(5) |> square(); + let val = 5 |> add(5) |> square(); println "Pipeline result: {val}"; assert(val == 100, "Pipeline calculation failed"); } test "test_fstrings" { - var x = 10; - var name = "ZPrep"; + let x = 10; + let name = "ZPrep"; - var s = f"Hello {name}, x = {x}, x * 2 = {x * 2}"; + let s = f"Hello {name}, x = {x}, x * 2 = {x * 2}"; println "F-String: {s}"; assert(x == 10, "Sanity check"); @@ -52,8 +52,8 @@ test "test_defer" { } test "test_hex_binary" { - var h = 0xFF; // 255 - var b = 0b1010; // 10 + let h = 0xFF; // 255 + let b = 0b1010; // 10 assert(h == 255, "Hex parsing failed"); assert(b == 10, "Binary parsing failed"); } diff --git a/tests/modules/test_aliasing.zc b/tests/modules/test_aliasing.zc index 468e558..ba8f759 100644 --- a/tests/modules/test_aliasing.zc +++ b/tests/modules/test_aliasing.zc @@ -3,8 +3,8 @@ import { Vector as MathVec } from "./test_modules/_math.zc"; import { Vector as PhysicsVec } from "./test_modules/_physics.zc"; test "test_selective_aliasing" { - var mv = MathVec::new(3, 4); - var pv = PhysicsVec::new(5.0, 12.0); + let mv = MathVec::new(3, 4); + let pv = PhysicsVec::new(5.0, 12.0); assert(mv.x == 3 && mv.y == 4, "MathVec initialization failed"); assert(pv.vx == 5.0 && pv.vy == 12.0, "PhysicsVec initialization failed"); diff --git a/tests/modules/test_namespaced.zc b/tests/modules/test_namespaced.zc index afc1d6c..67db941 100644 --- a/tests/modules/test_namespaced.zc +++ b/tests/modules/test_namespaced.zc @@ -3,11 +3,11 @@ import "./test_modules/_math.zc" as math; import "./test_modules/_physics.zc" as physics; test "test_namespaced_imports" { - var mv = math::Vector::new(3, 4); - var pv = physics::Vector::new(5.0, 12.0); + let mv = math::Vector::new(3, 4); + let pv = physics::Vector::new(5.0, 12.0); - var len1 = math::Vector::length(&mv); - var len2 = physics::Vector::magnitude(&pv); + let len1 = math::Vector::length(&mv); + let len2 = physics::Vector::magnitude(&pv); assert(len1 == 5, "Math vector length failed"); assert(len2 == 13.0, "Physics vector magnitude failed"); diff --git a/tests/std/test_env.zc b/tests/std/test_env.zc index 75bba3b..25d5bc1 100644 --- a/tests/std/test_env.zc +++ b/tests/std/test_env.zc @@ -2,34 +2,34 @@ import "std.zc" import "std/env.zc" test "test_std_env_set_and_get" { - var res = Env::set("TEST1", "ok1"); + let res = Env::set("TEST1", "ok1"); assert(res == EnvRes::OK(), "result should be EnvRes::OK()"); - var env_var = Env::get("TEST1"); + let env_var = Env::get("TEST1"); assert(env_var.is_some(), "env_var should have a value"); assert(env_var.unwrap() == "ok1", "env_var should be ok1"); } test "test_std_env_set_with_overwrite" { - var res = Env::set("TEST2", "ok2"); + let res = Env::set("TEST2", "ok2"); assert(res == EnvRes::OK(), "res should be EnvRes::OK()"); - var res2 = Env::set("TEST2", "ok2-ovwr"); + let res2 = Env::set("TEST2", "ok2-ovwr"); assert(res2 == EnvRes::OK(), "res2 should be EnvRes::OK()"); - var env_var = Env::get("TEST2"); + let env_var = Env::get("TEST2"); assert(env_var.is_some(), "env_var should have a value"); assert(env_var.unwrap() == "ok2-ovwr", "env_var should be ok2-ovwr"); } test "test_std_env_get_dup" { - var res = Env::set("TEST3", "ok3"); + let res = Env::set("TEST3", "ok3"); assert(res == EnvRes::OK(), "result should be EnvRes::OK()"); - var env_var = Env::get_dup("TEST3"); + let env_var = Env::get_dup("TEST3"); assert(env_var.is_some(), "env_var should have a value"); - var value = env_var.unwrap(); + let value = env_var.unwrap(); assert(value.c_str() == "ok3", "value should be ok3"); value.free(); @@ -38,24 +38,24 @@ test "test_std_env_get_dup" { } test "test_std_env_get_and_get_dup_with_invalid" { - var env_var = Env::get("TEST4"); + let env_var = Env::get("TEST4"); assert(env_var.is_none(), "env_var should not have a value"); - var env_var2 = Env::get_dup("TEST4"); + let env_var2 = Env::get_dup("TEST4"); assert(env_var2.is_none(), "env_var2 should not have a value"); } test "test_std_env_unset" { - var res = Env::set("TEST5", "ok5"); + let res = Env::set("TEST5", "ok5"); assert(res == EnvRes::OK(), "res should be EnvRes::OK()"); - var env_var = Env::get("TEST5"); + let env_var = Env::get("TEST5"); assert(env_var.is_some(), "env_var should have a value"); assert(env_var.unwrap() == "ok5", "env_var should be ok5"); - var res2 = Env::unset("TEST5"); + let res2 = Env::unset("TEST5"); assert(res2 == EnvRes::OK(), "res2 should be EnvRes::OK()"); - var env_var2 = Env::get("TEST5"); + let env_var2 = Env::get("TEST5"); assert(env_var2.is_none(), "env_var2 should not have a value"); } diff --git a/tests/std/test_fs.zc b/tests/std/test_fs.zc index 1b6eb56..8a2c5f5 100644 --- a/tests/std/test_fs.zc +++ b/tests/std/test_fs.zc @@ -6,64 +6,64 @@ test "test_std_fs_extended" { "Testing FS Extension..."; "Testing Path..."; - var p = Path::new("/var/log"); - var p2 = p.join("syslog"); - assert(strcmp(p2.c_str(), "/var/log/syslog") == 0, "Join failed"); + let p = Path::new("/let/log"); + let p2 = p.join("syslog"); + assert(strcmp(p2.c_str(), "/let/log/syslog") == 0, "Join failed"); - var p3 = Path::new("file.txt"); - var ext = p3.extension(); + let p3 = Path::new("file.txt"); + let ext = p3.extension(); assert(ext.is_some(), "Extension missed"); assert(strcmp(ext.unwrap_ref().c_str(), "txt") == 0, "Wrong extension"); - var p4 = Path::new("/usr/bin/gcc"); - var parent = p4.parent(); + let p4 = Path::new("/usr/bin/gcc"); + let parent = p4.parent(); assert(parent.is_some(), "Parent missed"); assert(strcmp(parent.unwrap_ref().c_str(), "/usr/bin") == 0, "Wrong parent"); - var fname = p4.file_name(); + let fname = p4.file_name(); assert(fname.is_some(), "Filename missed"); assert(strcmp(fname.unwrap_ref().c_str(), "gcc") == 0, "Wrong filename"); "Testing FS..."; - var test_dir = "tests/test_fs_sandbox"; + let test_dir = "tests/test_fs_sandbox"; if (File::exists(test_dir)) { File::remove_dir(test_dir); } "Create Dir"; - var res = File::create_dir(test_dir); + let res = File::create_dir(test_dir); if (res.is_err()) { "Dir create failed"; } assert(File::exists(test_dir), "Dir create failed"); "Write File"; - var tmp_path = Path::new(test_dir); - var p_file = tmp_path.join("hello.txt"); - var fpath = p_file.c_str(); - var f_res = File::open(fpath, "w"); + let tmp_path = Path::new(test_dir); + let p_file = tmp_path.join("hello.txt"); + let fpath = p_file.c_str(); + let f_res = File::open(fpath, "w"); assert(f_res.is_ok(), "File create failed"); - var f = f_res.unwrap(); + let f = f_res.unwrap(); f.write_string("Hello World"); f.close(); assert(File::exists(fpath), "File exists check failed"); "Metadata"; - var meta_res = File::metadata(fpath); + let meta_res = File::metadata(fpath); assert(meta_res.is_ok(), "Metadata failed"); - var meta = meta_res.unwrap(); + let meta = meta_res.unwrap(); assert(meta.is_file, "Is file check failed"); assert(!meta.is_dir, "Is dir check failed"); assert(meta.size == 11, "Size check failed"); "Read Dir"; - var list_res = File::read_dir(test_dir); + let list_res = File::read_dir(test_dir); assert(list_res.is_ok(), "Read dir failed"); - var entries = list_res.unwrap(); - var found_idx = -1; + let entries = list_res.unwrap(); + let found_idx = -1; for entry in &entries { if (strcmp((*entry).name.c_str(), "hello.txt") == 0) { found_idx = 1; diff --git a/tests/std/test_map_iter.zc b/tests/std/test_map_iter.zc index efce356..a366854 100644 --- a/tests/std/test_map_iter.zc +++ b/tests/std/test_map_iter.zc @@ -2,14 +2,14 @@ import "std/map.zc" import "std/string.zc" test "map_iterator" { - var m = Map<int>::new(); + let m = Map<int>::new(); m.put("one", 1); m.put("two", 2); m.put("three", 3); - var count = 0; - var sum = 0; + let count = 0; + let sum = 0; for entry in m { count = count + 1; diff --git a/tests/std/test_net.zc b/tests/std/test_net.zc index 98ba32f..638bace 100644 --- a/tests/std/test_net.zc +++ b/tests/std/test_net.zc @@ -9,29 +9,29 @@ import "std/result.zc" test "test_net" { "Testing Networking..."; - var t = Thread::spawn(fn() { - var listener = TcpListener::bind("127.0.0.1", 9090); + let t = Thread::spawn(fn() { + let listener = TcpListener::bind("127.0.0.1", 9090); if (listener.is_err()) { !"Server bind failed"; return; } - var l = listener.unwrap(); + let l = listener.unwrap(); - var client_res = l.accept(); + let client_res = l.accept(); if (client_res.is_err()) { !"Accept failed"; l.close(); return; } - var client = client_res.unwrap(); + let client = client_res.unwrap(); - var buf: char* = malloc(100); - var n_res = client.read(buf, 100); + let buf: char* = malloc(100); + let n_res = client.read(buf, 100); if (n_res.is_ok()) { - var n = n_res.unwrap(); + let n = n_res.unwrap(); buf[n] = 0; if (strcmp(buf, "Ping") == 0) { client.write("Pong", 4); @@ -50,17 +50,17 @@ test "test_net" { sleep_ms(100); - var stream_res = TcpStream::connect("127.0.0.1", 9090); + let stream_res = TcpStream::connect("127.0.0.1", 9090); if (stream_res.is_err()) { !"Client connect failed"; exit(1); } - var stream = stream_res.unwrap(); + let stream = stream_res.unwrap(); stream.write("Ping", 4); - var buf2: char* = malloc(100); - var n2_res = stream.read(buf2, 100); + let buf2: char* = malloc(100); + let n2_res = stream.read(buf2, 100); if (n2_res.is_ok()) { buf2[n2_res.unwrap()] = 0; diff --git a/tests/std/test_queue.zc b/tests/std/test_queue.zc index d8895b8..3316323 100644 --- a/tests/std/test_queue.zc +++ b/tests/std/test_queue.zc @@ -2,11 +2,11 @@ import "std/queue.zc" test "Queue Push/Pop" { println "Testing Queue Push/Pop"; - var queue = Queue<i32>::new(); + let queue = Queue<i32>::new(); defer queue.free(); println "Popping on an empty queue without pushing anything prior" - var v = queue.pop(); + let v = queue.pop(); assert(v.is_none(), "v should not have a valid value"); println "Pushing in three values..." @@ -30,7 +30,7 @@ test "Queue Push/Pop" { test "Queue Length and Clear" { println "Testing Queue clear"; - var queue = Queue<i32>::new(); + let queue = Queue<i32>::new(); defer queue.free(); assert(queue.is_empty() && queue.length() == 0, "queue should be empty"); @@ -44,13 +44,13 @@ test "Queue Length and Clear" { test "Queue Clone" { println "Testing Queue Cloning"; - var queue = Queue<i32>::new(); + let queue = Queue<i32>::new(); defer queue.free(); queue.push(123); - var queue2 = queue.clone(); + let queue2 = queue.clone(); defer queue2.free(); - var v = queue2.pop(); + let v = queue2.pop(); assert(v.is_some() && v.unwrap() == 123, "v's value should be 123"); v = queue2.pop(); assert(v.is_none(), "v should not have a valid value"); @@ -62,7 +62,7 @@ test "Queue Clone" { } test "Queue Ring Buffer (Advanced)" { - var q = Queue<int>::new(); + let q = Queue<int>::new(); println "Fill slightly" q.push(1); @@ -91,10 +91,10 @@ test "Queue Ring Buffer (Advanced)" { assert(q.is_empty()); println "Large scale test" - for (var i = 0; i < 100; i=i+1) { + for (let i = 0; i < 100; i=i+1) { q.push(i); } - for (var i = 0; i < 100; i=i+1) { + for (let i = 0; i < 100; i=i+1) { assert(*q.pop().unwrap_ref() == i); } diff --git a/tests/std/test_readln_scan.zc b/tests/std/test_readln_scan.zc index 5ea196d..f138c2c 100644 --- a/tests/std/test_readln_scan.zc +++ b/tests/std/test_readln_scan.zc @@ -2,18 +2,18 @@ test "test_readln_scan" { "Testing readln compilation..."; - var x: int = 0; - var f: float = 0.0; + let x: int = 0; + let f: float = 0.0; if (1 == 0) { - var s = readln(); + let s = readln(); - var count = readln(x); + let count = readln(x); readln(f); readln(x, f); - var count2 = ?"Age? "(x); + let count2 = ?"Age? "(x); ?"Coords? "(x, f); } diff --git a/tests/std/test_stack.zc b/tests/std/test_stack.zc index 03e51a4..1116f8d 100644 --- a/tests/std/test_stack.zc +++ b/tests/std/test_stack.zc @@ -2,11 +2,11 @@ import "std/stack.zc" test "Stack Push/Pop" { print "Testing Stack Push/Pop"; - var stack = Stack<i32>::new(); + let stack = Stack<i32>::new(); defer stack.free(); print "Popping on an empty stack without pushing anything prior" - var v = stack.pop(); + let v = stack.pop(); assert(v.is_none(), "v should not have a valid value"); print "Pushing in three values..." @@ -30,7 +30,7 @@ test "Stack Push/Pop" { test "Stack Length and Clear" { print "Testing Stack clear"; - var stack = Stack<i32>::new(); + let stack = Stack<i32>::new(); defer stack.free(); assert(stack.is_empty() && stack.length() == 0, "Stack should be empty"); @@ -44,13 +44,13 @@ test "Stack Length and Clear" { test "Stack Clone" { print "Testing Stack Cloning"; - var stack = Stack<i32>::new(); + let stack = Stack<i32>::new(); defer stack.free(); stack.push(123); - var stack2 = stack.clone(); + let stack2 = stack.clone(); defer stack2.free(); - var v = stack2.pop(); + let v = stack2.pop(); assert(v.is_some() && v.unwrap() == 123, "v's value should be 123"); v = stack2.pop(); assert(v.is_none(), "v should not have a valid value"); diff --git a/tests/std/test_std_expansion.zc b/tests/std/test_std_expansion.zc index 764e0ac..fbb6d6b 100644 --- a/tests/std/test_std_expansion.zc +++ b/tests/std/test_std_expansion.zc @@ -4,7 +4,7 @@ test "test_std_expansion" { "Testing Standard Library Expansion..."; "Testing Map..."; - var m = Map<int>::new(); + let m = Map<int>::new(); m.put("one", 1); m.put("two", 2); @@ -17,14 +17,14 @@ test "test_std_expansion" { assert(!m.contains("one"), "Map remove failed"); "Testing Time..."; - var t1 = Time::now(); + let t1 = Time::now(); Time::sleep_ms(10); - var t2 = Time::now(); + let t2 = Time::now(); assert(t2 >= t1, "Time went backwards!"); "Time passed: {t2 - t1} ms"; "Testing FS..."; - var content_res = File::read_all("tests/test_0.zc"); + let content_res = File::read_all("tests/test_0.zc"); if (content_res.is_ok()) { "Read file successfully."; } else { @@ -32,7 +32,7 @@ test "test_std_expansion" { } "Testing JSON..."; - var j = JsonValue::string("hello"); + let j = JsonValue::string("hello"); assert(j.kind == JsonType::JSON_STRING(), "Json string kind failed"); "All expansion tests passed!"; diff --git a/tests/std/test_string_split.zc b/tests/std/test_string_split.zc index 496dbd1..74bc624 100644 --- a/tests/std/test_string_split.zc +++ b/tests/std/test_string_split.zc @@ -1,24 +1,24 @@ import "std/string.zc" test "string_split_basic" { - var s = String::from("a,b,c"); - var parts = s.split(','); + let s = String::from("a,b,c"); + let parts = s.split(','); if (parts.length() != 3) { println "Split length fail: {parts.length()}"; exit(1); } - var p0 = parts.get(0); - var t0 = String::from("a"); + let p0 = parts.get(0); + let t0 = String::from("a"); if (!p0.eq(&t0)) exit(1); - var p1 = parts.get(1); - var t1 = String::from("b"); + let p1 = parts.get(1); + let t1 = String::from("b"); if (!p1.eq(&t1)) exit(1); - var p2 = parts.get(2); - var t2 = String::from("c"); + let p2 = parts.get(2); + let t2 = String::from("c"); if (!p2.eq(&t2)) exit(1); for p in &parts { @@ -28,28 +28,28 @@ test "string_split_basic" { } test "string_split_edge" { - var s = String::from("hello"); - var parts = s.split(' '); // Not found + let s = String::from("hello"); + let parts = s.split(' '); // Not found if (parts.length() != 1) { println "Split edge 1 failed"; exit(1); } - var p0 = parts.get(0); + let p0 = parts.get(0); if (!p0.eq(&s)) exit(1); p0.free(); parts.free(); - var s2 = String::from("a,,b"); - var parts2 = s2.split(','); + let s2 = String::from("a,,b"); + let parts2 = s2.split(','); if (parts2.length() != 3) { println "Split edge 2 failed: {parts2.length()}"; exit(1); } - var empty = parts2.get(1); + let empty = parts2.get(1); if (!empty.is_empty()) exit(1); for p in &parts2 { p.free(); } diff --git a/tests/std/test_string_utf8.zc b/tests/std/test_string_utf8.zc index a4d2095..a8f6272 100644 --- a/tests/std/test_string_utf8.zc +++ b/tests/std/test_string_utf8.zc @@ -1,22 +1,22 @@ import "std/string.zc" test "utf8_basic_ascii" { - var s = String::from("Hello"); + let s = String::from("Hello"); if (s.utf8_len() != 5) { println "ASCII Len failed"; exit(1); } - var h = s.utf8_at(0); - var t1 = String::from("H"); + let h = s.utf8_at(0); + let t1 = String::from("H"); if (!h.eq(&t1)) { println "ASCII At failed"; exit(1); } - var sub = s.utf8_substr(1, 4); - var t2 = String::from("ello"); + let sub = s.utf8_substr(1, 4); + let t2 = String::from("ello"); if (!sub.eq(&t2)) { println "ASCII Substr failed"; exit(1); @@ -28,7 +28,7 @@ test "utf8_multibyte" { // Bytes: H(1) e(1) y(1) (1) 🌎(4) !(1) = 9 bytes? // 🌎 is approx F0 9F 8C 8D (4 bytes) - var s = String::from("Hey 🌎!"); + let s = String::from("Hey 🌎!"); if (s.length() != 9) { println "Byte length unexpected: {s.length()}"; @@ -40,15 +40,15 @@ test "utf8_multibyte" { exit(1); } - var globe = s.utf8_at(4); - var t3 = String::from("🌎"); + let globe = s.utf8_at(4); + let t3 = String::from("🌎"); if (!globe.eq(&t3)) { println "UTF8 At failed"; exit(1); } - var sub = s.utf8_substr(4, 2); // "🌎!" - var t4 = String::from("🌎!"); + let sub = s.utf8_substr(4, 2); // "🌎!" + let t4 = String::from("🌎!"); if (!sub.eq(&t4)) { println "UTF8 Substr failed"; exit(1); diff --git a/tests/std/test_string_utils.zc b/tests/std/test_string_utils.zc index 212bac1..c001ef4 100644 --- a/tests/std/test_string_utils.zc +++ b/tests/std/test_string_utils.zc @@ -1,46 +1,46 @@ import "std/string.zc" test "string trim" { - var s1 = String::from(" hello "); - var t1 = s1.trim(); - var e1 = String::from("hello"); + let s1 = String::from(" hello "); + let t1 = s1.trim(); + let e1 = String::from("hello"); assert(t1.eq(&e1)); t1.free(); s1.free(); e1.free(); - var s2 = String::from("\n\t world \r "); - var t2 = s2.trim(); - var e2 = String::from("world"); + let s2 = String::from("\n\t world \r "); + let t2 = s2.trim(); + let e2 = String::from("world"); assert(t2.eq(&e2)); t2.free(); s2.free(); e2.free(); - var s3 = String::from("no_trim"); - var t3 = s3.trim(); - var e3 = String::from("no_trim"); + let s3 = String::from("no_trim"); + let t3 = s3.trim(); + let e3 = String::from("no_trim"); assert(t3.eq(&e3)); t3.free(); s3.free(); e3.free(); - var s4 = String::from(" "); - var t4 = s4.trim(); + let s4 = String::from(" "); + let t4 = s4.trim(); assert(t4.is_empty()); t4.free(); s4.free(); } test "string replace" { - var s1 = String::from("foo bar foo"); - var r1 = s1.replace("foo", "baz"); - var e1 = String::from("baz bar baz"); + let s1 = String::from("foo bar foo"); + let r1 = s1.replace("foo", "baz"); + let e1 = String::from("baz bar baz"); assert(r1.eq(&e1)); r1.free(); s1.free(); e1.free(); - var s2 = String::from("hello world"); - var r2 = s2.replace("world", "ZenC"); - var e2 = String::from("hello ZenC"); + let s2 = String::from("hello world"); + let r2 = s2.replace("world", "ZenC"); + let e2 = String::from("hello ZenC"); assert(r2.eq(&e2)); r2.free(); s2.free(); e2.free(); - var s3 = String::from("aaaa"); - var r3 = s3.replace("aa", "b"); - var e3 = String::from("bb"); + let s3 = String::from("aaaa"); + let r3 = s3.replace("aa", "b"); + let e3 = String::from("bb"); assert(r3.eq(&e3)); r3.free(); s3.free(); e3.free(); } diff --git a/tests/std/test_vec.zc b/tests/std/test_vec.zc index 5e3dddf..89086f6 100644 --- a/tests/std/test_vec.zc +++ b/tests/std/test_vec.zc @@ -24,7 +24,7 @@ struct Point { test "Vec Basics (Construction, Push, Pop, Access)" { print "Testing Vec basics...\n"; - var v = Vec<int>::new(); + let v = Vec<int>::new(); assert_eq(v.len, 0, "Initial len"); assert_eq(v.cap, 0, "Initial cap"); @@ -53,16 +53,16 @@ test "Vec Basics (Construction, Push, Pop, Access)" { test "Vec Capacity and Allocation" { print "Testing Vec capacity...\n"; // with_capacity - var v1 = Vec<int>::with_capacity(10); + let v1 = Vec<int>::with_capacity(10); assert_eq(v1.len, 0, "with_capacity len"); assert_eq(v1.cap, 10, "with_capacity cap"); v1.push(1); assert_eq(v1.cap, 10, "Cap should not change yet"); // Implicit grow - var v2 = Vec<int>::new(); + let v2 = Vec<int>::new(); // Force grow logic: 0 -> 8 -> 16... - var i = 0; + let i = 0; while i < 9 { v2.push(i); i = i + 1; @@ -74,7 +74,7 @@ test "Vec Capacity and Allocation" { test "Vec Modification (Insert, Append, Remove, Clear)" { print "Testing Vec modification...\n"; - var v = Vec<int>::new(); + let v = Vec<int>::new(); v.push(1); v.push(3); @@ -82,7 +82,7 @@ test "Vec Modification (Insert, Append, Remove, Clear)" { assert_eq(v.get(1), 2, "insert middle"); assert_eq(v.len, 3, "insert len"); - var v2 = Vec<int>::new(); + let v2 = Vec<int>::new(); v2.push(4); v2.push(5); v.append(v2); @@ -91,7 +91,7 @@ test "Vec Modification (Insert, Append, Remove, Clear)" { assert_eq(v.get(i), i + 1, "append value"); } - var val = v.remove(0); // [2, 3, 4, 5] + let val = v.remove(0); // [2, 3, 4, 5] assert_eq(val, 1, "remove return"); assert_eq(v.get(0), 2, "remove shift"); assert_eq(v.len, 4, "remove len"); @@ -103,25 +103,25 @@ test "Vec Modification (Insert, Append, Remove, Clear)" { test "Vec Extensions (pop_opt)" { print "Testing Vec extensions...\n"; - var v = Vec<int>::new(); + let v = Vec<int>::new(); v.push(42); - var opt = v.pop_opt(); + let opt = v.pop_opt(); assert_true(!opt.is_none(), "pop_opt some"); assert_eq(opt.unwrap(), 42, "pop_opt val"); - var empty = v.pop_opt(); + let empty = v.pop_opt(); assert_true(empty.is_none(), "pop_opt none"); } test "Vec Iteration (Reference and Value)" { print "Testing Vec iteration...\n"; - var v = Vec<Point>::new(); + let v = Vec<Point>::new(); v.push(Point { x: 10, y: 10 }); v.push(Point { x: 20, y: 20 }); // 1. Value Iteration - var sum_val = 0; + let sum_val = 0; for p in v { sum_val = sum_val + p.x; } @@ -144,11 +144,11 @@ test "Vec Iteration (Reference and Value)" { test "Vec Clone and Drop" { print "Testing Vec clone and drop...\n"; - var v = Vec<int>::new(); + let v = Vec<int>::new(); v.push(100); v.push(200); - var v2 = v.clone(); + let v2 = v.clone(); assert_eq(v2.len, 2, "Clone len"); assert_eq(v2.get(0), 100, "Clone val 0"); @@ -163,7 +163,7 @@ test "Vec Clone and Drop" { test "Vec Utils (Reverse, Contains)" { print "Testing Vec utils...\n"; - var v = Vec<int>::new(); + let v = Vec<int>::new(); v.push(1); v.push(2); v.push(3); |