konpeito 0.2.2 → 0.2.3

data/tools/konpeito-asm/src/konpeito/runtime/KArray.java

@@ -12,6 +12,13 @@ import java.util.*;
  */
 public class KArray<T> implements List<T> {
     private final ArrayList<T> data;
+    private boolean frozen = false;
+
+    /** Ruby: arr.freeze */
+    public void freeze() { frozen = true; }
+
+    /** Ruby: arr.frozen? */
+    public boolean isFrozen() { return frozen; }
 
     // ========================================================================
     // Constructors
@@ -127,7 +134,26 @@ public class KArray<T> implements List<T> {
     @SuppressWarnings("unchecked")
     public KArray<T> sort() {
         KArray<T> result = new KArray<>(data);
-        result.data.sort((a, b) -> ((Comparable<T>) a).compareTo(b));
+        result.data.sort((a, b) -> {
+            // Try Java Comparable first
+            if (a instanceof Comparable) {
+                try {
+                    return ((Comparable<T>) a).compareTo(b);
+                } catch (ClassCastException e) {
+                    // Fall through to op_cmp
+                }
+            }
+            // Try Ruby <=> (op_cmp) via reflection
+            try {
+                java.lang.reflect.Method cmp = a.getClass().getMethod("op_cmp", Object.class);
+                Object res = cmp.invoke(a, b);
+                if (res instanceof Long) return ((Long) res).intValue();
+                if (res instanceof Integer) return (Integer) res;
+                return 0;
+            } catch (Exception e) {
+                throw new ClassCastException("Cannot compare " + a.getClass().getName());
+            }
+        });
         return result;
     }
 
@@ -181,6 +207,15 @@ public class KArray<T> implements List<T> {
         return this;
     }
 
+    /** Ruby: arr.concat(other) — append all elements from other array, return self */
+    @SuppressWarnings("unchecked")
+    public KArray<T> concat(Object other) {
+        if (other instanceof KArray) {
+            data.addAll(((KArray<T>) other).data);
+        }
+        return this;
+    }
+
     /** Ruby: arr.delete_at(index) — remove and return element at index */
     public T deleteAt(int index) {
         int idx = index < 0 ? data.size() + index : index;
@@ -188,12 +223,54 @@ public class KArray<T> implements List<T> {
         return data.remove(idx);
     }
 
-    /** Ruby: arr.delete(value) — remove all occurrences, return last removed or nil */
+    /** Ruby: arr.delete(value) — remove all occurrences, return value or nil */
     public T deleteValue(T value) {
-        boolean found = data.remove(value);
+        boolean found = false;
+        java.util.Iterator<T> it = data.iterator();
+        while (it.hasNext()) {
+            if (java.util.Objects.equals(it.next(), value)) {
+                it.remove();
+                found = true;
+            }
+        }
+        return found ? value : null;
+    }
+
+    /** Ruby: arr.delete(value) — alias used by invokedynamic dispatch */
+    public Object delete(Object value) {
+        boolean found = false;
+        java.util.Iterator<T> it = data.iterator();
+        while (it.hasNext()) {
+            if (java.util.Objects.equals(it.next(), value)) {
+                it.remove();
+                found = true;
+            }
+        }
         return found ? value : null;
     }
 
+    /** Ruby: arr.rotate / arr.rotate(n) — returns new rotated array */
+    public KArray<T> rotate() {
+        return rotate(1);
+    }
+
+    /** Ruby: arr.rotate(n) — returns new rotated array by n positions */
+    public KArray<T> rotate(int n) {
+        int size = data.size();
+        if (size == 0) return new KArray<>();
+        int shift = ((n % size) + size) % size; // normalize negative
+        KArray<T> result = new KArray<>(size);
+        for (int i = 0; i < size; i++) {
+            result.data.add(data.get((i + shift) % size));
+        }
+        return result;
+    }
+
+    /** Ruby: arr.rotate(n) — overload accepting long for JVM compat */
+    public KArray<T> rotate(long n) {
+        return rotate((int) n);
+    }
+
     /** Ruby: arr.sum — sum all elements (for numeric arrays) */
     @SuppressWarnings("unchecked")
     public long sumLong() {
@@ -216,12 +293,18 @@ public class KArray<T> implements List<T> {
         return total;
     }
 
-    /** Ruby: arr.find_index(value) — returns index or -1 */
+    /** Ruby: arr.find_index(value) / arr.index(value) — returns index or nil */
     public long findIndex(T value) {
         int idx = data.indexOf(value);
         return idx;
     }
 
+    /** Ruby: arr.index(value) — alias for findIndex, returns Long index or null (nil) */
+    public Object index(Object value) {
+        int idx = data.indexOf(value);
+        return idx >= 0 ? Long.valueOf(idx) : null;
+    }
+
     /** Ruby: arr.first(n) — returns first n elements */
     public KArray<T> first(int n) {
         KArray<T> result = new KArray<>();
@@ -256,6 +339,16 @@ public class KArray<T> implements List<T> {
         return result;
     }
 
+    /** Multi-assign splat: collect elements from startIndex to size()-endOffset */
+    public KArray<T> splatSlice(int startIndex, int endOffset) {
+        KArray<T> result = new KArray<>();
+        int end = data.size() - endOffset;
+        for (int i = startIndex; i < end; i++) {
+            result.data.add(data.get(i));
+        }
+        return result;
+    }
+
     /** Ruby: arr.zip(other) — pairs elements from two arrays */
     @SuppressWarnings("unchecked")
     public KArray<KArray<Object>> zip(KArray<?> other) {

data/tools/konpeito-asm/src/konpeito/runtime/KConditionVariable.java

@@ -1,48 +1,43 @@
 package konpeito.runtime;
 
-import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * KConditionVariable - Ruby ConditionVariable implementation for JVM backend.
  *
- * Uses an internal ReentrantLock + Condition pair.
- * Note: In Ruby, ConditionVariable can be used with any Mutex.
- * This simplified implementation uses its own internal lock.
+ * Uses an Object monitor internally. When await(mutex) is called, the caller's
+ * mutex is released (matching Ruby cv.wait(mutex) semantics), then we wait on
+ * the internal monitor, and reacquire the mutex before returning.
  */
 public class KConditionVariable {
-    private final ReentrantLock lock = new ReentrantLock();
-    private final Condition condition = lock.newCondition();
+    private final Object monitor = new Object();
 
-    /** Ruby: cv.wait(mutex) — waits for signal */
-    public void await() {
-        lock.lock();
-        try {
-            condition.await();
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-        } finally {
-            lock.unlock();
+    /** Ruby: cv.wait(mutex) — releases mutex, waits for signal, reacquires mutex */
+    public void await(ReentrantLock mutex) {
+        // Release the caller's mutex (Ruby CV#wait semantics)
+        mutex.unlock();
+        synchronized (monitor) {
+            try {
+                monitor.wait();
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
         }
+        // Reacquire the caller's mutex before returning
+        mutex.lock();
     }
 
     /** Ruby: cv.signal — wakes one waiting thread */
     public void signal() {
-        lock.lock();
-        try {
-            condition.signal();
-        } finally {
-            lock.unlock();
+        synchronized (monitor) {
+            monitor.notify();
         }
     }
 
     /** Ruby: cv.broadcast — wakes all waiting threads */
     public void broadcast() {
-        lock.lock();
-        try {
-            condition.signalAll();
-        } finally {
-            lock.unlock();
+        synchronized (monitor) {
+            monitor.notifyAll();
         }
     }
 }

data/tools/konpeito-asm/src/konpeito/runtime/KFiber.java

@@ -0,0 +1,112 @@
+package konpeito.runtime;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.SynchronousQueue;
+
+/**
+ * KFiber - Ruby Fiber implementation for JVM backend using Java 21 Virtual Threads.
+ *
+ * Uses a pair of SynchronousQueues for handshake between caller and fiber:
+ * - resumeQueue: caller sends resume value to fiber
+ * - yieldQueue: fiber sends yielded value to caller
+ *
+ * ThreadLocal tracks the current fiber for Fiber.yield().
+ */
+public class KFiber {
+    private static final ThreadLocal<KFiber> currentFiber = new ThreadLocal<>();
+
+    // Sentinel object to distinguish null/nil yield values from "no value"
+    private static final Object SENTINEL = new Object();
+
+    private final Callable<Object> body;
+    private final SynchronousQueue<Object> resumeQueue = new SynchronousQueue<>();
+    private final SynchronousQueue<Object> yieldQueue = new SynchronousQueue<>();
+    private Thread thread;
+    private volatile boolean alive = true;
+    private volatile boolean started = false;
+
+    public KFiber(Callable<Object> body) {
+        this.body = body;
+    }
+
+    /**
+     * Ruby: fiber.resume or fiber.resume(value)
+     * Starts the fiber on first call, resumes it on subsequent calls.
+     * Returns the value passed to Fiber.yield or the fiber's final return value.
+     */
+    public Object resume(Object value) {
+        try {
+            if (!started) {
+                started = true;
+                thread = Thread.ofVirtual().start(() -> {
+                    currentFiber.set(this);
+                    try {
+                        Object result = body.call();
+                        // Fiber completed: send final result
+                        yieldQueue.put(result != null ? result : SENTINEL);
+                    } catch (Exception e) {
+                        try {
+                            yieldQueue.put(SENTINEL);
+                        } catch (InterruptedException ie) {
+                            Thread.currentThread().interrupt();
+                        }
+                    } finally {
+                        alive = false;
+                        currentFiber.remove();
+                    }
+                });
+            } else {
+                // Send resume value to fiber
+                resumeQueue.put(value != null ? value : SENTINEL);
+            }
+            // Wait for fiber to yield or complete
+            Object result = yieldQueue.take();
+            return result == SENTINEL ? null : result;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return null;
+        }
+    }
+
+    /** Ruby: fiber.resume (no args) */
+    public Object resume() {
+        return resume(null);
+    }
+
+    /**
+     * Ruby: Fiber.yield(value)
+     * Called from within a fiber to suspend execution and send a value to the caller.
+     * Returns the value passed to the next resume() call.
+     */
+    public static Object fiberYield(Object value) {
+        KFiber fiber = currentFiber.get();
+        if (fiber == null) {
+            throw new RuntimeException("Fiber.yield called outside of a fiber");
+        }
+        try {
+            // Send yielded value to caller
+            fiber.yieldQueue.put(value != null ? value : SENTINEL);
+            // Wait for next resume
+            Object resumeValue = fiber.resumeQueue.take();
+            return resumeValue == SENTINEL ? null : resumeValue;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return null;
+        }
+    }
+
+    /** Ruby: Fiber.yield (no args) */
+    public static Object fiberYield() {
+        return fiberYield(null);
+    }
+
+    /** Ruby: fiber.alive? */
+    public boolean isAlive() {
+        return alive;
+    }
+
+    /** Ruby: Fiber.current */
+    public static KFiber current() {
+        return currentFiber.get();
+    }
+}

data/tools/konpeito-asm/src/konpeito/runtime/KHash.java

@@ -116,6 +116,73 @@ public class KHash<K, V> implements Map<K, V> {
         return new KArray<>(data.values());
     }
 
+    /** Helper for group_by: adds elem to the array at hash[key], creating it if absent */
+    @SuppressWarnings("unchecked")
+    public void groupByAdd(Object key, Object elem) {
+        Object existing = data.get((K) key);
+        KArray<Object> group;
+        if (existing instanceof KArray) {
+            group = (KArray<Object>) existing;
+        } else {
+            group = new KArray<>();
+            data.put((K) key, (V) group);
+        }
+        group.add(elem);
+    }
+
+    /** Ruby: hash.sort_by { |pair| pair[index] } — sort by element at index in each [k,v] pair.
+     *  Returns KArray of KArray pairs sorted by the element at the given index. */
+    @SuppressWarnings("unchecked")
+    public KArray<KArray<Object>> sortByIndex(int index) {
+        KArray<KArray<Object>> pairs = toArray_();
+        // Selection sort by element at given index
+        int n = pairs.size();
+        for (int i = 0; i < n - 1; i++) {
+            int minIdx = i;
+            for (int j = i + 1; j < n; j++) {
+                Comparable<Object> sj = (Comparable<Object>) pairs.get(j).get(index);
+                Comparable<Object> sm = (Comparable<Object>) pairs.get(minIdx).get(index);
+                if (sj.compareTo((Object) sm) < 0) {
+                    minIdx = j;
+                }
+            }
+            if (minIdx != i) {
+                KArray<Object> tmp = pairs.get(i);
+                pairs.set(i, pairs.get(minIdx));
+                pairs.set(minIdx, tmp);
+            }
+        }
+        return pairs;
+    }
+
+    /** Sort pairs by scores — used by JVM codegen for sort_by.
+     *  pairs and scores are parallel KArrays. Sorts both in-place by scores ascending. */
+    @SuppressWarnings("unchecked")
+    public static void sortPairsByScores(KArray<Object> pairs, KArray<Object> scores) {
+        int n = pairs.size();
+        // Selection sort — simple and O(n²) is fine for small hashes
+        for (int i = 0; i < n - 1; i++) {
+            int minIdx = i;
+            for (int j = i + 1; j < n; j++) {
+                Comparable<Object> sj = (Comparable<Object>) scores.get(j);
+                Comparable<Object> sm = (Comparable<Object>) scores.get(minIdx);
+                if (sj.compareTo((Object) sm) < 0) {
+                    minIdx = j;
+                }
+            }
+            if (minIdx != i) {
+                // Swap pairs
+                Object tmp = pairs.get(i);
+                pairs.set(i, pairs.get(minIdx));
+                pairs.set(minIdx, tmp);
+                // Swap scores
+                Object stmp = scores.get(i);
+                scores.set(i, scores.get(minIdx));
+                scores.set(minIdx, stmp);
+            }
+        }
+    }
+
     // ========================================================================
     // Map<K,V> interface delegation
     // ========================================================================

data/tools/konpeito-asm/src/konpeito/runtime/KMatchData.java

@@ -0,0 +1,55 @@
+package konpeito.runtime;
+
+/**
+ * KMatchData - Ruby MatchData implementation for JVM backend.
+ *
+ * Wraps regex match results with group access and the original input string.
+ */
+public class KMatchData {
+    private final KArray<String> groups;
+    private final String inputString;
+
+    public KMatchData(KArray<String> groups, String inputString) {
+        this.groups = groups;
+        this.inputString = inputString;
+    }
+
+    /** MatchData#[](index) — returns the nth match group (0 = full match) */
+    public Object get(int index) {
+        if (index < 0 || index >= groups.size()) return null;
+        return groups.get(index);
+    }
+
+    /** MatchData#to_s — returns the entire matched string (group 0) */
+    public String toString() {
+        if (groups.isEmpty()) return "";
+        return groups.get(0) != null ? groups.get(0) : "";
+    }
+
+    /** MatchData#string — returns a copy of the match string (input) */
+    public String string() {
+        return inputString;
+    }
+
+    /** MatchData#captures — returns capture groups (excluding group 0) */
+    public KArray<String> captures() {
+        KArray<String> result = new KArray<>();
+        for (int i = 1; i < groups.size(); i++) {
+            result.push(groups.get(i));
+        }
+        return result;
+    }
+
+    /** MatchData#size / MatchData#length — number of elements (including full match) */
+    public long length() {
+        return groups.size();
+    }
+
+    /** MatchData#pre_match — returns the string before the match */
+    // Note: would need start index to implement fully
+
+    /** MatchData#class */
+    public String k_class() {
+        return "MatchData";
+    }
+}

data/tools/konpeito-asm/src/konpeito/runtime/KRubyException.java

@@ -0,0 +1,79 @@
+package konpeito.runtime;
+
+/**
+ * KRubyException - Wrapper for Ruby exceptions on JVM.
+ *
+ * Carries the Ruby exception class name and supports hierarchy checking
+ * for rescue clause matching.
+ */
+public class KRubyException extends RuntimeException {
+    private final String rubyClassName;
+
+    // Ruby exception hierarchy (simplified)
+    private static final java.util.Map<String, String> PARENT_MAP = new java.util.HashMap<>();
+    static {
+        // Standard exception hierarchy
+        PARENT_MAP.put("RuntimeError", "StandardError");
+        PARENT_MAP.put("ArgumentError", "StandardError");
+        PARENT_MAP.put("TypeError", "StandardError");
+        PARENT_MAP.put("NameError", "StandardError");
+        PARENT_MAP.put("NoMethodError", "NameError");
+        PARENT_MAP.put("ZeroDivisionError", "StandardError");
+        PARENT_MAP.put("RangeError", "StandardError");
+        PARENT_MAP.put("IOError", "StandardError");
+        PARENT_MAP.put("StopIteration", "StandardError");
+        PARENT_MAP.put("KeyError", "StandardError");
+        PARENT_MAP.put("IndexError", "StandardError");
+        PARENT_MAP.put("NotImplementedError", "StandardError");
+        PARENT_MAP.put("StandardError", "Exception");
+        PARENT_MAP.put("Exception", null);
+    }
+
+    public KRubyException(String rubyClassName, String message) {
+        super(message);
+        this.rubyClassName = rubyClassName;
+    }
+
+    public KRubyException(String rubyClassName) {
+        super(rubyClassName);
+        this.rubyClassName = rubyClassName;
+    }
+
+    public String getRubyClassName() {
+        return rubyClassName;
+    }
+
+    /**
+     * Register a custom exception class in the hierarchy.
+     * Called during class initialization for user-defined exception classes.
+     */
+    public static void registerExceptionClass(String className, String parentClassName) {
+        PARENT_MAP.put(className, parentClassName);
+    }
+
+    /**
+     * Check if this exception matches the given rescue class name.
+     * Walks up the hierarchy to find a match.
+     */
+    public boolean matchesRescueClass(String rescueClassName) {
+        if (rescueClassName == null || rescueClassName.equals("StandardError")) {
+            // bare rescue or StandardError catches all standard errors
+            return isSubclassOf(rubyClassName, "StandardError");
+        }
+        return isSubclassOf(rubyClassName, rescueClassName);
+    }
+
+    private static boolean isSubclassOf(String className, String targetClass) {
+        String current = className;
+        while (current != null) {
+            if (current.equals(targetClass)) return true;
+            current = PARENT_MAP.get(current);
+        }
+        // If class not in hierarchy, assume it's a subclass of StandardError
+        // (user-defined exceptions without explicit registration)
+        if (className != null && !PARENT_MAP.containsKey(className)) {
+            return targetClass.equals("StandardError") || targetClass.equals("Exception");
+        }
+        return false;
+    }
+}

data/tools/konpeito-asm/src/konpeito/runtime/KSizedQueue.java

@@ -46,4 +46,9 @@ public class KSizedQueue {
     public int size() {
         return queue.size();
     }
+
+    /** Ruby: sq.empty? — returns true if queue is empty */
+    public boolean empty_q() {
+        return queue.isEmpty();
+    }
 }