rapydscript-ng 0.7.18 → 0.7.22

package/src/output/modules.pyj

@@ -3,11 +3,14 @@
 # globals: writefile
 from __python__ import hash_literals
 
-from parse import COMPILER_VERSION
-from utils import cache_file_name
 from output.statements import declare_vars, display_body
 from output.stream import OutputStream
 from output.utils import create_doctring
+from output.comments import print_comments, output_comments
+from output.functions import set_module_name
+from parse import get_compiler_version
+from utils import cache_file_name
+
 
 def write_imports(module, output):
     imports = []
@@ -116,7 +119,8 @@ def prologue(module, output):
 
 
 def print_top_level(self, output):
-    is_main = output.is_main()
+    set_module_name(self.module_id)
+    is_main = self.module_id is '__main__'
 
     def write_docstrings():
         if is_main and output.options.keep_docstrings and self.docstrings and self.docstrings.length:
@@ -148,6 +152,10 @@ def print_top_level(self, output):
                         display_body(self.body, True, output)
                         output.newline()
                         write_docstrings()
+                        if self.comments_after and self.comments_after.length:
+                            output.indent()
+                            output_comments(self.comments_after, output)
+                            output.newline()
                     )
                 )
                 output.print("();")
@@ -164,8 +172,12 @@ def print_top_level(self, output):
 
         declare_vars(self.localvars, output)
         display_body(self.body, True, output)
+        if self.comments_after and self.comments_after.length:
+            output_comments(self.comments_after, output)
+    set_module_name()
 
 def print_module(self, output):
+    set_module_name(self.module_id)
 
     def output_module(output):
         declare_vars(self.localvars, output)
@@ -178,6 +190,7 @@ def print_module(self, output):
         output.print("function()")
         output.with_block(def():
             # dump the logic of this module
+            print_comments(self, output)
             if output.options.write_name:
                 output.indent()
                 output.print('var ')
@@ -194,9 +207,9 @@ def print_module(self, output):
                 output_module(output)
                 if self.srchash and self.filename:
                     cached = {
-                        'version':COMPILER_VERSION, 'signature':self.srchash, 'classes': {}, 'baselib':self.baselib,
+                        'version':get_compiler_version(), 'signature':self.srchash, 'classes': {}, 'baselib':self.baselib,
                         'nonlocalvars':self.nonlocalvars, 'imported_module_ids':self.imported_module_ids, 'exports':[],
-                        'outputs':{}, 'discard_asserts': output.options.discard_asserts
+                        'outputs':{}, 'discard_asserts': v'!!output.options.discard_asserts'
                     }
                     for cname in Object.keys(self.classes):
                         cobj = self.classes[cname]
@@ -225,6 +238,7 @@ def print_module(self, output):
     output.print("()")
     output.semicolon()
     output.newline()
+    set_module_name()
 
 def print_imports(container, output):
     is_first_aname = True
@@ -246,7 +260,6 @@ def print_imports(container, output):
         output.end_statement()
 
     for self in container.imports:
-        output.import_(self.module)
         if self.argnames:
             # A from import
             for argname in self.argnames:

package/src/output/operators.pyj

@@ -1,14 +1,15 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
-
 from ast import (
-    AST_Number, AST_Unary, AST_Seq, AST_Array, AST_Binary, AST_Set, AST_Object,
-    AST_Statement, AST_Conditional, AST_BaseCall, AST_Symbol, AST_SymbolRef, AST_Assign,
-    AST_Return, AST_SimpleStatement, AST_String, AST_Sub, AST_ItemAccess, is_node_type
+    AST_Array, AST_Assign, AST_BaseCall, AST_Binary, AST_Conditional,
+    AST_ItemAccess, AST_Number, AST_Object, AST_Return, AST_Seq, AST_Set,
+    AST_SimpleStatement, AST_Statement, AST_String, AST_Sub, AST_Symbol,
+    AST_SymbolRef, AST_Unary, is_node_type
 )
 from output.loops import unpack_tuple
 
+
 def print_getattr(self, output, skip_expression):  # AST_Dot
     if not skip_expression:
         expr = self.expression
@@ -54,7 +55,17 @@ def print_rich_getitem(self, output):  # AST_ItemAccess
     output.print(func + '(')
     self.expression.print(output), output.comma(), self.property.print(output)
     if self.assignment:
-        output.comma(), self.assignment.print(output)
+        output.comma()
+        asg = self.assignment
+        as_op = self.assign_operator
+        if as_op.length > 0:
+            self.assignment = None
+            print_rich_getitem(self, output)
+            self.assignment = asg
+            output.space()
+            output.print(as_op)
+            output.space()
+        self.assignment.print(output)
     output.print(')')
 
 def print_splice_assignment(self, output):  # AST_Splice
@@ -82,7 +93,12 @@ def print_unary_prefix(self, output):
     output.print(op)
     if /^[a-z]/i.test(op):
         output.space()
-    self.expression.print(output)
+    if self.parenthesized:
+        output.with_parens(def():
+            self.expression.print(output)
+        )
+    else:
+        self.expression.print(output)
 
 def write_instanceof(left, right, output):
 
@@ -123,19 +139,21 @@ def write_smart_equality(self, output):
         output.print('ρσ_' + ('equals(' if self.operator is '==' else 'not_equals('))
         self.left.print(output), output.print(','), output.space(), self.right.print(output), output.print(')')
 
-def print_binary_op(self, output):
-    comparators = {
-        "<": True,
-        ">": True,
-        "<=": True,
-        ">=": True,
-        "==": True,
-        "!=": True
-    }
-    function_ops = {
-        "in": "ρσ_in",
-    }
 
+comparators = {
+    "<": True,
+    ">": True,
+    "<=": True,
+    ">=": True,
+}
+
+function_ops = {
+    "in": "ρσ_in",
+    'nin': '!ρσ_in',
+}
+
+
+def print_binary_op(self, output):
     if function_ops[self.operator]:
         output.print(function_ops[self.operator])
         output.with_parens(def():
@@ -144,6 +162,7 @@ def print_binary_op(self, output):
             self.right.print(output)
         )
     elif comparators[self.operator] and is_node_type(self.left, AST_Binary) and comparators[self.left.operator]:
+        # A chained comparison such as a < b < c
         if is_node_type(self.left.right, AST_Symbol):
             # left side compares against a regular variable,
             # no caching needed
@@ -184,7 +203,7 @@ def print_binary_op(self, output):
         if is_node_type(self.left, AST_Unary) and not self.left.parenthesized:
             left = self.left.expression
             output.print(self.left.operator)
-        if output.options.js_version > 5:
+        if output.options.js_version > 6:
             output.print('(('), left.print(output), output.spaced(')', '**', '('), self.right.print(output), output.print('))')
         else:
             output.print('Math.pow('), left.print(output), output.comma(), self.right.print(output), output.print(')')
@@ -194,6 +213,18 @@ def print_binary_op(self, output):
         write_instanceof(self.left, self.right, output)
     elif self.operator is '*' and is_node_type(self.left, AST_String):
         self.left.print(output), output.print('.repeat('), self.right.print(output), output.print(')')
+    elif self.operator is '===' or self.operator is '!==':
+        nan_check = None
+        if is_node_type(self.right, AST_Symbol) and self.right.name is 'NaN':
+            nan_check = self.left
+        if is_node_type(self.left, AST_Symbol) and self.left.name is 'NaN':
+            nan_check = self.right
+        if nan_check is not None:
+            # We use the fact that NaN is the only object that is not equal to
+            # itself
+            output.spaced(nan_check, '!==' if self.operator is '===' else '===', nan_check)
+        else:
+            output.spaced(self.left, self.operator, self.right)
     else:
         output.spaced(self.left, self.operator, self.right)
 

package/src/output/statements.pyj

@@ -112,7 +112,7 @@ def print_bracketed(node, output, complex, function_preamble, before, after):
             if complex:
                 display_complex_body(node, False, output, function_preamble)
             else:
-                display_body(node.body, False, output, function_preamble)
+                display_body(node.body, False, output)
             if after:
                 after(output)
         )
@@ -171,7 +171,7 @@ def print_with(self, output):
 def print_assert(self, output):
     if output.options.discard_asserts:
         return
-    output.spaced('if', '(!'), self.condition.print(output), output.spaced(')', 'throw new AssertionError')
+    output.spaced('if', '(!('), self.condition.print(output), output.spaced('))', 'throw new AssertionError')
     if self.message:
         output.print('(')
         self.message.print(output)

package/src/output/stream.pyj

@@ -8,25 +8,27 @@ from tokenizer import is_identifier_char
 
 DANGEROUS = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g
 
+
+def as_hex(code, sz):
+    val = code.toString(16)
+    if val.length < sz:
+        val = '0'.repeat(sz - val.length) + val
+    return val
+
+
 def to_ascii(str_, identifier):
     return str_.replace(/[\u0080-\uffff]/g, def(ch):
         code = ch.charCodeAt(0).toString(16)
         if code.length <= 2 and not identifier:
-            while code.length < 2:
-                code = "0" + code
-
-            return "\\x" + code
+            return "\\x" + as_hex(code, 2)
         else:
-            while code.length < 4:
-                code = "0" + code
-
-            return "\\u" + code
+            return '\\u' + as_hex(code, 4)
 
     )
 
 def encode_string(str_):
     return JSON.stringify(str_).replace(DANGEROUS, def(a):
-            return '\\u' + a.charCodeAt(0).toString(16)
+            return '\\u' + as_hex(a.charCodeAt(0), 4)
     )
 require_semi_colon_chars = make_predicate("( [ + * / - , .")
 
@@ -64,7 +66,6 @@ class OutputStream:
         self.current_line = 1
         self.current_pos = 0
         self.OUTPUT = ""
-        self.IMPORTED = {}
         self.might_need_space = False
         self.might_need_semicolon = False
         self._last = None
@@ -249,7 +250,7 @@ class OutputStream:
         self.indent()
         self.spaced('var', 'ρσ_regenerator', '=', '{}')
         self.end_statement()
-        code = regenerate(False, self.options.beautify)
+        code = 'ρσ_regenerator.regeneratorRuntime = ' + regenerate(False, self.options.beautify)
         if self.options.beautify:
             code = code.replace(/\/\/.*$/mg, '\n').replace(/^\s*$/gm, '')  # strip comments
             ci = self.make_indent(0)
@@ -259,9 +260,7 @@ class OutputStream:
 
     def get(self):
         return self.OUTPUT
-
-    def toString(self):
-        return self.OUTPUT
+    toString = get
 
     def assign(self, name):
         # generates: '[name] = '
@@ -285,13 +284,6 @@ class OutputStream:
     def print_string(self, str_):
         self.print(encode_string(str_))
 
-    def import_(self, module):
-        if not Object.prototype.hasOwnProperty.call(self.IMPORTED, module.key):
-            self.IMPORTED[module.key] = module
-
-    def is_main(self):
-        return self.OUTPUT.length is 0
-
     def line(self):
         return self.current_line
 

package/src/parse.pyj

@@ -29,8 +29,17 @@ from tokenizer import tokenizer, is_token, RESERVED_WORDS
 COMPILER_VERSION = '__COMPILER_VERSION__'
 PYTHON_FLAGS = {'dict_literals':True, 'overload_getitem':True, 'bound_methods':True, 'hash_literals':True}
 
+
+def get_compiler_version():
+    return COMPILER_VERSION
+
+
+def static_predicate(names):
+    return {k:True for k in names.split(' ')}
+
 NATIVE_CLASSES = {
     'Image': {},
+    'FileReader': {},
     'RegExp': {},
     'Error': {},
     'EvalError': {},
@@ -41,24 +50,26 @@ NATIVE_CLASSES = {
     'TypeError': {},
     'URIError': {},
     'Object': {
-        'static': [
-            "getOwnPropertyNames", 'getOwnPropertyDescriptor',
-            'getOwnPropertySymbols', "keys", 'entries', 'values', "create", 'defineProperty',
-            'defineProperties', 'getPrototypeOf', 'setPrototypeOf', 'assign'
-        ]
+        'static': static_predicate(
+            'getOwnPropertyNames getOwnPropertyDescriptor getOwnPropertyDescriptors'
+            ' getOwnPropertySymbols keys entries values create defineProperty'
+            ' defineProperties getPrototypeOf setPrototypeOf assign'
+            ' seal isSealed is preventExtensions isExtensible'
+            ' freeze isFrozen'
+        )
     },
     'String': {
-        'static': [ "fromCharCode" ]
+        'static': static_predicate("fromCharCode")
     },
     'Array': {
-        'static': [ "isArray", "from", "of" ]
+        'static': static_predicate("isArray from of")
     },
     'Function': {},
     'Date': {
-        'static': [ "UTC", "now", "parse" ]
+        'static': static_predicate("UTC now parse")
     },
     'ArrayBuffer': {
-        'static': ['isView', 'transfer'],
+        'static': static_predicate('isView transfer')
     },
     'DataView': {},
     'Float32Array': {},
@@ -76,7 +87,7 @@ NATIVE_CLASSES = {
     'Set': {},
     'WeakSet': {},
     'Promise': {
-        'static': ['all', 'race', 'reject', 'resolve']
+        'static': static_predicate('all race reject resolve')
     },
     'WebSocket': {},
     'XMLHttpRequest': {},
@@ -97,7 +108,7 @@ ERROR_CLASSES = {
     'AssertionError': {},
     'ZeroDivisionError': {},
 }
-COMMON_STATIC = [ "call", "apply", "bind", "toString" ]
+COMMON_STATIC = static_predicate('call apply bind toString')
 FORBIDDEN_CLASS_VARS = 'prototype constructor'.split(' ')
 
 # -----[ Parser (constants) ]-----
@@ -119,7 +130,7 @@ PRECEDENCE = (def(a, ret):
     [ "^" ],
     [ "&" ],
     [ "==", "===", "!=", "!==" ],
-    [ "<", ">", "<=", ">=", "in", "instanceof" ],
+    [ "<", ">", "<=", ">=", "in", "nin", "instanceof" ],
     [ ">>", "<<", ">>>" ],
     [ "+", "-" ],
     [ "*", "/", "//", "%" ],
@@ -320,7 +331,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     continue
 
                 # recursive descent into conditional, loop and exception bodies
-                for option in ('body', 'alternative', 'bcatch'):
+                for option in ('body', 'alternative', 'bcatch', 'condition'):
                     opt = stmt[option]
                     if opt:
                         extend(scan_for_local_vars(opt))
@@ -467,13 +478,20 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                         expect(".")
                         expect_token("keyword", "while")
                         tmp = expression(True)
+                        if is_node_type(tmp, AST_Assign):
+                            croak('Assignments in do loop conditions are not allowed')
                         semicolon()
                         return tmp
                     )()
                 })
             elif tmp_ is "while":
+                while_cond = expression(True)
+                if is_node_type(while_cond, AST_Assign):
+                    croak('Assignments in while loop conditions are not allowed')
+                if not is_('punc', ':'):
+                    croak('Expected a colon after the while statement')
                 return new AST_While({
-                    'condition': expression(True),
+                    'condition': while_cond,
                     'body': in_loop(statement)
                 })
             elif tmp_ is "for":
@@ -739,7 +757,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             cached = None
 
         srchash = sha1sum(src_code)  # noqa:undef
-        if cached and cached.version is COMPILER_VERSION and cached.signature is srchash and cached.discard_asserts is options.discard_asserts:
+        if cached and cached.version is COMPILER_VERSION and cached.signature is srchash and cached.discard_asserts is v'!!options.discard_asserts':
             for ikey in cached.imported_module_ids:
                 do_import(ikey)  # Ensure all modules imported by the cached module are also imported
             imported_modules[key] = {
@@ -880,7 +898,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         externaldecorator = has_simple_decorator(S.decorators, 'external')
 
         class_details = {
-            "static": [],
+            "static": {},
             'bound': v'[]',
             'classvars': {},
             'processing': name.name,
@@ -969,7 +987,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 if is_node_type(node, AST_Method):
                     class_var_names[node.name.name] = True
                     return
-                elif is_node_type(node, AST_Assign) and is_node_type(node.left, AST_SymbolRef):
+                if is_node_type(node, AST_Function):
+                    return
+                if is_node_type(node, AST_Assign) and is_node_type(node.left, AST_SymbolRef):
                     varname = node.left.name
                     if FORBIDDEN_CLASS_VARS.indexOf(varname) is not -1:
                         token_error(node.left.start, varname + ' is not allowed as a class variable name')
@@ -1002,7 +1022,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             if staticloc:
                 if property_getter or property_setter:
                     croak('A method cannot be both static and a property getter/setter')
-                S.classes[S.classes.length - 2][in_class].static.push(name.name)
+                S.classes[S.classes.length - 2][in_class].static[name.name] = True
                 staticmethod = True
             elif name.name is not "__init__" and S.scoped_flags.get('bound_methods'):
                 S.classes[S.classes.length - 2][in_class].bound.push(name.name)
@@ -1689,7 +1709,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         return sym
 
     def is_static_method(cls, method):
-        if COMMON_STATIC.indexOf(method) is not -1 or cls.static and cls.static.indexOf(method) is not -1:
+        if has_prop(COMMON_STATIC, method) or (cls.static and has_prop(cls.static, method)):
             return True
         else:
             return False
@@ -1782,7 +1802,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             # regular index (arr[index])
             if is_py_sub:
                 assignment = None
-                if is_("operator") and S.token.value is "=":
+                assign_operator = ''
+                if is_("operator") and ASSIGNMENT[S.token.value]:
+                    assign_operator = S.token.value[:-1]
                     next()
                     assignment = expression(True)
                 return subscripts(new AST_ItemAccess({
@@ -1792,6 +1814,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                         'value': 0
                     }),
                     'assignment':assignment,
+                    'assign_operator': assign_operator,
                     'end': prev()
                 }), allow_calls)
 
@@ -1941,10 +1964,11 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             return new AST_EmptyStatement({'stype':'@', 'start':prev(), 'end':prev()})
         if is_("operator") and UNARY_PREFIX[start.value]:
             next()
+            is_parenthesized = is_('punc', '(')
             S.in_delete = start.value is 'delete'
             expr = maybe_unary(allow_calls)
             S.in_delete = False
-            ex = make_unary(AST_UnaryPrefix, start.value, expr)
+            ex = make_unary(AST_UnaryPrefix, start.value, expr, is_parenthesized)
             ex.start = start
             ex.end = prev()
             return ex
@@ -1952,23 +1976,21 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         val = expr_atom(allow_calls)
         return val
 
-    def make_unary(ctor, op, expr):
+    def make_unary(ctor, op, expr, is_parenthesized):
         return new ctor({
             'operator': op,
-            'expression': expr
+            'expression': expr,
+            'parenthesized': is_parenthesized
         })
 
     def expr_op(left, min_prec, no_in):
         op = S.token.value if is_('operator') else None
-        not_in = False
         if op is "!" and peek().type is "operator" and peek().value is "in":
             next()
-            op = "in"
-            not_in = True
+            S.token.value = op = 'nin'
 
-        if op is "in":
-            if no_in:
-                op = None
+        if no_in and (op is "in" or op is 'nin'):
+            op = None
 
         prec = PRECEDENCE[op] if op is not None else None
         if prec is not None and prec > min_prec:
@@ -1981,13 +2003,6 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'right': right,
                 'end': right.end
             })
-            if not_in:
-                ret = new AST_UnaryPrefix({
-                    'start': left.start,
-                    'operator': "!",
-                    'expression': ret,
-                    'end': right.end
-                })
             return expr_op(ret, min_prec, no_in)
         return left
 
@@ -2166,6 +2181,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         toplevel.baselib = baselib_items
         toplevel.scoped_flags = S.scoped_flags.stack[0]
         importing_modules[module_id] = False
+        toplevel.comments_after = S.token.comments_before or v'[]'
         return toplevel
 
     return run_parser

package/src/string_interpolation.pyj

@@ -14,7 +14,12 @@ def render_markup(markup):
         key += ch
         pos += 1
     fmtspec = markup[pos:]
-    return 'ρσ_str.format("{' + fmtspec + '}", ' + key + ')'
+    prefix = ''
+    if key.endsWith('='):
+        prefix=key
+        key = key[:-1]
+    return 'ρσ_str.format("' + prefix + '{' + fmtspec + '}", ' + key + ')'
+
 
 def interpolate(template, raise_error):
     pos = in_brace = 0

package/src/tokenizer.pyj

@@ -458,7 +458,10 @@ def tokenizer(raw_text, filename):
             else:
                 return token(tok_type, '')
 
-        while ch = next(True, True):
+        while True:
+            ch = next(True, True)
+            if not ch:
+                break
             if ch is "\n" and not is_multiline:
                 parse_error("End of line while scanning string literal")
 
@@ -529,7 +532,10 @@ def tokenizer(raw_text, filename):
             else: # empty regexp (//)
                 mods = read_name()
                 return token("regexp", RegExp(regexp, mods))
-        while (ch = next(True)):
+        while True:
+            ch = next(True)
+            if not ch:
+                break
             if in_comment:
                 if ch is '\n':
                     in_comment = False

package/test/baselib.pyj

@@ -20,6 +20,11 @@ assrt.deepEqual(['a', 'b'], list('ab'))
 assrt.ok(q is not list(q))
 assrt.deepEqual(q, list(q))
 assrt.ok(isinstance([], (String, list)))
+assrt.ok(isinstance(1, int))
+assrt.ok(not isinstance(v'new Number(1)', int))
+assrt.ok(not isinstance(1.1, int))
+assrt.ok(isinstance(1.1, float))
+assrt.ok(not isinstance(v'new Number(1.1)', float))
 m = Map()
 m.set('a', 1)
 assrt.equal(len(m), 1)
@@ -70,6 +75,9 @@ assrt.equal(int('a', 16), 10)
 assrt.throws(def ():int('a');, ValueError)
 assrt.equal(float('10.3'), 10.3)
 assrt.throws(def ():float('a');, ValueError)
+assrt.equal(int(2*1e-7), 0)
+assrt.equal(int(10*1e-7), 0)
+assrt.equal(float(3*1e-7), 3e-7)
 
 # sum()
 assrt.equal(6, sum([1, 2, 3]))
@@ -259,6 +267,8 @@ assrt.equal(b == a, False)
 a, b = range(1111111111)
 assrt.equal(a, 0)
 assrt.equal(b, 1)
+assrt.equal(len(range(10)), 10)
+assrt.equal(str(range(10)), 'range(0, 10, 1)')
 
 assrt.deepEqual(divmod(7, 3), [2, 1])
 assrt.deepEqual(divmod(-7, 3), [-3, 2])

package/test/classes.pyj

@@ -401,6 +401,7 @@ class B2(B1):
     def two(self):
         return self.b2
 assrt.equal(B2().two(), 2)
+assrt.equal(B2().b1, 1)
 
 
 class Cvar:
@@ -426,3 +427,26 @@ assrt.equal(Cvar.a, 2)
 assrt.equal(Cvar().val(), 3)
 assrt.equal(Cvar().incb(), 1)
 assrt.equal(Cvar().incb(), 2)
+
+class anon_func_in_class:
+
+    f = def():
+        func_var = 1
+        return func_var
+
+    def func_var(self):
+        pass
+
+assrt.equal(jstype(anon_func_in_class.prototype.func_var), 'function')
+anon_func_in_class.prototype.f()
+assrt.equal(jstype(anon_func_in_class.prototype.func_var), 'function')
+
+
+def decorate(cls):
+    assrt.equal(cls.prototype.somevar, 1)
+    return cls
+
+
+@decorate
+class decorated:
+    somevar = 1

package/test/collections.pyj

@@ -69,6 +69,13 @@ assrt.deepEqual(a, [3,2,1])
 a.pysort()
 assrt.deepEqual(a, [1,2,3])
 
+# misc interface
+a = [1,2,3]
+assrt.equal(a.pypop(), 3)
+assrt.deepEqual(a, [1,2])
+assrt.equal(a.pypop(0), 1)
+assrt.deepEqual(a, [2])
+
 # strings
 assrt.ok("tes" in "this is a test")
 
@@ -104,6 +111,7 @@ assrt.equal(d1.fun2(3), 4)
 assrt.equal(len(d0), 3)
 assrt.equal(d2.get(1), 2)
 assrt.equal(d2.get('a'), 'b')
+assrt.deepEqual(d2.popitem(), ['a', 'b'])
 
 # assignment
 d1["bar"] += "!"