fix: array methods + typed empty arrays

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [fix] — 2026-03-17
+- Added array methods: `.length()` and `.push()`
+- Allowed typed empty array assignment like `var xs: [int] = []`
+- Added `compiler/v1/src/tests/array_methods.rey` regression test
+
 ## [init] — 2026-03-17
 - Claude initialized as contributor
 - Created CLAUDE.md and primer.md

compiler/v1/src/interpreter/executor.rs

@@ -271,6 +271,19 @@ impl Executor {
 
     fn evaluate_method_call(&self, receiver: Value, name: &str, args: &[Value]) -> Result<Value, String> {
         match (receiver, name) {
+            (Value::Array(arr), "length") => {
+                if !args.is_empty() {
+                    return Err(format!("{}.length() expects 0 arguments, got {}", "Array", args.len()));
+                }
+                Ok(Value::Number(arr.borrow().len() as f64))
+            }
+            (Value::Array(arr), "push") => {
+                if args.len() != 1 {
+                    return Err(format!("{}.push() expects 1 argument, got {}", "Array", args.len()));
+                }
+                arr.borrow_mut().push(args[0].clone());
+                Ok(Value::Null)
+            }
             (Value::String(s), "length") => {
                 if !args.is_empty() {
                     return Err(format!("{}.length() expects 0 arguments, got {}", "String", args.len()));

compiler/v1/src/tests/array_methods.rey

@@ -0,0 +1,16 @@
+// Array method support
+
+func main(): Void {
+    var ints: [int] = [1, 2, 3];
+    println(ints.length());
+
+    var any = [];
+    any.push(1);
+    any.push("a");
+    println(any.length());
+
+    var result: [int] = [];
+    result.push(1);
+    result.push(2);
+    println(result.length());
+}

compiler/v1/src/typecheck.rs

@@ -172,7 +172,12 @@ impl TypeChecker {
                 let initTy = self.exprTy(initializer)?;
                 let finalTy = if let Some(ann) = ty {
                     let annTy = Ty::fromAnnotation(ann)?;
-                    if !initTy.isAssignableTo(&annTy) {
+                    let allowEmptyTypedArray = matches!(
+                        (initializer, &initTy, &annTy),
+                        (Expr::ArrayLiteral { elements }, Ty::Array(inner), Ty::Array(_))
+                            if elements.is_empty() && matches!(inner.as_ref(), Ty::Any)
+                    );
+                    if !initTy.isAssignableTo(&annTy) && !allowEmptyTypedArray {
                         return Err(format!(
                             "Type error: variable '{}' expected {:?} but got {:?}",
                             name, annTy, initTy
@@ -393,6 +398,25 @@ impl TypeChecker {
 
     fn methodTy(&mut self, receiver: &Ty, name: &str, args: &[Expr]) -> Result<Ty, String> {
         match (receiver, name) {
+            (Ty::Array(_), "length") => {
+                if !args.is_empty() {
+                    return Err("Type error: Array.length() expects 0 arguments".to_string());
+                }
+                Ok(Ty::Int)
+            }
+            (Ty::Array(inner), "push") => {
+                if args.len() != 1 {
+                    return Err("Type error: Array.push() expects 1 argument".to_string());
+                }
+                let a0 = self.exprTy(&args[0])?;
+                if !a0.isAssignableTo(inner.as_ref()) {
+                    return Err(format!(
+                        "Type error: Array.push() expected element {:?} but got {:?}",
+                        inner, a0
+                    ));
+                }
+                Ok(Ty::Void)
+            }
             (Ty::String, "length") | (Ty::String, "upper") | (Ty::String, "lower") => {
                 if !args.is_empty() {
                     return Err(format!("Type error: String.{}() expects 0 arguments", name));

primer.md

@@ -32,6 +32,7 @@ cargo run -- src/tests/variables.rey
 - Functions with optional typed params and return types
 - Builtins: println(), len(), push(), pop(), input()
 - Arrays: literals, indexing, typed arrays ([int])
+- Array methods: length(), push()
 - Dictionaries: literals, indexing, typed dicts ({String:int})
 - String methods: length/upper/lower/contains/split
 - Property access: obj.prop (dictionary key lookup)