rapydscript-ns 0.8.4 → 0.9.0

package/test/typing.pyj

@@ -0,0 +1,469 @@
+# globals: assrt
+# Tests for the typing standard library module.
+# Verifies that typing constructs transpile correctly to JavaScript and
+# that the resulting runtime objects carry the expected attributes.
+
+from typing import (
+    TYPE_CHECKING, Any, Union, Optional, ClassVar, Final, Literal, NoReturn,
+    List, Dict, Set, FrozenSet, Tuple, Type, Callable,
+    Iterator, Iterable, Generator, Sequence, MutableSequence,
+    Mapping, MutableMapping, AsyncGenerator, AsyncIterator, AsyncIterable,
+    Awaitable, Coroutine, IO, TextIO, BinaryIO, Pattern, Match,
+    TypeVar, Generic, Protocol,
+    cast, overload, no_type_check, no_type_check_decorator,
+    runtime_checkable, get_type_hints,
+    TypedDict, NamedTuple, AnyStr, ByteString, Text
+)
+
+
+# ── TYPE_CHECKING constant ─────────────────────────────────────────────────────
+
+assrt.equal(TYPE_CHECKING, False)
+
+
+# ── Generic aliases: __origin__ and __args__ ──────────────────────────────────
+
+def _test_list_alias():
+    alias = List[int]
+    assrt.ok(alias is not None)
+    assrt.equal(alias.__origin__, list)
+    assrt.equal(alias.__args__[0], int)
+    assrt.equal(alias._name, 'List')
+_test_list_alias()
+
+
+def _test_dict_alias():
+    alias = Dict[str, int]
+    assrt.equal(alias.__origin__, dict)
+    assrt.equal(alias.__args__[0], str)
+    assrt.equal(alias.__args__[1], int)
+    assrt.equal(alias._name, 'Dict')
+_test_dict_alias()
+
+
+def _test_set_alias():
+    alias = Set[str]
+    assrt.equal(alias.__origin__, set)
+    assrt.equal(alias.__args__[0], str)
+_test_set_alias()
+
+
+def _test_frozenset_alias():
+    alias = FrozenSet[int]
+    assrt.equal(alias.__origin__, frozenset)
+    assrt.equal(alias.__args__[0], int)
+_test_frozenset_alias()
+
+
+def _test_tuple_alias():
+    # Homogeneous variable-length tuple: Tuple[int, ...]
+    alias = Tuple[int, ...]
+    assrt.equal(alias.__origin__, tuple)
+    assrt.equal(alias.__args__[0], int)
+    assrt.equal(alias._name, 'Tuple')
+_test_tuple_alias()
+
+
+def _test_type_alias():
+    alias = Type[int]
+    assrt.equal(alias.__origin__, type)
+    assrt.equal(alias.__args__[0], int)
+_test_type_alias()
+
+
+def _test_callable_alias():
+    alias = Callable[[int, str], bool]
+    assrt.equal(alias._name, 'Callable')
+    assrt.ok(alias.__args__ is not None)
+_test_callable_alias()
+
+
+# ── Abstract aliases ───────────────────────────────────────────────────────────
+
+def _test_abstract_aliases():
+    assrt.equal(Iterator[int]._name, 'Iterator')
+    assrt.equal(Iterable[str]._name, 'Iterable')
+    assrt.equal(Generator[int, None, None]._name, 'Generator')
+    assrt.equal(Sequence[float]._name, 'Sequence')
+    assrt.equal(MutableSequence[float]._name, 'MutableSequence')
+    assrt.equal(Mapping[str, int]._name, 'Mapping')
+    assrt.equal(MutableMapping[str, int]._name, 'MutableMapping')
+    assrt.equal(Awaitable[int]._name, 'Awaitable')
+    assrt.equal(Coroutine[int, None, None]._name, 'Coroutine')
+    assrt.equal(AsyncGenerator[int, None]._name, 'AsyncGenerator')
+    assrt.equal(AsyncIterator[int]._name, 'AsyncIterator')
+    assrt.equal(AsyncIterable[int]._name, 'AsyncIterable')
+_test_abstract_aliases()
+
+
+# ── IO and pattern aliases ─────────────────────────────────────────────────────
+
+def _test_io_aliases():
+    assrt.equal(IO[str]._name, 'IO')
+    assrt.ok(TextIO is not None)
+    assrt.ok(BinaryIO is not None)
+    assrt.equal(Pattern[str]._name, 'Pattern')
+    assrt.equal(Match[str]._name, 'Match')
+_test_io_aliases()
+
+
+# ── Special forms ──────────────────────────────────────────────────────────────
+
+def _test_optional():
+    alias = Optional[str]
+    assrt.equal(alias._name, 'Optional')
+    assrt.equal(alias.__args__[0], str)
+    assrt.equal(alias.__args__[1], None)
+_test_optional()
+
+
+def _test_union():
+    alias = Union[str, int]
+    assrt.equal(alias._name, 'Union')
+    assrt.equal(alias.__args__.length, 2)
+    assrt.equal(alias.__args__[0], str)
+    assrt.equal(alias.__args__[1], int)
+_test_union()
+
+
+def _test_classvar():
+    alias = ClassVar[str]
+    assrt.equal(alias._name, 'ClassVar')
+    assrt.equal(alias.__args__[0], str)
+_test_classvar()
+
+
+def _test_final():
+    alias = Final[int]
+    assrt.equal(alias._name, 'Final')
+    assrt.equal(alias.__args__[0], int)
+_test_final()
+
+
+def _test_literal():
+    alias = Literal['r', 'w', 'a']
+    assrt.equal(alias._name, 'Literal')
+    assrt.equal(alias.__args__.length, 3)
+    assrt.equal(alias.__args__[0], 'r')
+    assrt.equal(alias.__args__[1], 'w')
+    assrt.equal(alias.__args__[2], 'a')
+_test_literal()
+
+
+def _test_any():
+    assrt.ok(Any is not None)
+    assrt.ok(repr(Any).indexOf('Any') >= 0)
+_test_any()
+
+
+def _test_noreturn():
+    assrt.ok(NoReturn is not None)
+_test_noreturn()
+
+
+# ── TypeVar ────────────────────────────────────────────────────────────────────
+
+def _test_typevar():
+    T = TypeVar('T')
+    assrt.equal(T.__name__, 'T')
+    assrt.ok(repr(T).indexOf('T') >= 0)
+
+    S = TypeVar('S', str, int)
+    assrt.equal(S.__name__, 'S')
+    assrt.equal(S.__constraints__.length, 2)
+    assrt.equal(S.__constraints__[0], str)
+    assrt.equal(S.__constraints__[1], int)
+
+    assrt.equal(AnyStr.__name__, 'AnyStr')
+    # AnyStr is constrained to both str and bytes now that bytes is supported
+    assrt.equal(AnyStr.__constraints__.length, 2)
+    assrt.equal(AnyStr.__constraints__[0], str)
+    assrt.equal(AnyStr.__constraints__[1], bytes)
+_test_typevar()
+
+
+# ── Generic base class ─────────────────────────────────────────────────────────
+
+def _test_generic():
+    T = TypeVar('T')
+
+    class Stack(Generic[T]):
+        def __init__(self):
+            self._items = []
+        def push(self, item):
+            self._items.append(item)
+        def pop(self):
+            return self._items.pop()
+        def empty(self):
+            return len(self._items) == 0
+
+    s = Stack()
+    s.push(1)
+    s.push(2)
+    assrt.equal(s.pop(), 2)
+    assrt.equal(s.pop(), 1)
+    assrt.ok(s.empty())
+
+    # __class_getitem__ on Generic subclass
+    alias = Stack[int]
+    assrt.ok(alias is not None)
+_test_generic()
+
+
+# ── Protocol base class ────────────────────────────────────────────────────────
+
+def _test_protocol():
+    @runtime_checkable
+    class Drawable(Protocol):
+        def draw(self):
+            pass
+
+    class Circle:
+        def draw(self):
+            return 'circle'
+
+    c = Circle()
+    assrt.equal(c.draw(), 'circle')
+    assrt.ok(Drawable is not None)
+_test_protocol()
+
+
+# ── cast ───────────────────────────────────────────────────────────────────────
+
+def _test_cast():
+    result = cast(int, 'hello')
+    assrt.equal(result, 'hello')
+    assrt.deepEqual(cast(List[int], [1, 2, 3]), [1, 2, 3])
+    assrt.equal(cast(str, 42), 42)
+_test_cast()
+
+
+# ── overload decorator ─────────────────────────────────────────────────────────
+
+def _test_overload():
+    @overload
+    def process(x):
+        return x * 2
+
+    assrt.equal(process(5), 10)
+_test_overload()
+
+
+# ── no_type_check decorator ────────────────────────────────────────────────────
+
+def _test_no_type_check():
+    @no_type_check
+    def f(x):
+        return x + 1
+
+    assrt.equal(f(3), 4)
+_test_no_type_check()
+
+
+# ── get_type_hints ─────────────────────────────────────────────────────────────
+
+def _test_get_type_hints():
+    def annotated(x: int, y: str) -> bool:
+        pass
+
+    hints = get_type_hints(annotated)
+    assrt.equal(hints['x'], int)
+    assrt.equal(hints['y'], str)
+    assrt.equal(hints['return'], bool)
+
+    def no_hints():
+        pass
+
+    assrt.deepEqual(get_type_hints(no_hints), {})
+_test_get_type_hints()
+
+
+# ── Function annotations with typing types ─────────────────────────────────────
+
+def _test_annotations_with_typing():
+    def process(items: List[int], label: Optional[str]) -> Dict[str, int]:
+        pass
+
+    annot = process.__annotations__
+    assrt.ok(annot is not None)
+    assrt.equal(annot['items'].__origin__, list)
+    assrt.equal(annot['items'].__args__[0], int)
+    assrt.equal(annot['label']._name, 'Optional')
+    assrt.equal(annot['return'].__origin__, dict)
+_test_annotations_with_typing()
+
+
+# ── TypedDict ──────────────────────────────────────────────────────────────────
+
+def _test_typeddict():
+    class Movie(TypedDict):
+        pass
+
+    # TypedDict subclass is a valid class that can be instantiated
+    m = Movie()
+    assrt.ok(m is not None)
+    # TypedDict itself is importable
+    assrt.ok(TypedDict is not None)
+_test_typeddict()
+
+
+# ── NamedTuple (functional form) ───────────────────────────────────────────────
+
+def _test_namedtuple():
+    from __python__ import overload_getitem
+    Point = NamedTuple('Point', [('x', float), ('y', float)])
+
+    p = Point(3.0, 4.0)
+    assrt.equal(p.x, 3.0)
+    assrt.equal(p.y, 4.0)
+
+    # Annotations carry type information
+    assrt.equal(Point.__annotations__['x'], float)
+    assrt.equal(Point.__annotations__['y'], float)
+
+    # Integer indexing
+    assrt.equal(p[0], 3.0)
+    assrt.equal(p[1], 4.0)
+
+    # Negative indexing
+    assrt.equal(p[-1], 4.0)
+_test_namedtuple()
+
+
+# ── ByteString ─────────────────────────────────────────────────────────────────
+
+def _test_bytestring():
+    from __python__ import overload_operators
+    # ByteString is importable and is a class
+    assrt.ok(ByteString is not None)
+
+    # Use ByteString as a type annotation — it is a no-op at runtime
+    def consume(data: ByteString) -> int:
+        return len(data)
+
+    assrt.equal(consume(bytes([1, 2, 3])), 3)
+    assrt.equal(consume(bytearray([10, 20])), 2)
+
+    # Optional[ByteString] works via _GenericAlias
+    from typing import Optional
+    alias = Optional[ByteString]
+    assrt.equal(alias._name, 'Optional')
+    assrt.equal(alias.__args__[0], ByteString)
+
+    # Union[bytes, bytearray] round-trip
+    from typing import Union
+    u = Union[bytes, bytearray]
+    assrt.equal(u._name, 'Union')
+    assrt.equal(u.__args__[0], bytes)
+    assrt.equal(u.__args__[1], bytearray)
+_test_bytestring()
+
+
+# ── bytes / bytearray in generic aliases ───────────────────────────────────────
+
+def _test_bytes_in_generic_aliases():
+    from __python__ import overload_operators
+    # List[bytes]
+    alias = List[bytes]
+    assrt.equal(alias.__origin__, list)
+    assrt.equal(alias.__args__[0], bytes)
+
+    # Dict[str, bytes]
+    alias = Dict[str, bytes]
+    assrt.equal(alias.__args__[0], str)
+    assrt.equal(alias.__args__[1], bytes)
+
+    # Optional[bytes]
+    from typing import Optional
+    alias = Optional[bytes]
+    assrt.equal(alias._name, 'Optional')
+    assrt.equal(alias.__args__[0], bytes)
+
+    # IO[bytes] — used to annotate binary-mode streams
+    alias = IO[bytes]
+    assrt.equal(alias._name, 'IO')
+    assrt.equal(alias.__args__[0], bytes)
+_test_bytes_in_generic_aliases()
+
+
+# ── Text alias ─────────────────────────────────────────────────────────────────
+
+def _test_text_alias():
+    assrt.equal(Text, str)
+_test_text_alias()
+
+
+# ── repr smoke test ────────────────────────────────────────────────────────────
+
+def _test_repr():
+    assrt.ok(repr(List[int]).indexOf('List') >= 0)
+    assrt.ok(repr(Dict[str, int]).indexOf('Dict') >= 0)
+    assrt.ok(repr(Optional[str]).indexOf('Optional') >= 0)
+    assrt.ok(repr(Union[str, int]).indexOf('Union') >= 0)
+_test_repr()
+
+
+# ── Annotated assignment with attribute target (self.x: Type = value) ──────────
+# Regression: these were previously mis-parsed, causing "invalid left-hand side"
+# in the generated JS output.
+
+def _test_attr_annotated_assign():
+    T = TypeVar('T')
+
+    class Stack(Generic[T]):
+        def __init__(self):
+            self._items: List[T] = []
+
+        def push(self, item: T) -> None:
+            self._items.append(item)
+
+        def pop(self) -> Optional[T]:
+            return self._items.pop() if self._items else None
+
+    s = Stack()
+    s.push(10)
+    s.push(20)
+    assrt.equal(s.pop(), 20)
+    assrt.equal(s.pop(), 10)
+    # _items list was assigned correctly (not left as undefined)
+    assrt.equal(s._items.length, 0)
+_test_attr_annotated_assign()
+
+
+def _test_attr_annotated_assign_no_value():
+    # Annotation-only on an attribute (no rhs) should compile without error
+    # and emit nothing (attribute remains unset).
+    class Container:
+        def __init__(self):
+            self.x: int  # annotation only — no assignment
+            self.y: str = 'hello'
+
+    c = Container()
+    assrt.equal(c.x, undefined)
+    assrt.equal(c.y, 'hello')
+_test_attr_annotated_assign_no_value()
+
+
+def _test_local_annotated_assign_complex_type():
+    # Local variable with a parameterised type annotation — the type is erased,
+    # only the assignment runs.
+    def make_pair() -> List[int]:
+        pair: List[int] = [1, 2]
+        return pair
+
+    result = make_pair()
+    assrt.equal(result.length, 2)
+    assrt.equal(result[0], 1)
+    assrt.equal(result[1], 2)
+_test_local_annotated_assign_complex_type()
+
+
+def _test_module_level_attr_annotated_assign():
+    # Annotated assignment on a plain object attribute at module level.
+    class Box:
+        pass
+
+    b = Box()
+    b.value: int = 42
+    assrt.equal(b.value, 42)
+_test_module_level_attr_annotated_assign()

package/test/unit/index.js

@@ -98,6 +98,16 @@ function compile_with_flags(src, flags_obj) {
     return output.toString();
 }
 
+// compile_python_mode simulates the default (legacy_rapydscript=false) behavior:
+// all Python compatibility flags are enabled globally.
+var PYTHON_MODE_FLAGS = ['dict_literals', 'overload_getitem', 'bound_methods',
+                         'hash_literals', 'overload_operators', 'truthiness', 'jsx'];
+function compile_python_mode(src) {
+    var flags = {};
+    PYTHON_MODE_FLAGS.forEach(function(f) { flags[f] = true; });
+    return compile_with_flags(src, flags);
+}
+
 function compile_virtual(src, virtual_files) {
     compiler_module.set_virtual_files(virtual_files);
     try {
@@ -805,8 +815,8 @@ var TESTS = [
             'result = v"typeof undefined"',
             'assrt.equal(result, "undefined")',
             "arr = [1, 2, 3]",
-            'len = v"arr.length"',
-            "assrt.equal(len, 3)",
+            'leng = v"arr.length"',
+            "assrt.equal(leng, 3)",
             'assrt.equal(v"Math.max(4, 7)", 7)',
         ].join("\n"),
         js_checks: ["typeof undefined", "arr.length", "Math.max(4, 7)"],
@@ -3188,10 +3198,11 @@ assrt.equal(fib(15), 610)
             var js_with = ec_with.compile(src, { python_flags: "truthiness" });
             assert.ok(/if\s*\(ρσ_bool\(/.test(js_with),
                 "python_flags='truthiness': expected if(ρσ_bool( in: " + js_with);
-            var ec_without = make_ec(RapydScript, baselib, null);
-            var js_without = ec_without.compile(src, {});
-            assert.ok(!/if\s*\(ρσ_bool\(/.test(js_without),
-                "no python_flags: if(ρσ_bool( should NOT appear in: " + js_without);
+            // Use legacy_rapydscript: true to get legacy mode (no python flags by default)
+            var ec_legacy = make_ec(RapydScript, baselib, null);
+            var js_legacy = ec_legacy.compile(src, { legacy_rapydscript: true });
+            assert.ok(!/if\s*\(ρσ_bool\(/.test(js_legacy),
+                "legacy mode: if(ρσ_bool( should NOT appear in: " + js_legacy);
         },
     },
 
@@ -4807,7 +4818,7 @@ assrt.equal(fib(15), 610)
             "assrt.equal(coords[0], 10)",
             "assrt.equal(coords[1], 20)",
         ].join("\n"),
-        js_checks: ["coords = [10, 20]"],
+        js_checks: [/coords\s*=\s*ρσ_list_decorate\(\s*\[\s*10,\s*20\s*\]/],
     },
 
     {
@@ -5118,6 +5129,104 @@ assrt.equal(fib(15), 610)
         js_checks: [],
     },
 
+    // ── legacy_rapydscript default ────────────────────────────────────────
+
+    {
+        name: "legacy_rapydscript_false_enables_overload_operators",
+        description: "default (legacy_rapydscript=false): overload_operators active; a+b uses ρσ_op_add",
+        run: function() {
+            // Use unique variable names so the pattern is only from user code, not baselib
+            var js = compile_python_mode("myval = myarg_a + myarg_b");
+            assert.ok(js.indexOf("ρσ_op_add(myarg_a, myarg_b)") !== -1,
+                "expected ρσ_op_add(myarg_a, myarg_b) in python mode; got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_true_no_overload_operators",
+        description: "legacy mode (no flags): a+b uses ρσ_list_add, not ρσ_op_add",
+        run: function() {
+            // compile() uses no scoped_flags → no overload_operators
+            var js = compile("myval = myarg_a + myarg_b");
+            assert.ok(js.indexOf("ρσ_op_add(myarg_a") === -1,
+                "unexpected ρσ_op_add(myarg_a in legacy mode; got:\n" + js);
+            assert.ok(js.indexOf("ρσ_list_add(myarg_a") !== -1,
+                "expected ρσ_list_add(myarg_a in legacy mode; got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_false_enables_dict_literals",
+        description: "default (legacy_rapydscript=false): dict_literals active; {} compiles to ρσ_dict()",
+        run: function() {
+            var js = compile_python_mode("mydict = {}");
+            assert.ok(js.indexOf("dict_literal") !== -1 || js.indexOf("ρσ_dict") !== -1,
+                "expected dict() wrapper with dict_literals enabled (python mode); got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_true_no_dict_literals",
+        description: "legacy mode (no flags): {} compiles to a plain JS object literal",
+        run: function() {
+            var js = compile("mydict = {}");
+            // The assignment line should not contain dict_literal or ρσ_dict
+            var lines = js.split("\n").filter(function(l) { return l.indexOf("mydict") !== -1; });
+            var userline = lines.join("\n");
+            assert.ok(userline.indexOf("dict_literal") === -1 && userline.indexOf("ρσ_dict") === -1,
+                "unexpected dict() wrapper in legacy mode; got:\n" + userline);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_false_enables_truthiness",
+        description: "default (legacy_rapydscript=false): truthiness active; if-condition wrapped in ρσ_bool()",
+        run: function() {
+            var js = compile_python_mode("if mycond:\n    pass");
+            assert.ok(/if\s*\(ρσ_bool\(mycond/.test(js),
+                "expected if(ρσ_bool(mycond in python mode; got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_true_no_truthiness",
+        description: "legacy mode (no flags): if-condition is not wrapped in ρσ_bool()",
+        run: function() {
+            var js = compile("if mycond:\n    pass");
+            assert.ok(!/if\s*\(ρσ_bool\(mycond/.test(js),
+                "unexpected ρσ_bool(mycond wrapping in legacy mode; got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_false_enables_bound_methods",
+        description: "default (legacy_rapydscript=false): bound_methods active; methods are .bind()-ed",
+        run: function() {
+            var js = compile_python_mode([
+                "class MyFoo:",
+                "    def mybar(self):",
+                "        return 1",
+            ].join("\n"));
+            // Bound methods produce a .bind(this) call in the class prototype setup
+            assert.ok(/mybar.*bind/.test(js) || /bind.*mybar/.test(js),
+                "expected .bind() for mybar with bound_methods enabled (python mode); got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_true_no_bound_methods",
+        description: "legacy mode (no flags): methods are not .bind()-ed",
+        run: function() {
+            var js = compile([
+                "class MyFoo:",
+                "    def mybar(self):",
+                "        return 1",
+            ].join("\n"));
+            assert.ok(!/mybar.*bind/.test(js) && !/bind.*mybar/.test(js),
+                "unexpected .bind() for mybar in legacy mode; got:\n" + js);
+        },
+    },
+
 ];
 
 // ── Runner ───────────────────────────────────────────────────────────────────