superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty/test_cases/ext_call__if_condition.py

@@ -0,0 +1,37 @@
+# call-external
+# External calls in if conditions
+
+
+def check_positive():
+    if add_ints(1, 2) > 0:
+        return 'positive'
+    return 'not positive'
+
+
+result = check_positive()
+assert result == 'positive', 'ext call in if condition'
+
+
+def check_with_else():
+    if add_ints(-5, 3) > 0:
+        return 'positive'
+    else:
+        return 'negative or zero'
+
+
+result = check_with_else()
+assert result == 'negative or zero', 'ext call in if condition with else'
+
+
+def check_elif():
+    val = add_ints(5, 5)
+    if val > 15:
+        return 'big'
+    elif val > 5:
+        return 'medium'
+    else:
+        return 'small'
+
+
+result = check_elif()
+assert result == 'medium', 'ext call result used in elif chain'

package/ref-monty/crates/monty/test_cases/ext_call__in_closure.py

@@ -0,0 +1,14 @@
+# call-external
+# External function calls inside closures (nested functions with captured variables).
+
+
+def outer_with_nested():
+    x = 10
+
+    def inner():
+        return add_ints(x, 5)
+
+    return inner()
+
+
+assert outer_with_nested() == 15, 'ext call in nested function'

package/ref-monty/crates/monty/test_cases/ext_call__in_function.py

@@ -0,0 +1,40 @@
+# call-external
+# === External function calls inside user-defined functions ===
+
+# Basic function calling external function
+def add_wrapper(a, b):
+    return add_ints(a, b)
+
+
+result = add_wrapper(10, 20)
+assert result == 30, 'basic ext call in function'
+
+
+# Function with multiple external calls (sequential)
+def multi_ext():
+    x = add_ints(1, 2)
+    y = add_ints(3, 4)
+    return add_ints(x, y)
+
+
+assert multi_ext() == 10, 'multiple ext calls in function'
+
+
+# External call in function with local variable usage
+def with_locals():
+    x = 100
+    y = add_ints(x, 50)
+    z = y * 2
+    return z
+
+
+assert with_locals() == 300, 'ext call with locals'
+
+
+# Function returning external call result
+def get_sum(a, b, c):
+    temp = add_ints(a, b)
+    return add_ints(temp, c)
+
+
+assert get_sum(1, 2, 3) == 6, 'chained ext calls in function'

package/ref-monty/crates/monty/test_cases/ext_call__in_function_simple.py

@@ -0,0 +1,7 @@
+# call-external
+def foo():
+    return add_ints(1, 2)
+
+
+result = foo()
+assert result == 3, 'basic ext call in function'

package/ref-monty/crates/monty/test_cases/ext_call__literals.py

@@ -0,0 +1,17 @@
+# call-external
+# External calls in list and dict literals
+
+# External call in list literal
+lst = [add_ints(1, 2), add_ints(3, 4)]
+assert lst[0] == 3, 'ext call in list literal [0]'
+assert lst[1] == 7, 'ext call in list literal [1]'
+
+# External call in tuple literal
+tup = (add_ints(1, 1), add_ints(2, 2))
+assert tup[0] == 2, 'ext call in tuple literal [0]'
+assert tup[1] == 4, 'ext call in tuple literal [1]'
+
+# External call in dict value
+d = {'a': add_ints(5, 5), 'b': add_ints(10, 10)}
+assert d['a'] == 10, 'ext call in dict value a'
+assert d['b'] == 20, 'ext call in dict value b'

package/ref-monty/crates/monty/test_cases/ext_call__multi_in_func.py

@@ -0,0 +1,32 @@
+# call-external
+# Multiple external calls within user-defined functions
+
+
+def compute_sum():
+    a = add_ints(1, 2)
+    b = add_ints(3, 4)
+    c = add_ints(5, 6)
+    return a + b + c
+
+
+result = compute_sum()
+assert result == 21, 'multiple sequential ext calls in func'
+
+
+def compute_nested():
+    return add_ints(add_ints(1, 2), add_ints(3, 4))
+
+
+result = compute_nested()
+assert result == 10, 'nested ext calls in func'
+
+
+def outer():
+    def inner():
+        return add_ints(10, 20)
+
+    return inner() + add_ints(1, 2)
+
+
+result = outer()
+assert result == 33, 'ext call in nested func plus outer ext call'

package/ref-monty/crates/monty/test_cases/ext_call__name_lookup.py

@@ -0,0 +1,69 @@
+# call-external
+# Tests for NameLookup resolution with various value types.
+# Verifies that the host can inject non-function values (constants)
+# into the sandbox namespace via the NameLookup mechanism.
+
+# === Integer constant ===
+assert CONST_INT == 42, f'CONST_INT should be 42, got {CONST_INT}'
+assert CONST_INT + 8 == 50, 'CONST_INT arithmetic'
+assert type(CONST_INT) == int, f'CONST_INT type should be int, got {type(CONST_INT)}'
+
+# === String constant ===
+assert CONST_STR == 'hello', f'CONST_STR should be hello, got {CONST_STR}'
+assert CONST_STR + ' world' == 'hello world', 'CONST_STR concatenation'
+assert len(CONST_STR) == 5, f'CONST_STR length should be 5, got {len(CONST_STR)}'
+assert type(CONST_STR) == str, f'CONST_STR type should be str, got {type(CONST_STR)}'
+
+# === Float constant ===
+assert CONST_FLOAT == 3.14, f'CONST_FLOAT should be 3.14, got {CONST_FLOAT}'
+assert CONST_FLOAT + 0.86 == 4.0, 'CONST_FLOAT arithmetic'
+assert type(CONST_FLOAT) == float, f'CONST_FLOAT type should be float, got {type(CONST_FLOAT)}'
+
+# === Boolean constant ===
+assert CONST_BOOL == True, f'CONST_BOOL should be True, got {CONST_BOOL}'
+assert CONST_BOOL and True, 'CONST_BOOL in boolean expression'
+assert type(CONST_BOOL) == bool, f'CONST_BOOL type should be bool, got {type(CONST_BOOL)}'
+
+# === List constant ===
+assert CONST_LIST == [1, 2, 3], f'CONST_LIST should be [1, 2, 3], got {CONST_LIST}'
+assert len(CONST_LIST) == 3, f'CONST_LIST length should be 3, got {len(CONST_LIST)}'
+assert CONST_LIST[0] == 1, 'CONST_LIST first element'
+assert CONST_LIST[-1] == 3, 'CONST_LIST last element'
+assert type(CONST_LIST) == list, f'CONST_LIST type should be list, got {type(CONST_LIST)}'
+
+# === None constant ===
+assert CONST_NONE is None, f'CONST_NONE should be None, got {CONST_NONE}'
+assert type(CONST_NONE) == type(None), f'CONST_NONE type should be NoneType, got {type(CONST_NONE)}'
+
+# === Caching: same constant used twice should work ===
+x = CONST_INT
+y = CONST_INT
+assert x == y == 42, 'cached CONST_INT should be consistent'
+
+# === Mixed: constants and external functions in the same code ===
+result = add_ints(CONST_INT, 8)
+assert result == 50, f'add_ints(CONST_INT, 8) should be 50, got {result}'
+
+str_result = concat_strings(CONST_STR, ' world')
+assert str_result == 'hello world', f'concat with CONST_STR should be hello world, got {str_result}'
+
+# === Constants used in control flow ===
+if CONST_BOOL:
+    flag = 'yes'
+else:
+    flag = 'no'
+assert flag == 'yes', f'CONST_BOOL in if should take true branch, got {flag}'
+
+# === Constants used in loops ===
+total = 0
+for item in CONST_LIST:
+    total = total + item
+assert total == 6, f'sum of CONST_LIST should be 6, got {total}'
+
+
+# === Constants in function scope ===
+def use_constant():
+    return CONST_INT * 2
+
+
+assert use_constant() == 84, f'CONST_INT in function should be 84, got {use_constant()}'

package/ref-monty/crates/monty/test_cases/ext_call__name_lookup_undefined.py

@@ -0,0 +1,4 @@
+# call-external
+# When NameLookup returns Undefined for an unknown name, NameError is raised.
+totally_unknown_name
+# Raise=NameError("name 'totally_unknown_name' is not defined")

package/ref-monty/crates/monty/test_cases/ext_call__nested_calls.py

@@ -0,0 +1,14 @@
+# call-external
+# External calls in nested call expressions
+
+# Nested external calls - inner first
+result = add_ints(add_ints(1, 2), 3)
+assert result == 6, 'nested ext calls'
+
+# Triple nested
+result = add_ints(add_ints(add_ints(1, 1), 2), 3)
+assert result == 7, 'triple nested ext calls'
+
+# Two separate nested calls
+result = add_ints(add_ints(1, 2), add_ints(3, 4))
+assert result == 10, 'two nested ext calls in args'

package/ref-monty/crates/monty/test_cases/ext_call__recursion_bug.py

@@ -0,0 +1,19 @@
+# call-external
+# BUG: External calls in recursive functions produce wrong results
+# Recursion with external calls doesn't compute the correct value
+
+
+def sum_with_ext(n):
+    if n <= 0:
+        return 0
+    return add_ints(n, sum_with_ext(n - 1))
+
+
+# sum_with_ext(3) should compute:
+#   add_ints(3, sum_with_ext(2))
+#   add_ints(3, add_ints(2, sum_with_ext(1)))
+#   add_ints(3, add_ints(2, add_ints(1, sum_with_ext(0))))
+#   add_ints(3, add_ints(2, add_ints(1, 0)))
+#   = 3 + 2 + 1 = 6
+result = sum_with_ext(3)
+assert result == 6, 'recursive ext call: 1+2+3=6'

package/ref-monty/crates/monty/test_cases/ext_call__return.py

@@ -0,0 +1,28 @@
+# call-external
+# External calls in return statements
+
+
+def direct_return():
+    return add_ints(10, 20)
+
+
+result = direct_return()
+assert result == 30, 'ext call as direct return value'
+
+
+def return_with_expression():
+    return add_ints(1, 2) + add_ints(3, 4)
+
+
+result = return_with_expression()
+assert result == 10, 'ext call expression as return value'
+
+
+def conditional_return():
+    if return_value(True):
+        return add_ints(100, 200)
+    return add_ints(1, 1)
+
+
+result = conditional_return()
+assert result == 300, 'ext call in conditional return'

package/ref-monty/crates/monty/test_cases/ext_call__side_effects.py

@@ -0,0 +1,25 @@
+# call-external
+def log(msg):
+    print(msg)
+    return 1
+
+
+def inner(x):
+    print('Inner called')
+    val = add_ints(x, 1)  # External call
+    print('Inner resumed')
+    return val
+
+
+def outer():
+    print('Outer calling inner')
+    # If side effects are duplicated, we'll see "Evaluating arg" twice
+    res = inner(log('Evaluating arg'))
+    print('Outer returned')
+    return res
+
+
+print('Starting')
+res = outer()
+print(f'Result: {res}')
+assert res == 2

package/ref-monty/crates/monty/test_cases/ext_call__subscript.py

@@ -0,0 +1,7 @@
+# call-external
+# External calls in subscript operations
+
+# External call as subscript index
+items = [10, 20, 30]
+result = items[add_ints(0, 1)]
+assert result == 20, 'ext call as subscript index'

package/ref-monty/crates/monty/test_cases/ext_call__ternary.py

@@ -0,0 +1,28 @@
+# call-external
+# External calls in ternary expressions (if/else expressions)
+
+# External call in true branch
+result = add_ints(1, 2) if True else add_ints(10, 20)
+assert result == 3, 'ext call in ternary true branch'
+
+# External call in false branch
+result = add_ints(1, 2) if False else add_ints(10, 20)
+assert result == 30, 'ext call in ternary false branch'
+
+# External call in condition
+result = 'yes' if return_value(True) else 'no'
+assert result == 'yes', 'ext call in ternary condition (true)'
+
+result = 'yes' if return_value(False) else 'no'
+assert result == 'no', 'ext call in ternary condition (false)'
+
+# External calls in both branches
+result = add_ints(1, 2) if return_value(True) else add_ints(10, 20)
+assert result == 3, 'ext call in condition and true branch'
+
+result = add_ints(1, 2) if return_value(False) else add_ints(10, 20)
+assert result == 30, 'ext call in condition and false branch'
+
+# Nested ternary with external calls
+result = add_ints(1, 1) if return_value(True) else (add_ints(2, 2) if return_value(False) else add_ints(3, 3))
+assert result == 2, 'nested ternary with ext calls'

package/ref-monty/crates/monty/test_cases/ext_call__try.py

@@ -0,0 +1,280 @@
+# call-external
+# === External calls in try blocks ===
+
+# Basic external call in try body
+result = None
+try:
+    result = add_ints(10, 20)
+except:
+    result = -1
+assert result == 30, 'ext call in try body'
+
+# Multiple external calls in try body
+try:
+    a = add_ints(1, 2)
+    b = add_ints(3, 4)
+    c = add_ints(a, b)
+except:
+    c = -1
+assert c == 10, 'multiple ext calls in try body'
+
+# Nested external calls in try body
+try:
+    nested = add_ints(add_ints(1, 2), add_ints(3, 4))
+except:
+    nested = -1
+assert nested == 10, 'nested ext calls in try body'
+
+# === External calls in except blocks ===
+
+# External call in except handler
+handler_result = None
+try:
+    raise ValueError('error')
+except ValueError:
+    handler_result = add_ints(100, 200)
+assert handler_result == 300, 'ext call in except handler'
+
+# Multiple external calls in except handler
+try:
+    raise TypeError('error')
+except TypeError:
+    x = add_ints(5, 5)
+    y = add_ints(10, 10)
+    handler_sum = add_ints(x, y)
+assert handler_sum == 30, 'multiple ext calls in except handler'
+
+# External call with exception variable
+exc_with_ext = None
+try:
+    raise ValueError('test')
+except ValueError as e:
+    prefix = concat_strings('caught: ', repr(e))
+    exc_with_ext = prefix
+assert exc_with_ext == "caught: ValueError('test')", 'ext call with exception variable'
+
+# === External calls in else blocks ===
+
+# External call in else block
+else_result = None
+try:
+    x = 1  # No exception
+except:
+    else_result = -1
+else:
+    else_result = add_ints(50, 50)
+assert else_result == 100, 'ext call in else block'
+
+# Multiple external calls in else block
+try:
+    pass
+except:
+    else_multi = -1
+else:
+    p = add_ints(1, 2)
+    q = add_ints(3, 4)
+    else_multi = add_ints(p, q)
+assert else_multi == 10, 'multiple ext calls in else block'
+
+# === External calls in finally blocks ===
+
+# External call in finally block
+finally_result = None
+try:
+    x = 1
+finally:
+    finally_result = add_ints(25, 75)
+assert finally_result == 100, 'ext call in finally block'
+
+# Finally with external call after exception caught
+finally_after_exc = None
+try:
+    raise ValueError('error')
+except ValueError:
+    pass
+finally:
+    finally_after_exc = add_ints(1, 99)
+assert finally_after_exc == 100, 'ext call in finally after caught exception'
+
+# Multiple external calls in finally
+try:
+    pass
+finally:
+    f1 = add_ints(10, 20)
+    f2 = add_ints(30, 40)
+    finally_multi = add_ints(f1, f2)
+assert finally_multi == 100, 'multiple ext calls in finally block'
+
+# === External calls across multiple phases ===
+
+# External calls in try, except, and finally
+all_phases = []
+try:
+    all_phases.append(add_ints(1, 0))  # 1
+    raise ValueError('error')
+except ValueError:
+    all_phases.append(add_ints(2, 0))  # 2
+finally:
+    all_phases.append(add_ints(3, 0))  # 3
+assert all_phases == [1, 2, 3], 'ext calls in try, except, and finally'
+
+# External calls in try, else, and finally (no exception)
+no_exc_phases = []
+try:
+    no_exc_phases.append(add_ints(10, 0))  # 10
+except:
+    no_exc_phases.append(-1)
+else:
+    no_exc_phases.append(add_ints(20, 0))  # 20
+finally:
+    no_exc_phases.append(add_ints(30, 0))  # 30
+assert no_exc_phases == [10, 20, 30], 'ext calls in try, else, and finally'
+
+# === External calls in nested try blocks ===
+
+# Nested try with external calls at each level
+outer_val = None
+inner_val = None
+try:
+    outer_val = add_ints(100, 0)
+    try:
+        inner_val = add_ints(200, 0)
+        raise ValueError('inner')
+    except ValueError:
+        inner_val = add_ints(inner_val, 50)
+except:
+    outer_val = -1
+assert outer_val == 100, 'ext call in outer try'
+assert inner_val == 250, 'ext call in inner try and handler'
+
+# === External calls in exception type expression ===
+# (Exception type is evaluated at handler matching time)
+
+# External call producing value used after try
+post_try = None
+try:
+    pre = add_ints(5, 5)
+except:
+    pre = -1
+post_try = add_ints(pre, 10)
+assert post_try == 20, 'ext call result used after try block'
+
+# === External call in finally with unhandled exception ===
+# Finally should still run even when exception propagates
+finally_with_propagate = None
+try:
+    try:
+        finally_with_propagate = add_ints(0, 0)  # Initialize
+        raise KeyError('unhandled')
+    except ValueError:
+        pass  # Won't catch KeyError
+    finally:
+        finally_with_propagate = add_ints(42, 0)  # Should still run
+except KeyError:
+    pass  # Catch propagated exception
+assert finally_with_propagate == 42, 'ext call in finally should run even with unhandled exception'
+
+# === External call in except handler that then raises ===
+handler_before_raise = None
+try:
+    try:
+        raise ValueError('original')
+    except ValueError:
+        handler_before_raise = add_ints(10, 0)  # External call before raising
+        raise TypeError('from handler')
+except TypeError:
+    pass
+assert handler_before_raise == 10, 'ext call in handler before raising'
+
+# === External call in else block that then raises ===
+else_before_raise = None
+try:
+    try:
+        pass  # No exception
+    except:
+        pass
+    else:
+        else_before_raise = add_ints(20, 0)  # External call before raising
+        raise ValueError('from else')
+except ValueError:
+    pass
+assert else_before_raise == 20, 'ext call in else before raising'
+
+# === External call preserves state across try/except ===
+state_before = add_ints(1000, 0)
+state_after = None
+try:
+    state_after = add_ints(state_before, 1)
+    raise ValueError('test')
+except ValueError:
+    state_after = add_ints(state_after, 10)
+finally:
+    state_after = add_ints(state_after, 100)
+assert state_after == 1111, 'state preserved across try/except with ext calls'
+
+# === Multiple except handlers with external calls ===
+which_handler = None
+try:
+    raise TypeError('test')
+except ValueError:
+    which_handler = add_ints(1, 0)
+except TypeError:
+    which_handler = add_ints(2, 0)
+except KeyError:
+    which_handler = add_ints(3, 0)
+assert which_handler == 2, 'ext call in correct handler with multiple handlers'
+
+# === External call in finally with pending exception (after handler raises) ===
+finally_after_handler_raise = None
+try:
+    try:
+        raise ValueError('original')
+    except ValueError:
+        finally_after_handler_raise = add_ints(10, 0)  # External call before raising
+        raise TypeError('from handler')
+    finally:
+        # This external call should work even though there's a pending exception
+        finally_after_handler_raise = add_ints(finally_after_handler_raise, 5)
+except TypeError:
+    pass
+assert finally_after_handler_raise == 15, 'ext call in finally with pending exception from handler'
+
+# === External call in finally with pending exception (no matching handler) ===
+finally_with_pending_exc = None
+try:
+    try:
+        finally_with_pending_exc = add_ints(0, 0)
+        raise KeyError('no handler')
+    except ValueError:
+        pass  # Won't catch KeyError
+    finally:
+        # This external call should work even though KeyError is pending
+        finally_with_pending_exc = add_ints(100, 0)
+except KeyError:
+    pass  # Catch it here
+assert finally_with_pending_exc == 100, 'ext call in finally with unhandled exception pending'
+
+# === External call in finally with return (uses simple values) ===
+# Note: External calls in user-defined functions are not supported,
+# so we test pending return with built-in operations only
+finally_return_result = None
+try:
+    finally_return_result = 'in_try'
+finally:
+    pass  # finally runs but doesn't override
+assert finally_return_result == 'in_try', 'finally runs with pending value'
+
+# === Multiple external calls in finally with pending exception ===
+multi_finally = None
+try:
+    try:
+        raise ValueError('test')
+    except TypeError:
+        pass  # Won't match
+    finally:
+        a = add_ints(1, 2)
+        b = add_ints(3, 4)
+        multi_finally = add_ints(a, b)
+except ValueError:
+    pass
+assert multi_finally == 10, 'multiple ext calls in finally with pending exception'

package/ref-monty/crates/monty/test_cases/ext_call__try_simple.py

@@ -0,0 +1,10 @@
+# call-external
+# Test external call with exception variable
+
+exc_with_ext = None
+try:
+    raise ValueError('test')
+except ValueError as e:
+    prefix = concat_strings('caught: ', repr(e))
+    exc_with_ext = prefix
+assert exc_with_ext == "caught: ValueError('test')", 'ext call with exception variable'

package/ref-monty/crates/monty/test_cases/ext_call__unary.py

@@ -0,0 +1,13 @@
+# call-external
+# External calls in unary expressions
+
+# Negation of external call result
+result = -add_ints(3, 4)
+assert result == -7, 'negation of ext call'
+
+# Not of external call
+result = not return_value(False)
+assert result == True, 'not of ext call returning False'
+
+result = not return_value(True)
+assert result == False, 'not of ext call returning True'