rapydscript-ns 0.8.3 → 0.9.0

package/src/parse.pyj

@@ -21,16 +21,17 @@ AST_SymbolCatch, AST_SymbolDefun, AST_SymbolFunarg,
 AST_SymbolLambda, AST_SymbolNonlocal, AST_SymbolRef, AST_SymbolVar, AST_This,
 AST_Throw, AST_Toplevel, AST_True, AST_Try, AST_UnaryPrefix,
 AST_Undefined, AST_Var, AST_VarDef, AST_Verbatim, AST_While, AST_With, AST_WithClause,
-AST_Yield, AST_Await, AST_Assert, AST_Existential, AST_NamedExpr, AST_AnnotatedAssign, AST_Super, AST_Starred, is_node_type,
+AST_Yield, AST_Await, AST_Assert, AST_Existential, AST_NamedExpr, AST_AnnotatedAssign, AST_Super, AST_Starred, AST_Spread, is_node_type,
 AST_Match, AST_MatchCase,
 AST_MatchWildcard, AST_MatchCapture, AST_MatchLiteral, AST_MatchOr,
 AST_MatchAs, AST_MatchStar, AST_MatchSequence, AST_MatchMapping, AST_MatchClass,
+AST_JSXElement, AST_JSXFragment, AST_JSXAttribute, AST_JSXSpread, AST_JSXText, AST_JSXExprContainer,
 TreeWalker
 )
 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, 'overload_operators':True, 'truthiness':True}
+PYTHON_FLAGS = {'dict_literals':True, 'overload_getitem':True, 'bound_methods':True, 'hash_literals':True, 'overload_operators':True, 'truthiness':True, 'jsx':True, 'strict_arithmetic':True}
 
 
 def get_compiler_version():
@@ -143,7 +144,7 @@ PRECEDENCE = (def(a, ret):
 
 STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ])
 
-ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name", "js" ])
+ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "imaginary", "string", "bytes_literal", "regexp", "name", "js" ])
 
 compile_time_decorators = ['staticmethod', 'classmethod', 'external', 'property']
 
@@ -511,7 +512,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         p = prev()
         if p and not S.token.nlb and ATOMIC_START_TOKEN[p.type] and not is_('punc', ':'):
             unexpected()
-        if tmp_ is "string":
+        if tmp_ is "string" or tmp_ is "bytes_literal":
             return simple_statement()
         elif tmp_ is "shebang":
             tmp_ = S.token.value
@@ -541,7 +542,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 p = peek()
                 # 'match' is a soft keyword: treat as match statement when followed by
                 # a token that can start an expression subject (not an assignment/attr-access/call op)
-                if p.type is 'name' or p.type is 'string' or p.type is 'num' or p.type is 'atom' or p.type is 'js' or (p.type is 'punc' and (p.value is '[' or p.value is '(')):
+                if p.type is 'name' or p.type is 'string' or p.type is 'bytes_literal' or p.type is 'num' or p.type is 'atom' or p.type is 'js' or (p.type is 'punc' and (p.value is '[' or p.value is '(')):
                     next()  # consume the 'match' name token
                     return match_()
             if (is_token(peek(), 'punc', ':')):
@@ -1062,7 +1063,26 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         })
 
     def simple_statement(tmp):
+        start = S.token
         tmp = expression(True)
+        # Handle annotated assignment with a complex target (e.g., self.x: Type = value).
+        # Simple-name annotated assignments are caught earlier (annotated_var_statement),
+        # but attribute/subscript targets reach here as a completed expression followed by ':'.
+        if is_("punc", ":"):
+            next()  # consume ':'
+            annotation = maybe_conditional()
+            value = None
+            if is_("operator", "="):
+                next()  # consume '='
+                value = expression(True)
+            semicolon()
+            return new AST_AnnotatedAssign({
+                'start': start,
+                'target': tmp,
+                'annotation': annotation,
+                'value': value,
+                'end': prev()
+            })
         semicolon()
         return new AST_SimpleStatement({
             'body': tmp
@@ -1188,17 +1208,18 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         # to maintain a list of local variables for every AST_Scope and provide
         # an easy way to walk the ast tree upwards.
         if is_node_type(expr, AST_SymbolRef):
-            # check Native JS classes
+            # traverse in reverse to check local / imported classes first
+            # (user-defined classes take priority over native JS classes)
+            for s in range(S.classes.length-1, -1, -1):
+                if has_prop(S.classes[s], expr.name):
+                    return S.classes[s][expr.name]
+
+            # fallback to Native JS classes
             if has_prop(NATIVE_CLASSES, expr.name):
                 return NATIVE_CLASSES[expr.name]
             if has_prop(ERROR_CLASSES, expr.name):
                 return ERROR_CLASSES[expr.name]
 
-            # traverse in reverse to check local variables first
-            for s in range(S.classes.length-1, -1, -1):
-                if has_prop(S.classes[s], expr.name):
-                    return S.classes[s][expr.name]
-
         elif is_node_type(expr, AST_Dot):
             referenced_path = []
             # this one is for detecting classes inside modules and eventually nested classes
@@ -1414,6 +1435,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             'provisional_classvars': {},
         }
         bases = v'[]'
+        class_kwargs = v'[]'
         class_parent = None
 
         # If this class is nested inside another class, register it under its
@@ -1437,10 +1459,14 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     S.in_parenthesized_expr = False
                     next()
                     break
-                a = expr_atom(False)
-                if class_parent is None:
-                    class_parent = a
-                bases.push(a)
+                a = expression(False)
+                if is_node_type(a, AST_Assign):
+                    # key=value → class keyword argument for __init_subclass__
+                    class_kwargs.push([a.left, a.right])
+                else:
+                    if class_parent is None:
+                        class_parent = a
+                    bases.push(a)
                 if is_('punc', ','):
                     next()
                     continue
@@ -1455,6 +1481,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             'dynamic_properties': Object.create(None),
             'parent': class_parent,
             'bases': bases,
+            'class_kwargs': class_kwargs,
             'localvars': [],
             'classvars': class_details.classvars,
             'static': class_details.static,
@@ -1501,6 +1528,26 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     descriptor['getter' if stmt.is_getter else 'setter'] = stmt
                 elif stmt.name.name is "__init__":
                     definition.init = stmt
+                elif stmt.name.name is "__new__":
+                    definition.has_new = True
+                    class_details.has_new = True
+                    class_details.static['__new__'] = True
+                    stmt.static = True  # suppress var cls = this in display_complex_body
+                elif stmt.name.name is "__class_getitem__":
+                    stmt.is_classmethod = True
+                    class_details.classmethod['__class_getitem__'] = True
+                elif stmt.name.name is "__init_subclass__":
+                    stmt.is_classmethod = True
+                    class_details.classmethod['__init_subclass__'] = True
+                elif stmt.name.name in ['__getattr__', '__setattr__', '__delattr__', '__getattribute__']:
+                    definition.has_attr_dunders = True
+                    class_details.has_attr_dunders = True
+        # Propagate has_attr_dunders from parent classes so subclasses are also Proxy-wrapped.
+        if not definition.has_attr_dunders and definition.parent:
+            parent_details = get_class_in_scope(definition.parent)
+            if parent_details and parent_details.has_attr_dunders:
+                definition.has_attr_dunders = True
+                class_details.has_attr_dunders = True
         # find the class variables
         class_var_names = {}
         # Ensure that if a class variable refers to another class variable in
@@ -1730,7 +1777,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 S.in_parenthesized_expr = False
                 a.defaults = defaults
                 a.is_simple_func = not a.starargs and not a.kwargs and not a.has_defaults and not a.bare_star and not a.posonly_count
-                if classmethod_flag and a.length > 0:
+                if (classmethod_flag or (name and (name.name is '__new__' or name.name is '__class_getitem__' or name.name is '__init_subclass__'))) and a.length > 0:
                     cm_cls_arg.push(a[0].name)
                 return a
             )(v'[]'),
@@ -1748,7 +1795,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             'body': (def(loop, labels):
                 S.in_class.push(False)
                 cm_pushed = v'[false]'
-                if classmethod_flag and in_class and cm_cls_arg.length > 0:
+                if (classmethod_flag or (name and (name.name is '__new__' or name.name is '__class_getitem__' or name.name is '__init_subclass__'))) and in_class and cm_cls_arg.length > 0:
                     cm_ctx_entry = None
                     for v'var si = S.classes.length - 1; si >= 0; si--':
                         if has_prop(S.classes[si], in_class):
@@ -1978,9 +2025,18 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         bcatch = v'[]'
         bfinally = None
         belse = None
+        has_star = None  # None = not yet seen, True/False = seen star/non-star
         while is_("keyword", "except"):
             start = S.token
             next()
+            is_star = False
+            if is_("operator", "*"):
+                is_star = True
+                next()
+            if has_star is None:
+                has_star = is_star
+            elif has_star is not is_star:
+                croak("Cannot mix 'except' and 'except*' in the same try statement")
             exceptions = []
             if not is_("punc", ":") and not is_("keyword", "as"):
                 # Accept both: except TypeError, ValueError:
@@ -2006,6 +2062,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'start': start,
                 'argname': name,
                 'errors': exceptions,
+                'is_star': is_star,
                 'body': block_(),
                 'end': prev()
             }))
@@ -2097,6 +2154,26 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             'value': strings.join('')
         })
 
+    def bytes_literal_():
+        parts = v'[]'
+        start = S.token
+        while True:
+            parts.push(S.token.value)
+            if peek().type is not 'bytes_literal':
+                break
+            next()
+        end_tok = S.token
+        value = parts.join('')
+        return new AST_Call({
+            'start': start,
+            'end': end_tok,
+            'expression': new AST_SymbolRef({'name': 'bytes', 'start': start, 'end': start}),
+            'args': [
+                new AST_String({'start': start, 'end': end_tok, 'value': value}),
+                new AST_String({'start': start, 'end': end_tok, 'value': 'latin-1'})
+            ]
+        })
+
     def token_as_atom_node():
         tok = S.token
         tmp_ = tok.type
@@ -2108,8 +2185,20 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'end': tok,
                 'value': tok.value
             })
+        elif tmp_ is "imaginary":
+            return new AST_Call({
+                'start': tok,
+                'end': tok,
+                'expression': new AST_SymbolRef({'name': 'complex', 'start': tok, 'end': tok}),
+                'args': [
+                    new AST_Number({'start': tok, 'end': tok, 'value': 0}),
+                    new AST_Number({'start': tok, 'end': tok, 'value': tok.value})
+                ]
+            })
         elif tmp_ is "string":
             return string_()
+        elif tmp_ is "bytes_literal":
+            return bytes_literal_()
         elif tmp_ is "regexp":
             return new AST_RegExp({
                 'start': tok,
@@ -2164,17 +2253,28 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 if is_('punc', ')'):
                     next()
                     return new AST_Array({'elements':[]})
-                ex = expression(True)
+                ex = expression(False)
                 if is_('keyword', 'for'):
                     ret = read_comprehension(new AST_GeneratorComprehension({'statement': ex}), ')')
                     S.in_parenthesized_expr = False
                     return ret
+                if is_('punc', ','):
+                    # Tuple literal: (a,) or (a, b, c, ...) — compile to JS array
+                    elements = [ex]
+                    while is_('punc', ','):
+                        next()
+                        if is_('punc', ')'):
+                            break  # trailing comma is OK
+                        elements.push(expression(False))
+                    expect(')')
+                    arr = new AST_Array({'elements': elements, 'start': start, 'end': prev()})
+                    S.in_parenthesized_expr = False
+                    return subscripts(arr, allow_calls)
                 ex.start = start
                 ex.end = S.token
                 if is_node_type(ex, AST_SymbolRef):
                     ex.parens = True
-                if not is_node_type(ex, AST_GeneratorComprehension):
-                    expect(")")
+                expect(")")
                 if is_node_type(ex, AST_UnaryPrefix):
                     ex.parenthesized = True
                 S.in_parenthesized_expr = False
@@ -2248,6 +2348,13 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             if is_("operator", "*") and func_call:
                 saw_starargs = True
                 next()
+            elif is_("operator", "*") and not func_call:
+                # Spread element in list literal: [1, *a, 2]
+                start = S.token
+                next()
+                spread_expr = expression(False)
+                a.push(new AST_Spread({'start': start, 'expression': spread_expr, 'end': prev()}))
+                continue
 
             if is_("punc", ",") and allow_empty:
                 a.push(new AST_Hole({
@@ -2294,7 +2401,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 a.starargs = True
             elif is_('operator', '**'):
                 next()
-                a.kwarg_items.push(as_symbol(AST_SymbolRef, False))
+                a.kwarg_items.push(expression(False))
                 a.starargs = True
             else:
                 arg = expression(False)
@@ -2318,10 +2425,17 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         expect("[")
         expr = []
         if not is_("punc", "]"):
-            expr.push(expression(False))
-            if is_("keyword", "for"):
-                # list comprehension
-                return read_comprehension(new AST_ListComprehension({'statement': expr[0]}), ']')
+            if is_("operator", "*"):
+                # Spread as first element — no list comprehension possible
+                start = S.token
+                next()
+                spread_expr = expression(False)
+                expr.push(new AST_Spread({'start': start, 'expression': spread_expr, 'end': prev()}))
+            else:
+                expr.push(expression(False))
+                if is_("keyword", "for"):
+                    # list comprehension
+                    return read_comprehension(new AST_ListComprehension({'statement': expr[0]}), ']')
 
             if not is_("punc", "]"):
                 expect(",")
@@ -2356,6 +2470,12 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 }))
                 has_non_const_keys = True
                 continue
+            if is_('operator', '*'):
+                # Must be a set literal with spread as first item: {*a, ...}
+                next()
+                spread_expr = expression(False)
+                spread_node = new AST_Spread({'start': start, 'expression': spread_expr, 'end': prev()})
+                return _read_set_items([spread_node], start)
             ctx = S.input.context()
             orig = ctx.expecting_object_literal_key
             ctx.expecting_object_literal_key = True
@@ -2388,18 +2508,25 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             'is_jshash': is_jshash,
         })
 
-    def set_(start, end, expr):
-        ostart = start
-        a = [new AST_SetItem({'start':start, 'end':end, 'value':expr})]
+    def _read_set_items(a, ostart):
+        "Read remaining items of a set literal into a (handles * spread)"
         while not is_("punc", "}"):
             expect(",")
-            start = S.token
+            item_start = S.token
             if is_("punc", "}"):
                 # allow trailing comma
                 break
-            a.push(new AST_SetItem({'start':start, 'value':expression(False), 'end':prev()}))
+            if is_("operator", "*"):
+                next()
+                spread_expr = expression(False)
+                a.push(new AST_Spread({'start': item_start, 'expression': spread_expr, 'end': prev()}))
+            else:
+                a.push(new AST_SetItem({'start': item_start, 'value': expression(False), 'end': prev()}))
         next()
-        return new AST_Set({'items':a, 'start':ostart, 'end':prev()})
+        return new AST_Set({'items': a, 'start': ostart, 'end': prev()})
+
+    def set_(start, end, expr):
+        return _read_set_items([new AST_SetItem({'start':start, 'end':end, 'value':expr})], start)
 
     def _read_comp_conditions():
         # Read zero or more consecutive `if` conditions, combining them with &&.
@@ -2602,6 +2729,20 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 multi_arr = new AST_Array({'start': start, 'elements': multi_items, 'end': prev()})
                 multi_arr.is_subscript_tuple = True
                 prop = multi_arr
+            # __class_getitem__: Class[item] → Class.__class_getitem__(item)
+            cls_info = get_class_in_scope(expr)
+            if cls_info and is_static_method(cls_info, '__class_getitem__'):
+                return subscripts(new AST_Call({
+                    'start': start,
+                    'expression': new AST_Dot({
+                        'start': start,
+                        'expression': expr,
+                        'property': '__class_getitem__',
+                        'end': prev()
+                    }),
+                    'args': [prop],
+                    'end': prev()
+                }), allow_calls)
             if is_py_sub:
                 assignment = None
                 assign_operator = ''
@@ -2630,22 +2771,68 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         S.in_parenthesized_expr = True
         next()
         if not expr.parens and get_class_in_scope(expr):
-            # this is an object being created using a class
-            ret = subscripts(new AST_New({
-                'start': start,
-                'expression': expr,
-                'args': func_call_list(),
-                'end': prev()
-            }), True)
+            c = get_class_in_scope(expr)
+            # Class instantiation
+            args = func_call_list()
+            if c.has_new:
+                # Class defines __new__: call without 'new' so __new__ controls
+                # instantiation (the constructor dispatches via !(this instanceof ...))
+                ret = subscripts(new AST_Call({
+                    'start': start,
+                    'expression': expr,
+                    'args': args,
+                    'end': prev()
+                }), True)
+            else:
+                ret = subscripts(new AST_New({
+                    'start': start,
+                    'expression': expr,
+                    'args': args,
+                    'end': prev()
+                }), True)
             S.in_parenthesized_expr = False
             return ret
-        else:
-            if is_node_type(expr, AST_Dot):
-                if is_node_type(expr.expression, AST_Super):
+        if is_node_type(expr, AST_Dot):
+            if is_node_type(expr.expression, AST_Super):
+                super_node = expr.expression
+                method_name = expr.property
+                method_args = func_call_list()
+                if method_name is '__new__':
+                    if super_node.parent:
+                        # super().__new__(cls, ...) → ρσ_new(parent, cls, ...)
+                        method_args.unshift(super_node.parent)
+                        ret = subscripts(new AST_Call({
+                            'start': start,
+                            'expression': new AST_SymbolRef({
+                                'name': 'ρσ_new',
+                                'start': start,
+                                'end': start
+                            }),
+                            'args': method_args,
+                            'end': prev()
+                        }), True)
+                    else:
+                        # Root class: super().__new__(cls) → ρσ_object_new(cls)
+                        cls_args = v'[]'
+                        if method_args.length > 0:
+                            cls_args.push(method_args[0])
+                        ret = subscripts(new AST_Call({
+                            'start': start,
+                            'expression': new AST_SymbolRef({
+                                'name': 'ρσ_object_new',
+                                'start': start,
+                                'end': start
+                            }),
+                            'args': cls_args,
+                            'end': prev()
+                        }), True)
+                else:
+                    if not super_node.parent:
+                        croak('super() used in a class without a parent class')
                     # super().method(args) → ParentClass.prototype.method.call(this, args)
-                    super_node = expr.expression
-                    method_name = expr.property
-                    method_args = func_call_list()
+                    # But for classmethods/static methods, use ParentClass.method.call(this, args)
+                    parent_cls_info = get_class_in_scope(super_node.parent)
+                    super_is_static = parent_cls_info and is_static_method(parent_cls_info, method_name)
                     this_node = new AST_This({
                         'name': 'this',
                         'start': start,
@@ -2656,100 +2843,119 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                         'start': start,
                         'class': super_node.parent,
                         'method': method_name,
-                        'static': False,
+                        'static': super_is_static or False,
                         'args': method_args,
                         'end': prev()
                     }), True)
-                    S.in_parenthesized_expr = False
-                    return ret
-                c = get_class_in_scope(expr.expression)
-
-            if c:
-                # generate class call
-                funcname = expr
-
-                ret = subscripts(new AST_ClassCall({
+                S.in_parenthesized_expr = False
+                return ret
+            # Intercept object.__setattr__/object.__getattribute__/object.__delattr__
+            # and compile them to the appropriate bypass helpers.
+            if (is_node_type(expr.expression, AST_SymbolRef) and
+                    expr.expression.name is 'object' and
+                    expr.property in ['__setattr__', '__getattribute__', '__delattr__']):
+                helper_name = (
+                    'ρσ_object_setattr' if expr.property is '__setattr__' else
+                    ('ρσ_object_getattr' if expr.property is '__getattribute__' else 'ρσ_object_delattr')
+                )
+                args = func_call_list()
+                ret = subscripts(new AST_Call({
                     'start': start,
-                    "class": expr.expression,
-                    'method': funcname.property,
-                    "static": is_static_method(c, funcname.property),
-                    'args': func_call_list(),
+                    'expression': new AST_SymbolRef({
+                        'name': helper_name,
+                        'start': start,
+                        'end': start
+                    }),
+                    'args': args,
                     'end': prev()
                 }), True)
                 S.in_parenthesized_expr = False
                 return ret
-            elif is_node_type(expr, AST_SymbolRef):
-                tmp_ = expr.name
-                if tmp_ is "jstype":
-                    ret = new AST_UnaryPrefix({
-                        'start': start,
-                        'operator': "typeof",
-                        'expression': func_call_list()[0],
-                        'end': prev()
-                    })
-                    S.in_parenthesized_expr = False
-                    return ret
-                elif tmp_ is "isinstance":
-                    args = func_call_list()
-                    if args.length is not 2:
-                        croak('isinstance() must be called with exactly two arguments')
-                    ret = new AST_Binary({
-                        'start': start,
-                        'left': args[0],
-                        'operator': 'instanceof',
-                        'right': args[1],
-                        'end': prev()
-                    })
-                    S.in_parenthesized_expr = False
-                    return ret
-                elif tmp_ is "super":
-                    # Find the innermost enclosing class name
-                    current_class = None
-                    for v'var i = S.in_class.length - 1; i >= 0; i--':
-                        if S.in_class[i]:
-                            current_class = S.in_class[i]
-                            break
-                    if not current_class:
-                        croak('super() is only valid inside a class method')
-                    super_args = func_call_list()
-                    parent_expr = None
-                    if super_args.length is 0:
-                        # 0-arg form: use parent of current class
-                        for v'var s = S.classes.length - 1; s >= 0; s--':
-                            if has_prop(S.classes[s], current_class):
-                                parent_expr = S.classes[s][current_class].parent
-                                break
-                        if not parent_expr:
-                            croak('super() used in a class without a parent class')
-                    elif super_args.length is 2:
-                        # 2-arg form: super(ClassName, self) — use parent of ClassName
-                        cls_ref = super_args[0]
-                        cls_info = get_class_in_scope(cls_ref)
-                        if not cls_info or not cls_info.parent:
-                            croak('First argument to super() must be a subclass with a parent')
-                        parent_expr = cls_info.parent
-                    else:
-                        croak('super() takes 0 or 2 arguments (' + super_args.length + ' given)')
-                    super_node = new AST_Super({
-                        'start': start,
-                        'parent': parent_expr,
-                        'class_name': current_class,
-                        'end': prev()
-                    })
-                    S.in_parenthesized_expr = False
-                    # Call subscripts to handle subsequent .method(args) chain
-                    return subscripts(super_node, True)
-
-            # fall-through to basic function call
-            ret = subscripts(new AST_Call({
+            c = get_class_in_scope(expr.expression)
+        if c:
+            # generate class call
+            funcname = expr
+            ret = subscripts(new AST_ClassCall({
                 'start': start,
-                'expression': expr,
+                "class": expr.expression,
+                'method': funcname.property,
+                "static": is_static_method(c, funcname.property),
                 'args': func_call_list(),
-                'end': prev(),
-                'python_truthiness': S.scoped_flags.get('truthiness', False) and is_node_type(expr, AST_SymbolRef)
+                'end': prev()
             }), True)
             S.in_parenthesized_expr = False
             return ret
+        elif is_node_type(expr, AST_SymbolRef):
+            tmp_ = expr.name
+            if tmp_ is "jstype":
+                ret = new AST_UnaryPrefix({
+                    'start': start,
+                    'operator': "typeof",
+                    'expression': func_call_list()[0],
+                    'end': prev()
+                })
+                S.in_parenthesized_expr = False
+                return ret
+            elif tmp_ is "isinstance":
+                args = func_call_list()
+                if args.length is not 2:
+                    croak('isinstance() must be called with exactly two arguments')
+                ret = new AST_Binary({
+                    'start': start,
+                    'left': args[0],
+                    'operator': 'instanceof',
+                    'right': args[1],
+                    'end': prev()
+                })
+                S.in_parenthesized_expr = False
+                return ret
+            elif tmp_ is "super":
+                # Find the innermost enclosing class name
+                current_class = None
+                for v'var i = S.in_class.length - 1; i >= 0; i--':
+                    if S.in_class[i]:
+                        current_class = S.in_class[i]
+                        break
+                if not current_class:
+                    croak('super() is only valid inside a class method')
+                super_args = func_call_list()
+                parent_expr = None
+                if super_args.length is 0:
+                    # 0-arg form: use parent of current class
+                    for v'var s = S.classes.length - 1; s >= 0; s--':
+                        if has_prop(S.classes[s], current_class):
+                            parent_expr = S.classes[s][current_class].parent
+                            break
+                    # parent_expr stays None for root classes; handled at method-call time
+                    # (super().__new__(cls) in a root class → ρσ_object_new(cls))
+                elif super_args.length is 2:
+                    # 2-arg form: super(ClassName, self) — use parent of ClassName
+                    cls_ref = super_args[0]
+                    cls_info = get_class_in_scope(cls_ref)
+                    if not cls_info or not cls_info.parent:
+                        croak('First argument to super() must be a subclass with a parent')
+                    parent_expr = cls_info.parent
+                else:
+                    croak('super() takes 0 or 2 arguments (' + super_args.length + ' given)')
+                super_node = new AST_Super({
+                    'start': start,
+                    'parent': parent_expr,
+                    'class_name': current_class,
+                    'end': prev()
+                })
+                S.in_parenthesized_expr = False
+                # Call subscripts to handle subsequent .method(args) chain
+                return subscripts(super_node, True)
+        # fall-through to basic function call
+        ret = subscripts(new AST_Call({
+            'start': start,
+            'expression': expr,
+            'args': func_call_list(),
+            'end': prev(),
+            'python_truthiness': S.scoped_flags.get('truthiness', False) and is_node_type(expr, AST_SymbolRef)
+        }), True)
+        S.in_parenthesized_expr = False
+        return ret
 
     def get_attr(expr, allow_calls):
         next()
@@ -2816,6 +3022,11 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
     def maybe_unary(allow_calls):
         start = S.token
+        # JSX: detect <tag or <> in expression position
+        if S.scoped_flags.get('jsx', False) and is_('operator', '<'):
+            nxt = peek()
+            if nxt.type is 'name' or (nxt.type is 'operator' and nxt.value is '>'):
+                return subscripts(read_jsx_element(), allow_calls)
         if is_('operator', '@'):
             if S.parsing_decorator:
                 croak('Nested decorators are not allowed')
@@ -2843,6 +3054,162 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         val = expr_atom(allow_calls)
         return val
 
+    # -----[ JSX parsing ]-----
+
+    def read_jsx_tag_name():
+        # reads a tag name (identifier or dot-separated, e.g. "div", "MyComp", "Foo.Bar")
+        if not is_('name'):
+            croak('Expected JSX tag name')
+        name = S.token.value
+        next()
+        while is_('punc', '.'):
+            next()  # consume .
+            if not is_('name'):
+                croak('Expected identifier after . in JSX tag name')
+            name += '.' + S.token.value
+            next()
+        return name
+
+    def read_jsx_attr_name():
+        # reads an attribute name; hyphens are allowed (e.g. aria-label, data-id)
+        if not is_('name'):
+            croak('Expected JSX attribute name')
+        name = S.token.value
+        next()
+        while is_('operator', '-'):
+            next()  # consume -
+            if not is_('name'):
+                croak('Expected identifier after - in JSX attribute name')
+            name += '-' + S.token.value
+            next()
+        return name
+
+    def read_jsx_attrs():
+        # reads all attributes until > or /> is reached
+        props = []
+        while not is_('operator', '>') and not is_('operator', '/') and not is_('eof'):
+            if is_('punc', '{'):
+                # Spread attribute: {...expr}
+                next()  # consume {
+                if not is_('atom', 'Ellipsis'):
+                    croak('Expected ... in JSX spread attribute')
+                next()  # consume ...
+                expr = expression()
+                expect('}')
+                props.push(new AST_JSXSpread({'expression': expr, 'start': prev(), 'end': prev()}))
+            elif is_('name'):
+                attr_start = S.token
+                name = read_jsx_attr_name()
+                if is_('operator', '='):
+                    next()  # consume =
+                    if is_('string'):
+                        val = new AST_String({'value': S.token.value, 'start': S.token, 'end': S.token, 'quote': S.token.quote})
+                        next()
+                    elif is_('punc', '{'):
+                        next()  # consume {
+                        val = expression()
+                        expect('}')
+                    else:
+                        croak('Expected string or { in JSX attribute value')
+                else:
+                    val = None  # boolean attribute
+                props.push(new AST_JSXAttribute({'name': name, 'value': val, 'start': attr_start, 'end': prev()}))
+            else:
+                unexpected()
+        return props
+
+    def read_jsx_children_loop(close_tag):
+        # S.token is already the first child token (jsx_text, OP(<), PUNC({))
+        # JSX depth is currently >0 (entered before this call)
+        children = []
+        while True:
+            if S.token.type is 'jsx_text':
+                text = S.token.value
+                children.push(new AST_JSXText({'value': text, 'start': S.token, 'end': S.token}))
+                next()  # still in JSX mode
+            elif is_('operator', '<'):
+                # Nested element or closing tag: exit JSX mode to tokenize tag content
+                S.input.jsx_exit()
+                next()  # reads what follows < (/ or tag name)
+                if is_('operator', '/'):
+                    # Closing tag
+                    next()  # consume /
+                    if close_tag is None:
+                        # Fragment closing </> — next should be >
+                        if not is_('operator', '>'):
+                            croak('Expected > to close JSX fragment')
+                        return children  # S.token = OP(>), don't consume
+                    else:
+                        if not is_('name'):
+                            croak('Expected closing tag name')
+                        if S.token.value is not close_tag:
+                            croak('JSX closing tag mismatch: expected </' + close_tag + '>, got </' + S.token.value + '>')
+                        next()  # consume tag name
+                        if not is_('operator', '>'):
+                            croak('Expected > in closing JSX tag')
+                        return children  # S.token = OP(>), don't consume
+                else:
+                    # Nested element: S.token is first token of tag (or > for fragment)
+                    child = read_jsx_element_inner()
+                    children.push(child)
+                    # S.token = OP(>) — child's closing >, re-enter JSX mode then consume
+                    S.input.jsx_enter()
+                    next()  # consume child's >, read next sibling in JSX mode
+            elif is_('punc', '{'):
+                # Expression container
+                S.input.jsx_exit()
+                next()  # consume {
+                expr = expression()
+                if not is_('punc', '}'):
+                    croak('Expected } to close JSX expression')
+                # Re-enter JSX mode BEFORE consuming } so next sibling reads in JSX mode
+                S.input.jsx_enter()
+                next()  # consume }, read next sibling in JSX mode
+                children.push(new AST_JSXExprContainer({'expression': expr, 'start': prev(), 'end': prev()}))
+            elif is_('eof'):
+                croak('Unterminated JSX element')
+            else:
+                unexpected()
+
+    def read_jsx_element_inner():
+        # Called when S.token is NAME(tag) or OP(>) for fragment
+        # NOT in JSX mode when entering
+        start = S.prev  # the < token (already consumed)
+        if is_('operator', '>'):
+            # Fragment: <>...</>
+            S.input.jsx_enter()
+            next()  # consume >, first child in JSX mode
+            children = read_jsx_children_loop(None)
+            # S.token = OP(>) — closing >
+            return new AST_JSXFragment({'start': start, 'children': children, 'end': S.token})
+        else:
+            tag = read_jsx_tag_name()
+            props = read_jsx_attrs()
+            if is_('operator', '/'):
+                next()  # consume /
+                # S.token = OP(>) — self-closing
+                return new AST_JSXElement({'start': start, 'tag': tag, 'props': props, 'children': [], 'self_closing': True, 'end': S.token})
+            else:
+                if not is_('operator', '>'):
+                    croak('Expected > or /> in JSX element')
+                S.input.jsx_enter()
+                next()  # consume >, first child in JSX mode
+                children = read_jsx_children_loop(tag)
+                # S.token = OP(>) — closing >
+                return new AST_JSXElement({'start': start, 'tag': tag, 'props': props, 'children': children, 'self_closing': False, 'end': S.token})
+
+    def read_jsx_element():
+        # S.token = OP(<) — the opening <
+        start = S.token
+        next()  # consume <, reads tag name or > for fragment (normal mode)
+        el = read_jsx_element_inner()
+        # S.token = OP(>) — closing >, consume it and return to normal mode
+        next()
+        el.end = prev()
+        return el
+
+    # -----[ end JSX parsing ]-----
+
     def make_unary(ctor, op, expr, is_parenthesized):
         return new ctor({
             'operator': op,
@@ -2874,6 +3241,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'right': right,
                 'end': right.end,
                 'overloaded': S.scoped_flags.get('overload_operators', False),
+                'strict_arith': S.scoped_flags.get('overload_operators', False) and S.scoped_flags.get('strict_arithmetic', True),
                 'python_truthiness': S.scoped_flags.get('truthiness', False) and (op is '&&' or op is '||')
             })
             return expr_op(ret, min_prec, no_in)
@@ -2955,6 +3323,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             })
             if S.scoped_flags.get('overload_operators', False) and val is not '=':
                 asgn.overloaded = True
+                asgn.strict_arith = S.scoped_flags.get('strict_arithmetic', True)
             return asgn
         return left
 
@@ -3168,9 +3537,8 @@ def parse(text, options):
             'get': def (name, defval):
                 for v'var i = this.stack.length - 1; i >= 0; i--':
                     d = this.stack[i]
-                    q = d[name]
-                    if q:
-                        return q
+                    if has_prop(d, name):
+                        return d[name]
                 return defval
             ,
             'set': def (name, val): this.stack[-1][name] = val;,