rapydscript-ns 0.8.4 → 0.9.0

package/src/parse.pyj

@@ -31,7 +31,7 @@ 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, 'jsx':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():
@@ -144,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']
 
@@ -512,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
@@ -542,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', ':')):
@@ -1063,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
@@ -1189,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
@@ -2134,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
@@ -2145,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,
@@ -2201,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
@@ -3178,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)
@@ -3259,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
 
@@ -3472,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;,

package/src/string_interpolation.pyj

@@ -1,72 +1,72 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-from __python__ import hash_literals
-
-def quoted_string(x):
-    return '"' + x.replace(/\\/g, '\\\\').replace(/"/g, r'\"').replace(/\n/g, '\\n') + '"'
-
-def render_markup(markup):
-    pos, key = 0, ''
-    while pos < markup.length:
-        ch = markup[pos]
-        if ch is '!' or ch is ':':
-            break
-        key += ch
-        pos += 1
-    fmtspec = markup[pos:]
-    prefix = ''
-    if key.endsWith('='):
-        prefix=key
-        key = key[:-1]
-    return 'ρσ_str.format("' + prefix + '{' + fmtspec + '}", ' + key + ')'
-
-
-def interpolate(template, raise_error):
-    pos = in_brace = 0
-    markup = ''
-    ans = v'[""]'
-    while pos < template.length:
-        ch = template[pos]
-        if in_brace:
-            if ch is '{':
-                in_brace += 1
-                markup += '{'
-            elif ch is '}':
-                in_brace -= 1
-                if in_brace > 0:
-                    markup += '}'
-                else:
-                    ans.push(v'[markup]')
-                    ans.push('')
-            else:
-                markup += ch
-        else:
-            if ch is '{':
-                if template[pos+1] is '{':
-                    pos += 1
-                    ans[-1] += '{'
-                else:
-                    in_brace = 1
-                    markup = ''
-            elif ch is '}':
-                if template[pos+1] is '}':
-                    pos += 1
-                    ans[-1] += '}'
-                else:
-                    raise_error("f-string: single '}' is not allowed")
-            else:
-                ans[-1] += ch
-
-        pos += 1
-
-    if in_brace:
-        raise_error("expected '}' before end of string")
-
-    if ans[-1] is '+':
-        ans[-1] = ''
-    for v'var i = 0; i < ans.length; i++':
-        if jstype(ans[i]) is 'string':
-            ans[i] = quoted_string(ans[i])
-        else:
-            ans[i] = '+' + render_markup.apply(this, ans[i]) + '+'
-    return ans.join('')
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+from __python__ import hash_literals
+
+def quoted_string(x):
+    return '"' + x.replace(/\\/g, '\\\\').replace(/"/g, r'\"').replace(/\n/g, '\\n') + '"'
+
+def render_markup(markup):
+    pos, key = 0, ''
+    while pos < markup.length:
+        ch = markup[pos]
+        if ch is '!' or ch is ':':
+            break
+        key += ch
+        pos += 1
+    fmtspec = markup[pos:]
+    prefix = ''
+    if key.endsWith('='):
+        prefix=key
+        key = key[:-1]
+    return 'ρσ_str.format("' + prefix + '{' + fmtspec + '}", ' + key + ')'
+
+
+def interpolate(template, raise_error):
+    pos = in_brace = 0
+    markup = ''
+    ans = v'[""]'
+    while pos < template.length:
+        ch = template[pos]
+        if in_brace:
+            if ch is '{':
+                in_brace += 1
+                markup += '{'
+            elif ch is '}':
+                in_brace -= 1
+                if in_brace > 0:
+                    markup += '}'
+                else:
+                    ans.push(v'[markup]')
+                    ans.push('')
+            else:
+                markup += ch
+        else:
+            if ch is '{':
+                if template[pos+1] is '{':
+                    pos += 1
+                    ans[-1] += '{'
+                else:
+                    in_brace = 1
+                    markup = ''
+            elif ch is '}':
+                if template[pos+1] is '}':
+                    pos += 1
+                    ans[-1] += '}'
+                else:
+                    raise_error("f-string: single '}' is not allowed")
+            else:
+                ans[-1] += ch
+
+        pos += 1
+
+    if in_brace:
+        raise_error("expected '}' before end of string")
+
+    if ans[-1] is '+':
+        ans[-1] = ''
+    for v'var i = 0; i < ans.length; i++':
+        if jstype(ans[i]) is 'string':
+            ans[i] = quoted_string(ans[i])
+        else:
+            ans[i] = '+' + render_markup.apply(this, ans[i]) + '+'
+    return ans.join('')

package/src/tokenizer.pyj

@@ -90,7 +90,7 @@ KEYWORDS_ATOM = "False None True"
 # see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar
 RESERVED_WORDS = ("break case class catch const continue debugger default delete do else export extends"
 " finally for function if import in instanceof new return switch this throw try typeof var void"
-" while with yield enum implements static private package let public protected interface await null true false" )
+" while with yield implements static private package let public protected interface await null true false" )
 
 KEYWORDS_BEFORE_EXPRESSION = "return yield new del raise elif else if"
 
@@ -104,7 +104,7 @@ IDENTIFIER_PAT = /^[a-z_$][_a-z0-9$]*$/i
 
 def is_string_modifier(val):
     for ch in val:
-        if 'vrufVRUF'.indexOf(ch) is -1:
+        if 'vrufbVRUFB'.indexOf(ch) is -1:
             return False
     return True
 
@@ -363,6 +363,8 @@ def tokenizer(raw_text, filename):
                 return False
             elif ch is '.':
                 return (has_dot = True) if not has_dot and not has_x and not has_e else False
+            elif ch is 'j' or ch is 'J':
+                return False  # imaginary suffix — stop here; handled after loop
             return is_alphanumeric_char(ch.charCodeAt(0))
         )
         if prefix:
@@ -370,6 +372,9 @@ def tokenizer(raw_text, filename):
 
         valid = parse_js_number(num)
         if not isNaN(valid):
+            if peek() is 'j' or peek() is 'J':
+                next()
+                return token("imaginary", valid)
             return token("num", valid)
         else:
             parse_error("Invalid syntax: " + num)
@@ -698,7 +703,7 @@ def tokenizer(raw_text, filename):
 
         if is_identifier_start(code):
             tok = read_word()
-            if '\'"'.indexOf(peek()) is not -1 and is_string_modifier(tok.value):
+            if (peek() is "'" or peek() is '"') and is_string_modifier(tok.value):
                 mods = tok.value.toLowerCase()
                 start_pos_for_string = S.tokpos
                 stok = read_string(mods.indexOf('r') is not -1, mods.indexOf('v') is not -1)
@@ -707,7 +712,7 @@ def tokenizer(raw_text, filename):
                     tok.col += start_pos_for_string - tok.pos
                     return handle_interpolated_string(stok.value, tok)
                 tok.value = stok.value
-                tok.type = stok.type
+                tok.type = 'bytes_literal' if mods.indexOf('b') is not -1 else stok.type
             return tok
 
         parse_error("Unexpected character «" + ch + "»")