rapydscript-ns 0.8.0

package/test/starargs.pyj

@@ -0,0 +1,506 @@
+# vim:fileencoding=utf-8
+# globals: assrt
+
+eq = assrt.equal
+de = assrt.deepEqual
+
+def get(obj, name):
+    return obj[name] if obj else undefined
+
+# Test the parsing of function definitions {{{
+
+def basic_test(code, arglen, starargs, kwargs, defaults):
+    func = RapydScript.parse('def func(' + code + '): pass\n', {'filename':code}).body[0]
+    eq(func.argnames.length, arglen)
+    eq(get(func.argnames.starargs, 'name'), starargs)
+    eq(get(func.argnames.kwargs, 'name'), kwargs)
+    eq(func.argnames.is_simple_func, bool(not starargs and not kwargs and not defaults))
+    if defaults:
+        fd = {}
+        for key in Object.keys(func.argnames.defaults):
+            fd[key] = func.argnames.defaults[key].value
+        de(fd, defaults)
+    return func
+
+def throw_test(code):
+    assrt.throws(def():
+        RapydScript.parse('def func(' + code + '): pass\n', {'filename':code}).body[0]
+    , RapydScript.SyntaxError)
+
+basic_test('a, b, c', 3)
+basic_test('*args', 0, 'args')
+basic_test('a, b, *args', 2, 'args')
+throw_test('*args, a')
+throw_test('*args, *a')
+basic_test('**kwargs', 0, undefined, 'kwargs')
+basic_test('*args, **kwargs', 0, 'args', 'kwargs')
+basic_test('a, b, *args, **kwargs', 2, 'args', 'kwargs')
+throw_test('**kw, *a')
+throw_test('**kw, **a')
+basic_test('a=1, b="2"', 2, None, None, {'a':1, 'b':"2"})
+basic_test('x, a=1, b="2", *args, **kw', 3, 'args', 'kw', {'a':1, 'b':"2"})
+throw_test('a=1, b')
+throw_test('**k, a=1')
+throw_test('a, a')
+throw_test('a, a=1')
+throw_test('*a, **a')
+# }}}
+
+# Test parsing of function calls {{{
+
+def parse_call_test(code, arglen, opts):
+    func = RapydScript.parse('f(' + code + ')', {'filename':code}).body[0].body
+    opts = opts or {}
+    eq(func.args.length, arglen, 'Incorrect len for: ' + code)
+    if (opts.starargs != undefined):
+        si = [[i, x.name] for i, x in enumerate(func.args) if x.is_array]
+        de(opts.starargs, si, 'starargs wrong for: ' + code + ': ' + si + ' != ' + opts.starargs)
+    if (opts.kwargs != undefined):
+        de(opts.kwargs, [x[0].name for x in func.args.kwargs])
+
+
+parse_call_test('a, b, c', 3)
+parse_call_test('*args', 1, {'starargs':[[0, 'args']]})
+parse_call_test('a, b, *args', 3, {'starargs':[[2, 'args']]})
+parse_call_test('a, *args, b, *a2', 4, {'starargs':[[1, 'args'], [3, 'a2']]})
+parse_call_test('a=1', 0, {'kwargs':['a']})
+parse_call_test('a=1, b', 1, {'kwargs':['a']})
+parse_call_test('a=1, b, **kwargs, *args, **k2', 2, {'kwargs':['a'], 'kw':['kwargs', 'k2'], 'starargs':[[1,'args']]})
+# }}}
+
+# Test calling {{{
+
+def f():
+    return Array.prototype.slice.call(arguments)
+
+
+de(f(1, 2, 3), [1, 2, 3])
+args1, args2 = [4, 5, 6], [7, 8, 9]
+kw1, kw2 = {'a':4, 'b':5, 'c':6}, {'a':7, 'x':8, 'y':9}
+
+de(f(*args1), [4, 5, 6])
+de(f(1, *args1), [1, 4, 5, 6])
+de(f(*args1, 2), [4, 5, 6, 2])
+de(f(1, *args1, 2), [1, 4, 5, 6, 2])
+de(f(*args1, *args2), args1.concat(args2))
+de(f(*args1, 1, 2, *args2, 3), [4, 5, 6, 1, 2, 7, 8, 9, 3])
+
+de(f(1, a=2), [1, {'a':2}])
+de(f(1, a=2, 3), [1, 3, {'a':2}])
+de(f(**kw1), [kw1])
+de(f(1, a=2, 3, **kw1), [1, 3, {'a':2, 'b':5, 'c':6}])
+de(f(**kw2, 1, 3, **kw1, 2), [1, 3, 2, {'a':4, 'b':5, 'c':6, 'x':8, 'y':9}])
+
+# }}}
+
+# Test calling with definitions {{{
+
+def f1(a, b, c):
+    return a, b, c
+de(f1(1, 2, 3), [1, 2, 3])
+de(f1(), [undefined, undefined, undefined])
+
+def f2(a, b=1):
+    return a, b
+
+de(f2(), [undefined, 1])
+de(f2(1), [1, 1])
+de(f2(1, 2), [1, 2])
+de(f2(b=2), [undefined, 2])
+de(f2(1, b=2), [1, 2])
+de(f2({'b':3}), [{'b':3}, 1], 'a normal object is being treated as an options object')
+
+def f3(*args):
+    return args
+
+de(f3(), [])
+de(f3(1, 2), [1, 2])
+
+def f4(**kwargs):
+    return kwargs
+
+de(f4(), {})
+de(f4(a=1, b=2), {'a':1, 'b':2})
+
+def f5(*args, **kwargs):
+    return [args, kwargs]
+
+de(f5(), [[], {}])
+de(f5(1, 2, a=1, b=2), [[1,2], {'a':1, 'b':2}])
+
+def f6(a, *args):
+    return [a, args]
+
+de(f6(), [undefined, []])
+de(f6(1), [1, []])
+de(f6(1, 2, 3), [1, [2, 3]])
+
+def f7(a=1, **kw):
+    return [a, kw]
+
+de(f7(), [1, {}])
+de(f7(a=3, b=4), [3, {'b':4}])
+
+def f8(a, b=2, *args, **kwargs):
+    return [a, b, args, kwargs]
+
+de(f8(), [undefined, 2, [], {}])
+de(f8(1), [1, 2, [], {}])
+de(f8(1, 3, 4, 5, b=8, c=9), [1, 8, [4, 5], {'c':9}])
+
+def f9(*args, **kwargs):
+    return [args, kwargs]
+
+de(f9(), [[], {}])
+de(f9(1, 2, a=1, b=2), [[1,2], {'a':1, 'b':2}])
+
+def f10(a, b=2, c=3):
+    return [a, b, c]
+
+de(f10(1, c=6), [1, 2, 6])
+
+def f11(a, b, x=1):
+    return [a, b, x]
+
+de(f11(x=3), [undefined, undefined, 3])
+# }}}
+
+acc = []
+def mutable_defaults(a=acc):
+    a.append(1)
+
+mutable_defaults(), mutable_defaults()
+de([1, 1], acc)
+
+def identity(f):
+    return def():
+        return f()
+
+@identity
+def wrapped(x=1):
+    return x
+
+eq(wrapped(), 1)
+
+class W:
+    @identity
+    def wrapped(self, x=1):
+        return x
+eq(W().wrapped(), 1)
+eq(1, (def(x=1): return x;)())
+
+class Simple:
+
+    def __init__(self, a, b):
+        self.q = [a, b]
+de(Simple(b=2, a=1).q, [1, 2])
+
+class Other:
+    def func(self, **kw):
+        if self:
+            return kw
+
+class Test:
+
+    def __init__(self, a, b=2, *args, **kwargs):
+        self.q = [a, b, args, kwargs]
+        self.other = Other()
+
+    def forwarded(self, **kw):
+        return self.other.func(**kw)
+
+    def simple(self, a, b):
+        return [a, b]
+
+de(Test().q, [undefined, 2, [], {}])
+de(Test(a=1).q, [1, 2, [], {}])
+de(Test(1, 3, 4, 5, b=8, c=9).q, [1, 8, [4, 5], {'c':9}])
+args = [1, 2]
+de(Test(*args).q, [1, 2, [], {}])
+t = Test()
+de(t.simple(b=2, a=1), [1, 2])
+
+@options_object
+def callback(a, b=1, c=2):
+    return [a, b, c]
+
+de(callback(0, {'c':4}), [0, 1, 4])
+
+def afunc(a=1):
+    return a
+
+def a2func(*args):
+    return args[0]
+
+eq(afunc(None), None)
+eq(a2func(None), None)
+de(Test().forwarded(a=1), {'a':1})
+
+def norm(a, b):
+    return [a, b]
+
+de(norm(b=2, a=1), [1, 2])
+
+call_counter = 0
+
+def cc():
+    nonlocal call_counter
+    call_counter += 1
+    return def():
+        pass
+
+cc()(a=1)
+eq(call_counter, 1)
+cc(o=1)(a=1)
+eq(call_counter, 2)
+call_counter = 0
+
+def cc2():
+    nonlocal call_counter
+    call_counter += 1
+    return {'val':3, 'x':def():return this.val;}
+eq(3, cc2().x(a=1))
+eq(call_counter, 1)
+call_counter = 0
+
+def cc3():
+    nonlocal call_counter
+    call_counter += 1
+    this.num = call_counter
+    this.c = def():
+        return call_counter
+eq(new cc3(a=1).num, 1)
+eq(new cc3(a=1).c(b=9), 2)
+
+class Pr:
+    def __init__(self, a=1):
+        self.a = a
+
+    def add(self, val=0):
+        self.a += val
+
+class Pr2(Pr):
+
+    def __init__(self):
+        Pr.__init__(self, a=2)
+
+    def add(self):
+        Pr.add(self, val=1)
+
+p = Pr(a=2)
+p.add(val=3)
+eq(p.a, 5)
+p = Pr2()
+p.add()
+eq(p.a, 3)
+p1, p2 = Pr(), Pr(a=1)
+eq(p1.prototype, p2.prototype)
+de(dir(p1), dir(p2))
+
+class Prn:
+
+    def __init__(self, x):
+        self.x = x
+
+class Prn1(Prn):
+
+    def __init__(self, x, *a):
+        Prn.__init__(self, [x, a])
+
+class Prn2(Prn):
+
+    def __init__(self, *a):
+        Prn.__init__(self, a)
+
+
+class Prn3(Prn):
+
+    def __init__(self, *a):
+        Prn.__init__(self, *a)
+
+p = Prn1(1, 2, 3)
+eq(p.x[0], 1)
+de(p.x[1], [2, 3])
+p = Prn2(1, 2)
+de(p.x, [1, 2])
+p = Prn3(1, 2)
+eq(p.x, 1)
+
+
+class Prnb:
+
+    def __init__(self, a, k):
+        self.a, self.k = a, k
+
+class Prnb1(Prnb):
+
+    def __init__(self, *a, **kw):
+        Prnb.__init__(self, a, kw)
+
+p = Prnb1(1, 2, x=1, y=2)
+de(p.a, [1, 2])
+de(p.k, {'x': 1, 'y':2})
+
+# Test positional-only (/) and keyword-only (*) parameter separators {{{
+
+# --- Parse tests ---
+
+def parse_posonly_test(code, arglen, posonly_count, bare_star):
+    func = RapydScript.parse('def func(' + code + '): pass\n', {'filename':code}).body[0]
+    eq(func.argnames.length, arglen, 'arglen for: ' + code)
+    eq(func.argnames.posonly_count or 0, posonly_count, 'posonly_count for: ' + code)
+    eq(bool(func.argnames.bare_star), bool(bare_star), 'bare_star for: ' + code)
+    eq(func.argnames.is_simple_func, False, 'is_simple_func should be False for: ' + code)
+    return func
+
+# Positional-only: all params before /
+f = parse_posonly_test('a, b, /', 2, 2, False)
+eq(f.argnames[0].posonly, True)
+eq(f.argnames[1].posonly, True)
+
+# Positional-only: only first param is posonly
+f = parse_posonly_test('a, /, b', 2, 1, False)
+eq(f.argnames[0].posonly, True)
+eq(bool(f.argnames[1].posonly), False)
+
+# Keyword-only: bare * separator
+f = parse_posonly_test('a, *, b', 2, 0, True)
+eq(bool(f.argnames[0].kwonly), False)
+eq(f.argnames[1].kwonly, True)
+
+# Combined: positional-only and keyword-only
+f = parse_posonly_test('a, /, *, b', 2, 1, True)
+eq(f.argnames[0].posonly, True)
+eq(f.argnames[1].kwonly, True)
+
+# Posonly + regular + kwonly
+f = parse_posonly_test('a, b, /, c, *, d, e', 5, 2, True)
+eq(f.argnames[0].posonly, True)
+eq(f.argnames[1].posonly, True)
+eq(bool(f.argnames[2].posonly), False)
+eq(bool(f.argnames[2].kwonly), False)
+eq(f.argnames[3].kwonly, True)
+eq(f.argnames[4].kwonly, True)
+
+# Defaults in posonly and kwonly sections
+f = parse_posonly_test('a=1, /, *, b=2', 2, 1, True)
+eq(f.argnames.defaults.a.value, 1)
+eq(f.argnames.defaults.b.value, 2)
+
+# Posonly with *args and **kwargs
+parse_posonly_test('a, /, *args', 1, 1, False)
+parse_posonly_test('a, /, **kw', 1, 1, False)
+parse_posonly_test('a, /, *args, **kw', 1, 1, False)
+
+# Keyword-only with **kwargs
+parse_posonly_test('a, *, b, **kw', 2, 0, True)
+
+# Error: / before any argument
+throw_test('/')
+throw_test('/, a')
+
+# Error: / after *
+throw_test('*args, /')
+throw_test('*, a, /')
+
+# Error: / after **kwargs
+throw_test('**kw, /')
+
+# Error: duplicate /
+throw_test('a, /, b, /')
+
+# Error: bare * without following keyword-only param
+throw_test('a, *')
+throw_test('*')
+
+# Error: required kwonly after optional kwonly
+throw_test('*, a=1, b')
+
+# --- Runtime tests ---
+
+# Positional-only: basic
+def po1(a, b, /):
+    return [a, b]
+
+de(po1(1, 2), [1, 2])
+de(po1(10, 20), [10, 20])
+
+# Positional-only with default
+def po2(a, b=99, /):
+    return [a, b]
+
+de(po2(1), [1, 99])
+de(po2(1, 2), [1, 2])
+
+# Positional-only + regular
+def po3(a, /, b):
+    return [a, b]
+
+de(po3(1, 2), [1, 2])
+de(po3(1, b=2), [1, 2])
+
+# Positional-only + regular with default
+def po4(a, /, b=5):
+    return [a, b]
+
+de(po4(1), [1, 5])
+de(po4(1, 10), [1, 10])
+de(po4(1, b=10), [1, 10])
+
+# Keyword-only: basic
+def ko1(a, *, b):
+    return [a, b]
+
+de(ko1(1, b=2), [1, 2])
+de(ko1(b=2, a=1), [1, 2])
+
+# Keyword-only with default
+def ko2(a, *, b=7):
+    return [a, b]
+
+de(ko2(1), [1, 7])
+de(ko2(1, b=3), [1, 3])
+de(ko2(a=1, b=3), [1, 3])
+
+# Multiple keyword-only params
+def ko3(*, x, y, z=0):
+    return [x, y, z]
+
+de(ko3(x=1, y=2), [1, 2, 0])
+de(ko3(x=1, y=2, z=3), [1, 2, 3])
+
+# Combined posonly + kwonly
+def poko1(a, b, /, *, c, d=4):
+    return [a, b, c, d]
+
+de(poko1(1, 2, c=3), [1, 2, 3, 4])
+de(poko1(1, 2, c=3, d=5), [1, 2, 3, 5])
+
+# Combined posonly + regular + kwonly
+def poko2(a, /, b, *, c):
+    return [a, b, c]
+
+de(poko2(1, 2, c=3), [1, 2, 3])
+de(poko2(1, b=2, c=3), [1, 2, 3])
+
+# Posonly with *args
+def po_star(a, /, *args):
+    return [a, args]
+
+de(po_star(1, 2, 3), [1, [2, 3]])
+
+# Kwonly with **kwargs
+def ko_kw(a, *, b, **rest):
+    return [a, b, rest]
+
+de(ko_kw(1, b=2, c=3), [1, 2, {'c':3}])
+
+# Class method with posonly and kwonly
+class PoKoClass:
+    def method(self, a, /, *, b):
+        return [a, b]
+
+obj = PoKoClass()
+de(obj.method(10, b=20), [10, 20])
+
+# }}}

package/test/starred_assign.pyj

@@ -0,0 +1,104 @@
+# vim:fileencoding=utf-8
+# globals: assrt
+
+eq = assrt.equal
+de = assrt.deepEqual
+ok = assrt.ok
+
+# ----[ Transpilation tests (parse + codegen) ]----
+
+def compile_test(code):
+    # Returns the JS output as a string (main code section only)
+    ast = RapydScript.parse(code + '\n', {'filename': code})
+    opts = RapydScript.OutputStream({'beautify': True, 'js_version': 7})
+    ast.print(opts)
+    return opts.get()
+
+def throw_parse_test(code):
+    assrt.throws(def():
+        RapydScript.parse(code + '\n', {'filename': code})
+    , RapydScript.SyntaxError)
+
+# ----[ Basic runtime correctness tests ]----
+
+# a, *b, c = list — middle starred
+a, *b, c = [1, 2, 3, 4, 5]
+eq(a, 1)
+de(b, [2, 3, 4])
+eq(c, 5)
+
+# *a, b = list — starred at front
+*a, b = [1, 2, 3]
+de(a, [1, 2])
+eq(b, 3)
+
+# x, *y = list — starred at end
+x, *y = [1, 2, 3, 4]
+eq(x, 1)
+de(y, [2, 3, 4])
+
+# first, *rest, last — first and last are scalars
+first, *rest, last = [10, 20, 30, 40, 50]
+eq(first, 10)
+de(rest, [20, 30, 40])
+eq(last, 50)
+
+# Minimal: only two elements on rhs, starred in front
+*p, q = [7, 8]
+de(p, [7])
+eq(q, 8)
+
+# Minimal: only two elements on rhs, starred at end
+m, *n = [7, 8]
+eq(m, 7)
+de(n, [8])
+
+# Starred gets empty list when nothing to absorb
+a2, *b2, c2 = [1, 2]
+eq(a2, 1)
+de(b2, [])
+eq(c2, 2)
+
+# Works with tuple packing on rhs
+i, *j, k = 1, 2, 3, 4
+eq(i, 1)
+de(j, [2, 3])
+eq(k, 4)
+
+# Works with string (iterable)
+head, *tail = "hello"
+eq(head, "h")
+de(tail, ["e", "l", "l", "o"])
+
+# Works with generator
+def make_gen():
+    yield 10
+    yield 20
+    yield 30
+    yield 40
+
+g1, *g2, g3 = make_gen()
+eq(g1, 10)
+de(g2, [20, 30])
+eq(g3, 40)
+
+# Starred result is a list (not raw js array)
+*s1, s2 = [1, 2, 3]
+ok(Array.isArray(s1))
+eq(s1.length, 2)
+
+# ----[ Language service parse tests ]----
+
+# Parsing: starred assignment produces an AST_SimpleStatement containing AST_Assign
+parsed = RapydScript.parse('a, *b, c = [1,2,3]\n', {'filename': 'test'}).body[0]
+ok(v'parsed instanceof RapydScript.AST_SimpleStatement')
+ok(v'parsed.body instanceof RapydScript.AST_Assign')
+ok(v'parsed.body.left instanceof RapydScript.AST_Array')
+
+# ----[ Error detection ]----
+
+# Multiple starred expressions should throw
+throw_parse_test('*a, *b = [1, 2]')
+
+# Starred in augmented assignment should throw
+throw_parse_test('a, *b += [1, 2]')