rapydscript-ng 0.8.2 → 0.8.4

package/src/parse.pyj

@@ -1,33 +1,110 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: readfile, writefile, stat_file, sha1sum, ast_from_json, ast_to_json, make_lazy_ast_module, decode_cache, encode_cache
+# globals: readfile, writefile, stat_file, sha1sum, ast_from_json,
+# globals: ast_to_json, make_lazy_ast_module, decode_cache, encode_cache
 from __python__ import hash_literals
 
 from ast import (
-AST_ArgsDef, AST_Array, AST_Assign, AST_Binary, AST_BlockStatement, AST_Break,
-AST_Call, AST_CallArg, AST_CallArgs, AST_Catch, AST_Class, AST_ClassCall, AST_Conditional,
-AST_Constant, AST_Continue, AST_DWLoop, AST_Debugger, AST_Decorator,
-AST_Definitions, AST_DictComprehension, AST_Directive, AST_Do, AST_Dot,
-AST_Else, AST_EmptyStatement, AST_Except, AST_ExpressiveObject, AST_False, AST_Finally,
-AST_ForIn, AST_ForJS, AST_Function, AST_GeneratorComprehension, AST_Hole,
-AST_If, AST_Import, AST_ImportedVar, AST_Imports, AST_ListComprehension,
-AST_Method, AST_New, AST_Null, AST_Number, AST_Object, AST_ObjectKeyVal,
-AST_PropAccess, AST_RegExp, AST_Return, AST_Scope, AST_Set,
-AST_SetComprehension, AST_SetItem, AST_Seq, AST_SimpleStatement, AST_Splice,
-AST_String, AST_Sub, AST_ItemAccess, AST_SymbolAlias,
-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, is_node_type, TreeWalker
+    AST_ArgsDef,
+    AST_Array,
+    AST_Assign,
+    AST_Binary,
+    AST_BlockStatement,
+    AST_Break,
+    AST_Call,
+    AST_CallArg,
+    AST_CallArgs,
+    AST_Catch,
+    AST_Class,
+    AST_ClassCall,
+    AST_Conditional,
+    AST_Constant,
+    AST_Continue,
+    AST_DWLoop,
+    AST_Debugger,
+    AST_Decorator,
+    AST_Definitions,
+    AST_DictComprehension,
+    AST_Directive,
+    AST_Do,
+    AST_Dot,
+    AST_Else,
+    AST_EmptyStatement,
+    AST_Except,
+    AST_ExpressiveObject,
+    AST_False,
+    AST_Finally,
+    AST_ForIn,
+    AST_ForJS,
+    AST_Function,
+    AST_GeneratorComprehension,
+    AST_Hole,
+    AST_If,
+    AST_Import,
+    AST_ImportedVar,
+    AST_Imports,
+    AST_ListComprehension,
+    AST_Method,
+    AST_New,
+    AST_Null,
+    AST_Number,
+    AST_Object,
+    AST_ObjectKeyVal,
+    AST_PropAccess,
+    AST_RegExp,
+    AST_Return,
+    AST_Scope,
+    AST_Set,
+    AST_SetComprehension,
+    AST_SetItem,
+    AST_Seq,
+    AST_SimpleStatement,
+    AST_Splice,
+    AST_String,
+    AST_Sub,
+    AST_ItemAccess,
+    AST_SymbolAlias,
+    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,
+    is_node_type,
+    TreeWalker
 )
 from errors import SyntaxError, ImportError
 from tokenizer import tokenizer, is_token, RESERVED_WORDS
-from utils import make_predicate, array_to_hash, defaults, has_prop, cache_file_name
+from utils import (
+    make_predicate, array_to_hash, defaults, has_prop, cache_file_name
+)
 
 
 COMPILER_VERSION = '__COMPILER_VERSION__'
-PYTHON_FLAGS = {'dict_literals': True, 'overload_getitem': True, 'bound_methods': True, 'hash_literals': True}
+PYTHON_FLAGS = {
+    'dict_literals': True,
+    'overload_getitem': True,
+    'bound_methods': True,
+    'hash_literals': True,
+}
 CACHE_VERSION = 1
 
 
@@ -50,28 +127,19 @@ NATIVE_CLASSES = {
     'SyntaxError': {},
     'TypeError': {},
     'URIError': {},
-    'Object': {
-        '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': static_predicate('fromCharCode')
-    },
-    'Array': {
-        'static': static_predicate('isArray from of')
-    },
+    'Object': {'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': static_predicate('fromCharCode')},
+    'Array': {'static': static_predicate('isArray from of')},
     'Function': {},
-    'Date': {
-        'static': static_predicate('UTC now parse')
-    },
-    'ArrayBuffer': {
-        'static': static_predicate('isView transfer')
-    },
+    'Date': {'static': static_predicate('UTC now parse')},
+    'ArrayBuffer': {'static': static_predicate('isView transfer')},
     'DataView': {},
     'Float32Array': {},
     'Float64Array': {},
@@ -87,9 +155,7 @@ NATIVE_CLASSES = {
     'Proxy': {},
     'Set': {},
     'WeakSet': {},
-    'Promise': {
-        'static': static_predicate('all race reject resolve')
-    },
+    'Promise': {'static': static_predicate('all race reject resolve')},
     'WebSocket': {},
     'XMLHttpRequest': {},
     'TextEncoder': {},
@@ -141,7 +207,9 @@ 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', 'string', 'regexp', 'name', 'js'
+])
 
 compile_time_decorators = ['staticmethod', 'external', 'property']
 
@@ -164,7 +232,10 @@ def has_setter_decorator(decorators, name):
     remove = v'[]'
     for v'var i = 0; i < decorators.length; i++':
         s = decorators[i]
-        if is_node_type(s, AST_Dot) and is_node_type(s.expression, AST_SymbolRef) and s.expression.name is name and s.property is 'setter':
+        if is_node_type(s, AST_Dot) and is_node_type(
+            s.expression,
+            AST_SymbolRef
+        ) and s.expression.name is name and s.property is 'setter':
             remove.push(i)
     if remove.length:
         remove.reverse()
@@ -175,7 +246,11 @@ def has_setter_decorator(decorators, name):
 
 
 # -----[ Parser ]-----
-def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_ids, imported_modules, importing_modules, options):
+def create_parser_ctx(
+    S, import_dirs, module_id, baselib_items,
+    imported_module_ids, imported_modules,
+    importing_modules, options
+):
     def next():
         S.prev = S.token
         if S.peeked.length:
@@ -197,10 +272,17 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         return S.prev
 
     def croak(msg, line, col, pos, is_eof):
-        # note: undefined means nothing was passed in, None/null means a null value was passed in
+        # note: undefined means nothing was passed in,
+        # None/null means a null value was passed in
         ctx = S.input.context()
-        raise new SyntaxError(msg, ctx.filename, (line if line is not undefined else ctx.tokline),
-                 (col if col is not undefined else ctx.tokcol), (pos if pos is not undefined else ctx.tokpos), is_eof)
+        raise new SyntaxError(
+            msg,
+            ctx.filename,
+            (line if line is not undefined else ctx.tokline),
+            (col if col is not undefined else ctx.tokcol),
+            (pos if pos is not undefined else ctx.tokpos),
+            is_eof
+        )
 
     def token_error(token, msg):
         is_eof = token.type is 'eof'
@@ -209,9 +291,13 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
     def unexpected(token):
         if token is undefined:
             token = S.token
-        token_error(token, 'Unexpected token: ' + token.type + ' «' + token.value + '»')
+        token_error(
+            token,
+            'Unexpected token: ' + token.type + ' «' + token.value + '»'
+        )
 
-    # --- Error recovery (only active when options.recover_errors is True) --------
+    # --- Error recovery (only active when
+    # options.recover_errors is True) --------
     # These helpers let the LSP obtain a usable AST from a file that contains
     # syntax errors. They are never invoked on the normal compile path, so they
     # cannot introduce a performance or behavior regression there.
@@ -229,7 +315,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         # Resynchronize after a syntax error: always consume at least one token
         # (guaranteeing forward progress) then stop at the start of the next
         # logical line, a block dedent, or eof. next() may itself raise a
-        # tokenizer level SyntaxError (e.g. an unterminated string on the skipped
+        # tokenizer level SyntaxError (e.g. an unterminated string on the
+        # skipped
         # line); such errors are recorded and skipping continues. The tokenizer
         # advances its position for every such error (and never raises for an
         # unexpected character in recover mode), so this loop always terminates.
@@ -249,8 +336,12 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
     def expect_token(type, val):
         if is_(type, val):
             return next()
-        token_error(S.token, 'Unexpected token ' + S.token.type + ' «' + S.token.value + '»' +
-                    ', expected ' + type + ' «' + val + '»')
+        token_error(
+            S.token,
+            'Unexpected token ' + S.token.type +
+            ' «' + S.token.value + '»' +
+            ', expected ' + type + ' «' + val + '»'
+        )
 
     def expect(punc):
         return expect_token('punc', punc)
@@ -277,11 +368,17 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         # Get the named functions and classes
         if Array.isArray(body):
             for obj in body:
-                if is_node_type(obj, AST_Function) or is_node_type(obj, AST_Class):
+                if is_node_type(
+                    obj,
+                    AST_Function
+                ) or is_node_type(obj, AST_Class):
                     if obj.name:
                         ans.push(obj.name.name)
                     else:
-                        token_error(obj.start, 'Top-level functions must have names')
+                        token_error(
+                            obj.start,
+                            'Top-level functions must have names'
+                        )
                 else:
                     # skip inner scopes
                     if is_node_type(obj, AST_Scope):
@@ -291,8 +388,13 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                         if opt:
                             ans = ans.concat(scan_for_top_level_callables(opt))
 
-                        if is_node_type(opt, AST_Assign) and not (is_node_type(opt.right, AST_Scope)):
-                            ans = ans.concat(scan_for_top_level_callables(opt.right))
+                        if is_node_type(
+                            opt,
+                            AST_Assign
+                        ) and not (is_node_type(opt.right, AST_Scope)):
+                            ans = ans.concat(
+                                scan_for_top_level_callables(opt.right)
+                            )
 
         elif body.body:
             # recursive descent into wrapper statements that contain body blocks
@@ -311,7 +413,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
     def scan_for_local_vars(body):
         """
-        Pick out all variables being assigned to from within this scope, we'll mark them as local
+        Pick out all variables being assigned to from within this scope,
+        we'll mark them as local
 
         body        body to be scanned
         """
@@ -373,7 +476,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     if opt:
                         extend(scan_for_local_vars(opt))
 
-                    if is_node_type(opt, AST_Assign) and not (is_node_type(opt.right, AST_Scope)):
+                    if is_node_type(
+                        opt,
+                        AST_Assign
+                    ) and not (is_node_type(opt.right, AST_Scope)):
                         extend(scan_for_local_vars(opt.right))
 
                 # pick up iterators from loops
@@ -399,7 +505,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 is_compound_assign = False
                 for lhs in body.traverse_chain()[0]:
                     add_assign_lhs(lhs)
-                    if is_node_type(lhs, AST_Seq) or is_node_type(lhs, AST_Array):
+                    if is_node_type(
+                        lhs,
+                        AST_Seq
+                    ) or is_node_type(lhs, AST_Array):
                         is_compound_assign = True
                         break
                 if is_compound_assign:
@@ -454,19 +563,28 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
     @embed_tokens
     async def statement():
-        # From Kovid: The next three lines were a hack to try to support statements
+        # From Kovid: The next three lines were a hack to try to support
+        # statements
         # starting with a regexp literal. However, it did not work, for example:
         # echo 'f=1\n/asd/.test()' | rs -> parse error
-        # So we just accept that this cannot be supported in RS, and avoid hacks that mess
+        # So we just accept that this cannot be supported in RS, and avoid
+        # hacks that mess
         # with the internal state of S. In any case,
         # statements starting with a literal are very rare.
         if S.token.type is 'operator' and S.token.value.substr(0, 1) is '/':
-            token_error(S.token, 'RapydScript does not support statements starting with regexp literals')
+            token_error(
+                S.token,
+                'RapydScript does not support statements starting with'
+                ' regexp literals'
+            )
 
         S.statement_starting_token = S.token
         tmp_ = S.token.type
         p = prev()
-        if p and not S.token.nlb and ATOMIC_START_TOKEN[p.type] and not is_('punc', ':'):
+        if p and not S.token.nlb and ATOMIC_START_TOKEN[p.type] and not is_(
+            'punc',
+            ':'
+        ):
             unexpected()
         if tmp_ is 'string':
             return await simple_statement()
@@ -476,7 +594,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             return new AST_Directive({
                 'value': tmp_
             })
-        elif tmp_ is 'num' or tmp_ is 'regexp' or tmp_ is 'operator' or tmp_ is 'atom' or tmp_ is 'js':
+        elif (tmp_ is 'num' or tmp_ is 'regexp' or tmp_ is 'operator'
+              or tmp_ is 'atom' or tmp_ is 'js'):
             return await simple_statement()
         elif tmp_ is 'punc':
             tmp_ = S.token.value
@@ -491,11 +610,16 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 return await simple_statement()
             elif tmp_ is ';':
                 next()
-                return new AST_EmptyStatement({'stype': ';', 'start': prev(), 'end': prev()})
+                return new AST_EmptyStatement({
+                    'stype': ';', 'start': prev(), 'end': prev()
+                })
             else:
                 unexpected()
         elif tmp_ is 'name':
-            if (is_token(peek(), 'punc', ':')) token_error(peek(), 'invalid syntax, colon not allowed here')
+            if (is_token(peek(), 'punc', ':')) token_error(
+                peek(),
+                'invalid syntax, colon not allowed here'
+            )
             return await simple_statement()
         elif tmp_ is 'keyword':
             tmp_ = S.token.value
@@ -514,7 +638,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     expect_token('keyword', 'while')
                     tmp = await expression(True)
                     if is_node_type(tmp, AST_Assign):
-                        croak('Assignments in do loop conditions are not allowed')
+                        croak(
+                            'Assignments in do loop conditions are not allowed'
+                        )
                     semicolon()
                     return tmp
                 )()
@@ -525,7 +651,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             elif tmp_ is 'while':
                 while_cond = await expression(True)
                 if is_node_type(while_cond, AST_Assign):
-                    croak('Assignments in while loop conditions are not allowed')
+                    croak(
+                        'Assignments in while loop conditions are not allowed'
+                    )
                 if not is_('punc', ':'):
                     croak('Expected a colon after the while statement')
                 while_body = await in_loop(statement)
@@ -581,12 +709,17 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 if is_('punc', ','):
                     next()
                     msg = await expression(False)
-                return new AST_Assert({'start': start, 'condition': cond, 'message': msg, 'end': prev()})
+                return new AST_Assert({
+                    'start': start, 'condition': cond,
+                    'message': msg, 'end': prev()
+                })
             elif tmp_ is 'if':
                 return await if_()
             elif tmp_ is 'pass':
                 semicolon()
-                return new AST_EmptyStatement({'stype': 'pass', 'start': prev(), 'end': prev()})
+                return new AST_EmptyStatement({
+                    'stype': 'pass', 'start': prev(), 'end': prev()
+                })
             elif tmp_ is 'return':
                 if S.in_function is 0:
                     croak("'return' outside of function")
@@ -644,7 +777,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             if is_('keyword', 'as'):
                 next()
                 alias = as_symbol(AST_SymbolAlias)
-            clauses.push(new AST_WithClause({'expression': expr, 'alias': alias}))
+            clauses.push(new AST_WithClause({
+                'expression': expr, 'alias': alias
+            }))
             if is_('punc', ','):
                 next()
                 continue
@@ -695,8 +830,12 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             init = await expression(True, True)
             # standardize AST_Seq into array now for consistency
             if is_node_type(init, AST_Seq):
-                if is_node_type(init.car, AST_SymbolRef) and is_node_type(init.cdr, AST_SymbolRef):
-                    # Optimization to prevent runtime call to ρσ_flatten when init is simply (a, b)
+                if is_node_type(
+                    init.car,
+                    AST_SymbolRef
+                ) and is_node_type(init.cdr, AST_SymbolRef):
+                    # Optimization to prevent runtime call to ρσ_flatten
+                    # when init is simply (a, b)
                     tmp = init.to_array()
                 else:
                     tmp = [init]
@@ -708,7 +847,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
             if is_('operator', 'in'):
                 if is_node_type(init, AST_Var) and init.definitions.length > 1:
-                    croak('Only one variable declaration allowed in for..in loop')
+                    croak(
+                        'Only one variable declaration allowed in for..in loop'
+                    )
                 next()
                 return await for_in(init, list_comp)
 
@@ -763,13 +904,15 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
         elif is_node_type(expr, AST_Dot):
             referenced_path = []
-            # this one is for detecting classes inside modules and eventually nested classes
+            # this one is for detecting classes inside modules and
+            # eventually nested classes
             while is_node_type(expr, AST_Dot):
                 referenced_path.unshift(expr.property)
                 expr = expr.expression
             if is_node_type(expr, AST_SymbolRef):
                 referenced_path.unshift(expr.name)
-                # now 'referenced_path' should contain the full path of potential class
+                # now 'referenced_path' should contain the full path
+                # of potential class
                 if len(referenced_path) > 1:
                     class_name = referenced_path.join('.')
                     for s in range(S.classes.length - 1, -1, -1):
@@ -779,17 +922,29 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
     def import_error(message):
         ctx = S.input.context()
-        raise new ImportError(message, ctx.filename, ctx.tokline, ctx.tokcol, ctx.tokpos)
+        raise new ImportError(
+            message,
+            ctx.filename,
+            ctx.tokline,
+            ctx.tokcol,
+            ctx.tokpos
+        )
 
     async def do_import(key):
         if has_prop(imported_modules, key):
             return
-        # Circular import check must come BEFORE loading_promises so we detect cycles
+        # Circular import check must come BEFORE loading_promises so we
+        # detect cycles
         # even when the same module is being loaded by a parallel chain.
         if has_prop(importing_modules, key) and importing_modules[key]:
-            import_error('Detected a recursive import of: ' + key + ' while importing: ' + module_id)
-        # If a parallel chain is already loading this module, wait for it instead of
-        # starting a duplicate load.  loading_promises is shared across the entire
+            import_error(
+                'Detected a recursive import of: ' + key +
+                ' while importing: ' + module_id
+            )
+        # If a parallel chain is already loading this module, wait for it
+        # instead of
+        # starting a duplicate load.  loading_promises is shared across
+        # the entire
         # compilation via options.loading_promises.
         loading_promises = options.loading_promises
         if has_prop(loading_promises, key):
@@ -798,8 +953,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
         # Register this load BEFORE the first await so that any parallel caller
         # that reaches this point sees the in-progress entry and waits.
-        # Use a single-element list to capture the resolve function from the Promise
-        # executor without needing nonlocal (mutating a container, not rebinding).
+        # Use a single-element list to capture the resolve function from
+        # the Promise
+        # executor without needing nonlocal (mutating a container,
+        # not rebinding).
         _rfn = v'[null]'
 
         def _capture_resolve(resolve):
@@ -813,20 +970,37 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 await do_import(package_module_id)
 
             if options.for_linting:
-                imported_modules[key] = {'is_cached': True, 'classes': {}, 'module_id': key, 'exports': [],
-                                         'nonlocalvars': [], 'baselib': {}, 'outputs': {}, 'discard_asserts': options.discard_asserts}
+                imported_modules[key] = {
+                    'is_cached': True,
+                    'classes': {},
+                    'module_id': key,
+                    'exports': [],
+                    'nonlocalvars': [],
+                    'baselib': {},
+                    'outputs': {},
+                    'discard_asserts': options.discard_asserts,
+                }
                 return
 
-            # stat_file returns {mtimeMs, content?}.  For real filesystems mtimeMs is a
-            # number and content is absent; for virtual filesystems content holds the
+            # stat_file returns {mtimeMs, content?}.  For real filesystems
+            # mtimeMs is a
+            # number and content is absent; for virtual filesystems
+            # content holds the
             # already-read source to avoid a double read.
             async def safe_stat(base_path):  # noqa
-                for i, path in enumerate([base_path + '.pyj', base_path + '/__init__.pyj']):
+                for i, path in enumerate([
+                    base_path + '.pyj', base_path + '/__init__.pyj'
+                ]):
                     try:
                         st = await stat_file(path)
-                        return [st.mtimeMs, path, st.content if has_prop(st, 'content') else None]
+                        return [
+                            st.mtimeMs,
+                            path,
+                            st.content if has_prop(st, 'content') else None,
+                        ]
                     except as e:
-                        if e.code is 'ENOENT' or e.code is 'EPERM' or e.code is 'EACCESS':
+                        if (e.code is 'ENOENT' or e.code is 'EPERM'
+                                or e.code is 'EACCESS'):
                             if i is 1:
                                 return None, None, None
                         if i is 1:
@@ -837,15 +1011,24 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
             for location in import_dirs:
                 if location:
-                    file_mtime, filename, prefetched_src = await safe_stat(location + '/' + modpath)
+                    file_mtime, filename, prefetched_src = await safe_stat(
+                        location + '/' + modpath
+                    )
                     if filename is not None:
                         break
             if filename is None:
-                import_error("Failed Import: '" + key + "' module doesn't exist in any of the import directories: " + import_dirs.join(':'))
-
-            # Read the cache file.  I/O starts here; any CPU work done before the
+                import_error(
+                    "Failed Import: '" + key +
+                    "' module doesn't exist in any of the import"
+                    ' directories: ' + import_dirs.join(':')
+                )
+
+            # Read the cache file.  I/O starts here; any CPU work done
+            # before the
             # await can overlap with the disk read.
-            cache_read = readfile(cache_file_name(filename, options.module_cache_dir))
+            cache_read = readfile(
+                cache_file_name(filename, options.module_cache_dir)
+            )
 
             cached = None
             ast_json_str = None
@@ -858,21 +1041,31 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 cached = None
 
             srchash = src_code = None
-            cache_ok = cached and cached.v is CACHE_VERSION and cached.compiler_version is COMPILER_VERSION
-            if cache_ok and file_mtime is not None and cached.mtime is not None and cached.mtime is file_mtime:
-                # Fast path: mtime matches — source file is unchanged, skip reading and hashing it
+            cache_ok = (
+                cached and cached.v is CACHE_VERSION
+                and cached.compiler_version is COMPILER_VERSION
+            )
+            if (cache_ok and file_mtime is not None
+                    and cached.mtime is not None
+                    and cached.mtime is file_mtime):
+                # Fast path: mtime matches — source file is unchanged,
+                # skip reading and hashing it
                 srchash = cached.signature
             else:
-                # Need source content to validate with sha1sum (or to re-parse on miss)
+                # Need source content to validate with sha1sum (or to
+                # re-parse on miss)
                 src_code = prefetched_src or await readfile(filename, 'utf-8')
                 srchash = sha1sum(src_code)
                 if not cache_ok or cached.signature is not srchash:
                     cached = None
 
             if cached is not None:
-                # Load all deps in parallel — cached module deps have been pre-validated as
-                # non-circular so Promise.all is safe.  The loading_promises dict ensures
-                # that if two parallel chains try to load the same dep, only one actually
+                # Load all deps in parallel — cached module deps have been
+                # pre-validated as
+                # non-circular so Promise.all is safe.  The loading_promises
+                # dict ensures
+                # that if two parallel chains try to load the same dep,
+                # only one actually
                 # does the work; the other waits.
                 pending = v'[]'
                 for ikey in cached.imported_module_ids:
@@ -880,11 +1073,17 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                         pending.push(do_import(ikey))
                 if pending.length > 0:
                     await Promise.all(pending)
-                # Reconstruct classes dict from the simplified cache (no full AST nodes).
+                # Reconstruct classes dict from the simplified cache
+                # (no full AST nodes).
                 classes = {}
                 for cname in Object.keys(cached.classes or {}):
                     ci = cached.classes[cname]
-                    classes[cname] = {'name': {'name': cname}, 'static': ci.static or {}, 'bound': ci.bound or [], 'classvars': ci.classvars or {}}
+                    classes[cname] = {
+                        'name': {'name': cname},
+                        'static': ci.static or {},
+                        'bound': ci.bound or [],
+                        'classvars': ci.classvars or {},
+                    }
                 meta = {
                     'module_id': key,
                     'filename': filename,
@@ -901,21 +1100,25 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 module = make_lazy_ast_module(ast_json_str, meta)
                 imported_modules[key] = module
             else:
-                await parse(src_code, {
-                    'filename': filename,
-                    'toplevel': None,
-                    'basedir': options.basedir,
-                    'libdir': options.libdir,
-                    'import_dirs': options.import_dirs,
-                    'module_id': key,
-                    'imported_modules': imported_modules,
-                    'importing_modules': importing_modules,
-                    'discard_asserts': options.discard_asserts,
-                    'module_cache_dir': options.module_cache_dir,
-                    '_src_hash': srchash,
-                    '_file_mtime': file_mtime,
-                    'loading_promises': loading_promises,
-                })  # This function will add the module to imported_modules itself
+                await parse(
+                    src_code,
+                    {
+                        'filename': filename,
+                        'toplevel': None,
+                        'basedir': options.basedir,
+                        'libdir': options.libdir,
+                        'import_dirs': options.import_dirs,
+                        'module_id': key,
+                        'imported_modules': imported_modules,
+                        'importing_modules': importing_modules,
+                        'discard_asserts': options.discard_asserts,
+                        'module_cache_dir': options.module_cache_dir,
+                        '_src_hash': srchash,
+                        '_file_mtime': file_mtime,
+                        'loading_promises': loading_promises,
+                    }
+                )
+        # This function will add the module to imported_modules itself
         finally:
             del loading_promises[key]
             if _rfn[0]:
@@ -951,7 +1154,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     else:
                         continue
                 break
-        return new AST_EmptyStatement({'stype': 'scoped_flags', 'start': prev(), 'end': prev()})
+        return new AST_EmptyStatement({
+            'stype': 'scoped_flags', 'start': prev(), 'end': prev()
+        })
 
     async def import_(from_import):
         ans = new AST_Imports({'imports': []})
@@ -1001,8 +1206,14 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     exports[symdef.name] = True
                 while True:
                     aname = as_symbol(AST_ImportedVar)
-                    if not options.for_linting and not has_prop(exports, aname.name):
-                        import_error('The symbol "' + aname.name + '" is not exported from the module: ' + key)
+                    if not options.for_linting and not has_prop(
+                        exports,
+                        aname.name
+                    ):
+                        import_error(
+                            'The symbol "' + aname.name +
+                            '" is not exported from the module: ' + key
+                        )
                     if is_('keyword', 'as'):
                         next()
                         aname.alias = as_symbol(AST_SymbolAlias)
@@ -1022,12 +1233,20 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     obj = classes[argvar.name]
                     if obj:
                         key = argvar.alias.name if argvar.alias else argvar.name
-                        S.classes[-1][key] = {'static': obj.static, 'bound': obj.bound, 'classvars': obj.classvars}
+                        S.classes[-1][key] = {
+                            'static': obj.static,
+                            'bound': obj.bound,
+                            'classvars': obj.classvars,
+                        }
             else:
                 for cname in Object.keys(classes):
                     obj = classes[cname]
                     key = imp.alias.name if imp.alias else imp.key
-                    S.classes[-1][key + '.' + obj.name.name] = {'static': obj.static, 'bound': obj.bound, 'classvars': obj.classvars}
+                    S.classes[-1][key + '.' + obj.name.name] = {
+                        'static': obj.static,
+                        'bound': obj.bound,
+                        'classvars': obj.classvars,
+                    }
 
         return ans
 
@@ -1077,7 +1296,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             return d
         )()
         cls_body = await (async def (loop, labels):
-            # navigate to correct location in the module tree and append the class
+            # navigate to correct location in the module tree and
+            # append the class
             S.in_class.push(name.name)
             S.classes[S.classes.length - 1][name.name] = class_details
             S.classes.push({})
@@ -1117,7 +1337,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 if stmt.is_getter or stmt.is_setter:
                     descriptor = definition.dynamic_properties[stmt.name.name]
                     if not descriptor:
-                        descriptor = definition.dynamic_properties[stmt.name.name] = {}
+                        descriptor = definition.dynamic_properties[
+                            stmt.name.name
+                        ] = {}
                     descriptor['getter' if stmt.is_getter else 'setter'] = stmt
                 elif stmt.name.name is '__init__':
                     definition.init = stmt
@@ -1134,14 +1356,25 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     return
                 if is_node_type(node, AST_Function):
                     return
-                if is_node_type(node, AST_Assign) and is_node_type(node.left, AST_SymbolRef):
+                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')
+                        token_error(
+                            node.left.start,
+                            varname + ' is not allowed as a class variable name'
+                        )
                     class_var_names[varname] = True
                     definition.classvars[varname] = True
-                elif is_node_type(node, AST_SymbolRef) and has_prop(class_var_names, node.name):
-                    node.thedef = new AST_SymbolDefun({'name': name.name + '.prototype.' + node.name})
+                elif is_node_type(node, AST_SymbolRef) and has_prop(
+                    class_var_names,
+                    node.name
+                ):
+                    node.thedef = new AST_SymbolDefun({
+                        'name': name.name + '.prototype.' + node.name
+                    })
                 if descend:
                     descend.call(node)
             this._visit = visit_node
@@ -1154,7 +1387,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         return definition
 
     async def function_(in_class, is_expression, is_async=False):
-        name = as_symbol(AST_SymbolDefun if in_class else AST_SymbolLambda) if is_('name') else None
+        name = as_symbol(
+            AST_SymbolDefun if in_class else AST_SymbolLambda
+        ) if is_('name') else None
         if in_class and not name:
             croak('Cannot use anonymous function as class methods')
         is_anonymous = not name
@@ -1166,10 +1401,16 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             property_setter = has_setter_decorator(S.decorators, name.name)
             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[name.name] = True
+                    croak(
+                        'A method cannot be both static and a'
+                        ' property getter/setter'
+                    )
+                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'):
+            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)
 
         expect('(')
@@ -1196,7 +1437,11 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 if has_prop(seen_names, current_arg_name):
                     token_error(prev(), "Can't repeat parameter names")
                 if current_arg_name is 'arguments':
-                    token_error(prev(), "Can't use the name arguments as a parameter name, it is reserved by JavaScript")
+                    token_error(
+                        prev(),
+                        "Can't use the name arguments as a parameter"
+                        ' name, it is reserved by JavaScript'
+                    )
                 seen_names[current_arg_name] = True
                 # save these in order to move back if we have an annotation
                 name_token = S.token
@@ -1226,8 +1471,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     return sym
                 else:
                     if not is_('name'):
-                        # there is no name, which is an error we should report on the
-                        # same line as the definition, so move to that is we're not already there.
+                        # there is no name, which is an error we should
+                        # report on the same line as the definition, so
+                        # move to that is we're not already there.
                         if S.input.context().tokline is not def_line:
                             croak('Name expected', def_line)
                         else:
@@ -1252,29 +1498,52 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     # **kwargs
                     next()
                     if kwargs_sym:
-                        token_error(name_token, "Can't define multiple **kwargs in function definition")
+                        token_error(
+                            name_token,
+                            "Can't define multiple **kwargs"
+                            ' in function definition'
+                        )
                     kwargs_sym = await get_arg()
                 elif is_('operator', '*'):
                     # *args
                     next()
                     if starargs_sym:
-                        token_error(name_token, "Can't define multiple *args in function definition")
+                        token_error(
+                            name_token,
+                            "Can't define multiple *args in function definition"
+                        )
                     if kwargs_sym:
-                        token_error(name_token, "Can't define *args after **kwargs in function definition")
+                        token_error(
+                            name_token,
+                            "Can't define *args after **kwargs"
+                            ' in function definition'
+                        )
                     starargs_sym = await get_arg()
                 else:
                     if starargs_sym or kwargs_sym:
-                        token_error(name_token, "Can't define a formal parameter after *args or **kwargs")
+                        token_error(
+                            name_token,
+                            "Can't define a formal parameter after"
+                            ' *args or **kwargs'
+                        )
                     a.push(await get_arg())
                     if is_('operator', '='):
                         if kwargs_sym:
-                            token_error(name_token, "Can't define an optional formal parameter after **kwargs")
+                            token_error(
+                                name_token,
+                                "Can't define an optional formal parameter"
+                                ' after **kwargs'
+                            )
                         next()
                         defaults[current_arg_name] = await expression(False)
                         has_defaults = True
                     else:
                         if has_defaults:
-                            token_error(name_token, "Can't define required formal parameters after optional formal parameters")
+                            token_error(
+                                name_token,
+                                "Can't define required formal parameters"
+                                ' after optional formal parameters'
+                            )
             next()
             # check if we have a return type annotation
             if is_('punc', '->'):
@@ -1288,7 +1557,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'kwargs': kwargs_sym,
                 'defaults': defaults,
                 'has_defaults': has_defaults,
-                'is_simple_func': not starargs_sym and not kwargs_sym and not has_defaults,
+                'is_simple_func': (
+                    not starargs_sym and not kwargs_sym and not has_defaults
+                ),
             })
         )()
 
@@ -1339,14 +1610,23 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             definition.is_getter = property_getter
             definition.is_setter = property_setter
             if definition.argnames.args.length < 1 and not definition.static:
-                croak('Methods of a class must have at least one argument, traditionally named self')
+                croak(
+                    'Methods of a class must have at least one argument,'
+                    ' traditionally named self'
+                )
             if definition.name and definition.name.name is '__init__':
                 if definition.is_generator:
-                    croak('The __init__ method of a class cannot be a generator (yield not allowed)')
+                    croak(
+                        'The __init__ method of a class cannot be a'
+                        ' generator (yield not allowed)'
+                    )
                 if definition.is_async:
                     croak('The __init__ method of a class cannot be async')
                 if property_getter or property_setter:
-                    croak('The __init__ method of a class cannot be a property getter/setter')
+                    croak(
+                        'The __init__ method of a class cannot be a'
+                        ' property getter/setter'
+                    )
         if definition.is_async and definition.is_generator:
             croak('A function cannot be both async and a generator')
         if definition.is_generator:
@@ -1357,13 +1637,19 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         for i in range(assignments.length):
             for j in range(definition.argnames.args.length + 1):
                 if j is definition.argnames.args.length:
-                    definition.localvars.push(new_symbol(AST_SymbolVar, assignments[i]))
-                elif j < definition.argnames.args.length and assignments[i] is definition.argnames.args[j].name:
+                    definition.localvars.push(
+                        new_symbol(AST_SymbolVar, assignments[i])
+                    )
+                elif (j < definition.argnames.args.length
+                        and assignments[i] is definition.argnames.args[j].name):
                     break
 
         nonlocals = scan_for_nonlocal_defs(definition.body)
         nonlocals = {name for name in nonlocals}
-        definition.localvars = definition.localvars.filter(def (v): return not nonlocals.has(v.name);)
+        definition.localvars = definition.localvars.filter(
+            def (v):
+                return not nonlocals.has(v.name)
+        )
         return definition
 
     async def if_():
@@ -1419,7 +1705,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 a.push(stmt)
         else:
             current_whitespace = S.token.leading_whitespace
-            if current_whitespace.length is 0 or prev_whitespace is current_whitespace:
+            if (current_whitespace.length is 0
+                    or prev_whitespace is current_whitespace):
                 croak('Expected an indented block')
             while not is_('punc', '}'):
                 if is_('eof'):
@@ -1499,7 +1786,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
         return new AST_Try({
             'body': body,
-            'bcatch': (new AST_Catch({'body': bcatch}) if bcatch.length else None),
+            'bcatch': (
+                new AST_Catch({'body': bcatch}) if bcatch.length else None
+            ),
             'bfinally': bfinally,
             'belse': belse
         })
@@ -1612,7 +1901,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'end': tok,
                 'value': tok.value,
             })
-        token_error(tok, 'Expecting an atomic token (number/string/bool/regexp/js/None)')
+        token_error(
+            tok,
+            'Expecting an atomic token (number/string/bool/regexp/js/None)'
+        )
 
     def as_atom_node():
         ret = token_as_atom_node()
@@ -1627,15 +1919,20 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         if is_('punc'):
             tmp_ = start.value
             if tmp_ is '(':
+                prev_parens = S.in_parenthesized_expr
                 S.in_parenthesized_expr = True
                 next()
                 if is_('punc', ')'):
                     next()
+                    S.in_parenthesized_expr = prev_parens
                     return new AST_Array({'elements': []})
                 ex = await expression(True)
                 if is_('keyword', 'for'):
-                    ret = await read_comprehension(new AST_GeneratorComprehension({'statement': ex}), ')')
-                    S.in_parenthesized_expr = False
+                    ret = await read_comprehension(
+                        new AST_GeneratorComprehension({'statement': ex}),
+                        ')'
+                    )
+                    S.in_parenthesized_expr = prev_parens
                     return ret
                 ex.start = start
                 ex.end = S.token
@@ -1645,7 +1942,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     expect(')')
                 if is_node_type(ex, AST_UnaryPrefix):
                     ex.parenthesized = True
-                S.in_parenthesized_expr = False
+                S.in_parenthesized_expr = prev_parens
                 return await subscripts(ex, allow_calls)
             elif tmp_ is '[':
                 return await subscripts(await array_(), allow_calls)
@@ -1700,7 +1997,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         saw_starargs = False
         while not is_('punc', closing):
             if saw_starargs:
-                token_error(prev(), '*args must be the last argument in a function call')
+                token_error(
+                    prev(),
+                    '*args must be the last argument in a function call'
+                )
 
             if first:
                 first = False
@@ -1730,7 +2030,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     kwargs.push([arg.left, arg.right])
                 else:
                     pargs.push(arg)
-            return new AST_CallArgs({'args': pargs, 'kwargs': kwargs, 'kwarg_items': v'[]', 'starargs': saw_starargs})
+            return new AST_CallArgs({
+                'args': pargs, 'kwargs': kwargs,
+                'kwarg_items': v'[]', 'starargs': saw_starargs
+            })
         return a
 
     async def func_call_list(empty):
@@ -1740,13 +2043,19 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         kwarg_items = v'[]'
         starargs = False
         if empty:
-            return new AST_CallArgs({'args': a, 'kwargs': kwargs, 'kwarg_items': kwarg_items, 'starargs': starargs})
+            return new AST_CallArgs({
+                'args': a, 'kwargs': kwargs,
+                'kwarg_items': kwarg_items, 'starargs': starargs
+            })
         single_comprehension = False
         while not is_('punc', ')') and not is_('eof'):
             if not first:
-                expect(',')
-                if is_('punc', ')'):
-                    break
+                if S.token.nlb and not is_('punc', ','):
+                    pass
+                else:
+                    expect(',')
+                    if is_('punc', ')'):
+                        break
             if is_('operator', '*'):
                 next()
                 arg = await expression(False)
@@ -1763,16 +2072,27 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 else:
                     if is_('keyword', 'for'):
                         if not first:
-                            croak('Generator expression must be parenthesized if not sole argument')
-                        comp = await read_comprehension(new AST_GeneratorComprehension({'statement': arg}), ')')
-                        a.push(new AST_CallArg({'value': comp, 'is_array': False}))
+                            croak(
+                                'Generator expression must be'
+                                ' parenthesized if not sole argument'
+                            )
+                        comp = await read_comprehension(
+                            new AST_GeneratorComprehension({'statement': arg}),
+                            ')'
+                        )
+                        a.push(new AST_CallArg({
+                            'value': comp, 'is_array': False
+                        }))
                         single_comprehension = True
                         break
                     a.push(new AST_CallArg({'value': arg, 'is_array': False}))
             first = False
         if not single_comprehension:
             next()
-        return new AST_CallArgs({'args': a, 'kwargs': kwargs, 'kwarg_items': kwarg_items, 'starargs': starargs})
+        return new AST_CallArgs({
+            'args': a, 'kwargs': kwargs,
+            'kwarg_items': kwarg_items, 'starargs': starargs
+        })
 
     @embed_tokens
     async def array_():
@@ -1782,7 +2102,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             expr.push(await expression(False))
             if is_('keyword', 'for'):
                 # list comprehension
-                return await read_comprehension(new AST_ListComprehension({'statement': expr[0]}), ']')
+                return await read_comprehension(
+                    new AST_ListComprehension({'statement': expr[0]}),
+                    ']'
+                )
 
             if not is_('punc', ']'):
                 expect(',')
@@ -1818,7 +2141,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 ctx.expecting_object_literal_key = orig
             if is_('keyword', 'for'):
                 # is_pydict is irrelevant here
-                return await read_comprehension(new AST_SetComprehension({'statement': left}), '}')
+                return await read_comprehension(
+                    new AST_SetComprehension({'statement': left}),
+                    '}'
+                )
             if a.length is 0 and (is_('punc', ',') or is_('punc', '}')):
                 end = prev()
                 return await set_(start, end, left)
@@ -1836,11 +2162,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 return await dict_comprehension(a, is_pydict, is_jshash)
 
         next()
-        return new (AST_ExpressiveObject if has_non_const_keys else AST_Object)({
-            'properties': a,
-            'is_pydict': is_pydict,
-            'is_jshash': is_jshash,
-        })
+        return new (
+            AST_ExpressiveObject if has_non_const_keys else AST_Object
+        )({'properties': a, 'is_pydict': is_pydict, 'is_jshash': is_jshash,})
 
     async def set_(start, end, expr):
         ostart = start
@@ -1852,7 +2176,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 # allow trailing comma
                 break
             set_val = await expression(False)
-            a.push(new AST_SetItem({'start': start, 'value': set_val, 'end': prev()}))
+            a.push(new AST_SetItem({
+                'start': start, 'value': set_val, 'end': prev()
+            }))
         next()
         return new AST_Set({'items': a, 'start': ostart, 'end': prev()})
 
@@ -1860,7 +2186,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         if is_node_type(obj, AST_GeneratorComprehension):
             baselib_items['yield'] = True
         S.in_comprehension = True
-        S.in_parenthesized_expr = False  # in case we are already in a parenthesized expression
+        # in case we are already in a parenthesized expression
+        S.in_parenthesized_expr = False
         expect_token('keyword', 'for')
         forloop = await for_(True)
         obj.init = forloop.init
@@ -1881,11 +2208,17 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         else:
             left = await expression(False)
             if not is_('punc', ':'):
-                return await read_comprehension(new AST_SetComprehension({'statement': left}), '}')
+                return await read_comprehension(
+                    new AST_SetComprehension({'statement': left}),
+                    '}'
+                )
             expect(':')
             right = await expression(False)
         return await read_comprehension(
-            new AST_DictComprehension({'statement': left, 'value_statement': right, 'is_pydict': is_pydict, 'is_jshash': is_jshash}),
+            new AST_DictComprehension({
+                'statement': left, 'value_statement': right,
+                'is_pydict': is_pydict, 'is_jshash': is_jshash
+            }),
             '}'
         )
 
@@ -1893,7 +2226,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         tmp = S.token
         next()
         tmp_ = tmp.type
-        if tmp_ is 'name' or tmp_ is 'operator' or tmp_ is 'keyword' or tmp_ is 'atom':
+        if (tmp_ is 'name' or tmp_ is 'operator'
+                or tmp_ is 'keyword' or tmp_ is 'atom'):
             return tmp.value
         else:
             unexpected()
@@ -1928,7 +2262,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         return sym
 
     def is_static_method(cls, method):
-        if has_prop(COMMON_STATIC, method) or (cls.static and has_prop(cls.static, method)):
+        if has_prop(
+            COMMON_STATIC,
+            method
+        ) or (cls.static and has_prop(cls.static, method)):
             return True
         else:
             return False
@@ -1992,44 +2329,79 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 _ca.push(new AST_CallArg({'value': expr, 'is_array': False}))
                 for _sb in slice_bounds:
                     _ca.push(new AST_CallArg({'value': _sb, 'is_array': False}))
-                return await subscripts(new AST_Call({
-                    'start': start,
-                    'expression': new AST_SymbolRef({
-                        'name': 'ρσ_delslice' if S.in_delete else 'ρσ_eslice'
+                return await subscripts(
+                    new AST_Call({
+                        'start': start,
+                        'expression': new AST_SymbolRef({
+                            'name': (
+                                'ρσ_delslice'
+                                if S.in_delete else 'ρσ_eslice'
+                            )
+                        }),
+                        'args': new AST_CallArgs({
+                            'args': _ca, 'kwargs': v'[]',
+                            'kwarg_items': v'[]', 'starargs': False
+                        }),
+                        'end': prev()
                     }),
-                    'args': new AST_CallArgs({'args': _ca, 'kwargs': v'[]', 'kwarg_items': v'[]', 'starargs': False}),
-                    'end': prev()
-                }), allow_calls)
+                    allow_calls
+                )
             else:
                 # regular slice (arr[start:end])
-                slice_bounds = [new AST_Number({'value': 0}) if i is None else i for i in slice_bounds]
+                slice_bounds = [
+                    new AST_Number({'value': 0}) if i is None else i
+                    for i in slice_bounds
+                ]
                 if S.in_delete:
                     _ca2 = v'[]'
-                    _ca2.push(new AST_CallArg({'value': expr, 'is_array': False}))
-                    _ca2.push(new AST_CallArg({'value': new AST_Number({'value': 1}), 'is_array': False}))
+                    _ca2.push(new AST_CallArg({
+                        'value': expr, 'is_array': False
+                    }))
+                    _ca2.push(new AST_CallArg({
+                        'value': new AST_Number({'value': 1}),
+                        'is_array': False
+                    }))
                     for _sb in slice_bounds:
-                        _ca2.push(new AST_CallArg({'value': _sb, 'is_array': False}))
-                    return await subscripts(new AST_Call({
-                        'start': start,
-                        'expression': new AST_SymbolRef({'name': 'ρσ_delslice'}),
-                        'args': new AST_CallArgs({'args': _ca2, 'kwargs': v'[]', 'kwarg_items': v'[]', 'starargs': False}),
-                        'end': prev()
-                    }), allow_calls)
+                        _ca2.push(new AST_CallArg({
+                            'value': _sb, 'is_array': False
+                        }))
+                    return await subscripts(
+                        new AST_Call({
+                            'start': start,
+                            'expression': new AST_SymbolRef({
+                                'name': 'ρσ_delslice'
+                            }),
+                            'args': new AST_CallArgs({
+                                'args': _ca2, 'kwargs': v'[]',
+                                'kwarg_items': v'[]', 'starargs': False
+                            }),
+                            'end': prev()
+                        }),
+                        allow_calls
+                    )
 
                 _ca3 = v'[]'
                 for _sb in slice_bounds:
-                    _ca3.push(new AST_CallArg({'value': _sb, 'is_array': False}))
-                return await subscripts(new AST_Call({
-                    'start': start,
-                    'expression': new AST_Dot({
+                    _ca3.push(new AST_CallArg({
+                        'value': _sb, 'is_array': False
+                    }))
+                return await subscripts(
+                    new AST_Call({
                         'start': start,
-                        'expression': expr,
-                        'property': 'slice',
+                        'expression': new AST_Dot({
+                            'start': start,
+                            'expression': expr,
+                            'property': 'slice',
+                            'end': prev()
+                        }),
+                        'args': new AST_CallArgs({
+                            'args': _ca3, 'kwargs': v'[]',
+                            'kwarg_items': v'[]', 'starargs': False
+                        }),
                         'end': prev()
                     }),
-                    'args': new AST_CallArgs({'args': _ca3, 'kwargs': v'[]', 'kwarg_items': v'[]', 'starargs': False}),
-                    'end': prev()
-                }), allow_calls)
+                    allow_calls
+                )
         else:
             # regular index (arr[index])
             if is_py_sub:
@@ -2061,6 +2433,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
     async def call_(expr):
         start = expr.start
+        prev_parens = S.in_parenthesized_expr
         S.in_parenthesized_expr = True
         next()
         if not expr.parens and get_class_in_scope(expr):
@@ -2072,7 +2445,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'args': call_args,
                 'end': prev()
             }), True)
-            S.in_parenthesized_expr = False
+            S.in_parenthesized_expr = prev_parens
             return ret
         else:
             if is_node_type(expr, AST_Dot):
@@ -2091,7 +2464,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     'args': classcall_args,
                     'end': prev()
                 }), True)
-                S.in_parenthesized_expr = False
+                S.in_parenthesized_expr = prev_parens
                 return ret
             elif is_node_type(expr, AST_SymbolRef):
                 tmp_ = expr.name
@@ -2103,12 +2476,15 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                         'expression': jstype_args.args[0].value,
                         'end': prev()
                     })
-                    S.in_parenthesized_expr = False
+                    S.in_parenthesized_expr = prev_parens
                     return ret
                 elif tmp_ is 'isinstance':
                     args = await func_call_list()
                     if args.args.length is not 2:
-                        croak('isinstance() must be called with exactly two arguments')
+                        croak(
+                            'isinstance() must be called with exactly'
+                            ' two arguments'
+                        )
                     ret = new AST_Binary({
                         'start': start,
                         'left': args.args[0].value,
@@ -2116,7 +2492,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                         'right': args.args[1].value,
                         'end': prev()
                     })
-                    S.in_parenthesized_expr = False
+                    S.in_parenthesized_expr = prev_parens
                     return ret
 
             # fall-through to basic function call
@@ -2127,7 +2503,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'args': basic_args,
                 'end': prev()
             }), True)
-            S.in_parenthesized_expr = False
+            S.in_parenthesized_expr = prev_parens
             return ret
 
     async def get_attr(expr, allow_calls):
@@ -2147,11 +2523,14 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         }), allow_calls)
 
     async def existential(expr, allow_calls):
-        ans = new AST_Existential({'start': expr.start, 'end': S.token, 'expression': expr})
+        ans = new AST_Existential({
+            'start': expr.start, 'end': S.token, 'expression': expr
+        })
         next()
         ttype = S.token.type
         val = S.token.value
-        if S.token.nlb or ttype is 'keyword' or ttype is 'operator' or ttype is 'eof':
+        if (S.token.nlb or ttype is 'keyword'
+                or ttype is 'operator' or ttype is 'eof'):
             ans.after = None
             return ans
         if ttype is 'punc':
@@ -2197,14 +2576,21 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             expr = await expression()
             S.parsing_decorator = False
             S.decorators.push(expr)
-            return new AST_EmptyStatement({'stype': '@', 'start': prev(), 'end': prev()})
+            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 = await maybe_unary(allow_calls)
             S.in_delete = False
-            ex = make_unary(AST_UnaryPrefix, start.value, expr, is_parenthesized)
+            ex = make_unary(
+                AST_UnaryPrefix,
+                start.value,
+                expr,
+                is_parenthesized
+            )
             ex.start = start
             ex.end = prev()
             return ex
@@ -2248,7 +2634,12 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
     async def maybe_conditional(no_in):
         start = S.token
         expr = await expr_ops(no_in)
-        if (is_('keyword', 'if') and (S.in_parenthesized_expr or (S.statement_starting_token is not S.token and not S.in_comprehension and not S.token.nlb))):
+        if (is_('keyword', 'if') and (
+                S.in_parenthesized_expr or (
+                    S.statement_starting_token is not S.token
+                    and not S.in_comprehension
+                    and not S.token.nlb
+                ))):
             next()
             ne = await expression(False)
             expect_token('keyword', 'else')
@@ -2264,10 +2655,18 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         return expr
 
     def create_assign(data):
-        if data.right and is_node_type(data.right, AST_Seq) and (
-                is_node_type(data.right.car, AST_Assign) or
-                is_node_type(data.right.cdr, AST_Assign)) and data.operator is not '=':
-            token_error(data.start, 'Invalid assignment operator for chained assignment: ' + data.operator)
+        if data.right and is_node_type(
+            data.right,
+            AST_Seq
+        ) and (
+            is_node_type(data.right.car, AST_Assign)
+            or is_node_type(data.right.cdr, AST_Assign)
+        ) and data.operator is not '=':
+            token_error(
+                data.start,
+                'Invalid assignment operator for chained'
+                ' assignment: ' + data.operator
+            )
         ans = AST_Assign(data)
         if S.in_class.length and S.in_class[-1]:
             class_name = S.in_class[-1]
@@ -2287,7 +2686,10 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         val = S.token.value
         if is_('operator') and ASSIGNMENT[val]:
             if only_plain_assignment and val is not '=':
-                croak('Invalid assignment operator for chained assignment: ' + val)
+                croak(
+                    'Invalid assignment operator for chained assignment: '
+                    + val
+                )
             next()
             assign_right = await maybe_assign(no_in, True)
             return create_assign({
@@ -2317,20 +2719,26 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             })
         if commas:
             left = v'[ expr ]'
-            while is_('punc', ',') and (not peek().nlb or S.in_parenthesized_expr):
-                next()
+            while is_(
+                'punc', ','
+            ) and (not peek().nlb or S.in_parenthesized_expr) or (
+                S.in_parenthesized_expr and S.token.nlb
+                and not is_('punc', ')')
+            ):
+                if is_('punc', ','):
+                    next()
                 if is_node_type(expr, AST_Assign):
                     left[-1] = left[-1].left
                     seq_cdr = await expression(True, no_in)
                     return create_assign({
                         'start': start,
-                        'left': (left[0] if left.length is 1 else new AST_Array({
-                            'elements': left
-                        })),
+                        'left': (
+                            left[0] if left.length is 1
+                            else new AST_Array({'elements': left})
+                        ),
                         'operator': expr.operator,
                         'right': new AST_Seq({
-                            'car': expr.right,
-                            'cdr': seq_cdr
+                            'car': expr.right, 'cdr': seq_cdr
                         }),
                         'end': peek()
                     })
@@ -2378,10 +2786,15 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     raise
             else:
                 element = await statement()
-            if first_token and is_node_type(element, AST_Directive) and element.value.indexOf('#!') is 0:
+            if first_token and is_node_type(
+                element,
+                AST_Directive
+            ) and element.value.indexOf('#!') is 0:
                 shebang = element.value
             else:
-                ds = not toplevel and is_docstring(element)  # do not process strings as docstrings if we are concatenating toplevels
+                # do not process strings as docstrings if we are
+                # concatenating toplevels
+                ds = not toplevel and is_docstring(element)
                 if ds:
                     docstrings.push(ds)
                 else:
@@ -2404,17 +2817,21 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
         if options.recover_errors:
             # Combine parser-level recovered errors with any collected by the
-            # tokenizer (e.g. skipped unexpected characters) for the LSP to report.
+            # tokenizer (e.g. skipped unexpected characters) for the
+            # LSP to report.
             recovered = S.recovered_errors
             try:
                 tok_ctx = S.input.context()
-                if tok_ctx and tok_ctx.recovered_errors and tok_ctx.recovered_errors.length:
+                if (tok_ctx and tok_ctx.recovered_errors
+                        and tok_ctx.recovered_errors.length):
                     recovered = recovered.concat(tok_ctx.recovered_errors)
             except:
                 pass
             toplevel.recovered_errors = recovered
 
-        toplevel.nonlocalvars = scan_for_nonlocal_defs(toplevel.body).concat(S.globals)
+        toplevel.nonlocalvars = scan_for_nonlocal_defs(
+            toplevel.body
+        ).concat(S.globals)
         toplevel.localvars = []
         toplevel.exports = []
         seen_exports = {}
@@ -2445,16 +2862,23 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         importing_modules[module_id] = False
         toplevel.comments_after = S.token.comments_before or v'[]'
 
-        if options._src_hash and options.filename and module_id is not '__main__':
+        if (options._src_hash and options.filename
+                and module_id is not '__main__'):
             try:
-                # Simplified class info (no full AST nodes) for lazy-shell reconstruction.
+                # Simplified class info (no full AST nodes) for
+                # lazy-shell reconstruction.
                 classes_cache = {}
                 for cname in Object.keys(toplevel.classes or {}):
                     cls = toplevel.classes[cname]
-                    classes_cache[cname] = {'static': cls.static or {}, 'bound': cls.bound or [], 'classvars': cls.classvars or {}}
+                    classes_cache[cname] = {
+                        'static': cls.static or {},
+                        'bound': cls.bound or [],
+                        'classvars': cls.classvars or {},
+                    }
                 # Single pass: compute has_side_effects + tree-shaking index.
                 # The index lets the tree-shaker resolve the fixpoint iteration
-                # (steps 4-5) without accessing mod.body — no AST deserialization
+                # (steps 4-5) without accessing mod.body — no AST
+                # deserialization
                 # until step 6 (pruning), which needs actual nodes anyway.
                 has_se = False
                 idx_exec_refs_set = {}
@@ -2468,26 +2892,50 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     node.walk(new TreeWalker(_rv))
 
                 for idx_stmt in toplevel.body:
-                    if is_node_type(idx_stmt, AST_Function) or is_node_type(idx_stmt, AST_Class):
+                    if is_node_type(
+                        idx_stmt,
+                        AST_Function
+                    ) or is_node_type(idx_stmt, AST_Class):
                         if idx_stmt.name:
                             idx_pinned = False
                             if idx_stmt.decorators:
                                 for idx_dec in idx_stmt.decorators:
-                                    if idx_dec.expression and is_node_type(idx_dec.expression, AST_SymbolRef) and idx_dec.expression.name == 'no_prune':
+                                    if idx_dec.expression and is_node_type(
+                                        idx_dec.expression,
+                                        AST_SymbolRef
+                                    ) and idx_dec.expression.name == 'no_prune':
                                         idx_pinned = True
                                         break
                             idx_def_refs = {}
                             _collect_refs_into(idx_stmt, idx_def_refs)
-                            idx_top_defs[idx_stmt.name.name] = {'pinned': idx_pinned, 'refs': Object.keys(idx_def_refs)}
+                            idx_top_defs[idx_stmt.name.name] = {
+                                'pinned': idx_pinned,
+                                'refs': Object.keys(idx_def_refs),
+                            }
                     elif is_node_type(idx_stmt, AST_Imports):
                         for idx_imp in idx_stmt.imports:
                             if idx_imp.argnames and idx_imp.argnames.length:
                                 for idx_arg in idx_imp.argnames:
-                                    idx_local = idx_arg.alias.name if idx_arg.alias else idx_arg.name
-                                    idx_import_bindings[idx_local] = {'source': idx_imp.key, 'imported_name': idx_arg.name, 'is_namespace': False}
+                                    idx_local = (
+                                        idx_arg.alias.name
+                                        if idx_arg.alias else idx_arg.name
+                                    )
+                                    idx_import_bindings[idx_local] = {
+                                        'source': idx_imp.key,
+                                        'imported_name': idx_arg.name,
+                                        'is_namespace': False,
+                                    }
                             else:
-                                idx_local = idx_imp.alias.name if idx_imp.alias else idx_imp.key.split('.')[0]
-                                idx_import_bindings[idx_local] = {'source': idx_imp.key, 'imported_name': None, 'is_namespace': True}
+                                idx_local = (
+                                    idx_imp.alias.name
+                                    if idx_imp.alias
+                                    else idx_imp.key.split('.')[0]
+                                )
+                                idx_import_bindings[idx_local] = {
+                                    'source': idx_imp.key,
+                                    'imported_name': None,
+                                    'is_namespace': True,
+                                }
                     else:
                         if not has_se:
                             se_found = v'[false]'
@@ -2516,12 +2964,22 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                         'top_defs': idx_top_defs,
                     },
                 }
-                if options._file_mtime is not None and options._file_mtime is not undefined:
+                if (options._file_mtime is not None
+                        and options._file_mtime is not undefined):
                     cache_meta['mtime'] = options._file_mtime
-                # Binary format: metadata JSON followed by newline and binary AST pool.
-                await writefile(cache_file_name(options.filename, options.module_cache_dir), encode_cache(JSON.stringify(cache_meta), toplevel))
+                # Binary format: metadata JSON followed by newline
+                # and binary AST pool.
+                await writefile(
+                    cache_file_name(options.filename, options.module_cache_dir),
+                    encode_cache(JSON.stringify(cache_meta), toplevel)
+                )
             except as e:
-                console.error('Failed to write AST cache file:', options.filename, 'with error:', e)
+                console.error(
+                    'Failed to write AST cache file:',
+                    options.filename,
+                    'with error:',
+                    e
+                )
 
         return toplevel
 
@@ -2533,13 +2991,18 @@ async def parse(text, options):
         'filename': None,  # name of the file being parsed
         'module_id': '__main__',  # The id of the module being parsed
         'toplevel': None,
-        'for_linting': False,  # If True certain actions are not performed, such as importing modules
+        # If True certain actions are not performed, such as importing modules
+        'for_linting': False,
         'import_dirs': v'[]',
-        'classes': undefined,  # Map of class names to AST_Class that are available in the global namespace (used by the REPL)
+        # Map of class names to AST_Class that are available in the
+        # global namespace (used by the REPL)
+        'classes': undefined,
         'scoped_flags': {},  # Global scoped flags (used by the REPL)
         'discard_asserts': False,
         'module_cache_dir': '',
-        'recover_errors': False,  # When True, continue parsing past syntax errors (used by the LSP). See run_parser/block_.
+        # When True, continue parsing past syntax errors (used by the
+        # LSP). See run_parser/block_.
+        'recover_errors': False,
     })
     import_dirs = [x for x in options.import_dirs]
     for location in v'[options.libdir, options.basedir]':
@@ -2550,16 +3013,21 @@ async def parse(text, options):
     imported_module_ids = []
     imported_modules = options.imported_modules or {}
     importing_modules = options.importing_modules or {}
-    # loading_promises tracks modules currently being loaded across the entire compilation.
-    # It is shared by passing it through options so parallel sub-parse() calls all see it.
+    # loading_promises tracks modules currently being loaded across the
+    # entire compilation.
+    # It is shared by passing it through options so parallel sub-parse()
+    # calls all see it.
     if not options.loading_promises:
         options.loading_promises = {}
     importing_modules[module_id] = True
 
     # The internal state of the parser
     S = {
-        'input': tokenizer(text, options.filename, options.recover_errors) if jstype(text) is 'string' else text,
-        'recovered_errors': v'[]',  # syntax errors swallowed during recovery (recover_errors mode only)
+        'input': tokenizer(
+            text, options.filename, options.recover_errors
+        ) if jstype(text) is 'string' else text,
+        # syntax errors swallowed during recovery (recover_errors mode only)
+        'recovered_errors': v'[]',
         'token': None,
         'prev': None,
         'peeked': [],
@@ -2595,9 +3063,22 @@ async def parse(text, options):
     if options.classes:
         for cname in options.classes:
             obj = options.classes[cname]
-            S.classes[0][cname] = {'static': obj.static, 'bound': obj.bound, 'classvars': obj.classvars}
+            S.classes[0][cname] = {
+                'static': obj.static,
+                'bound': obj.bound,
+                'classvars': obj.classvars,
+            }
 
     if jstype(text) is 'string' and not options._src_hash:
         options._src_hash = sha1sum(text)
 
-    return await create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_ids, imported_modules, importing_modules, options)()
+    return await create_parser_ctx(
+        S,
+        import_dirs,
+        module_id,
+        baselib_items,
+        imported_module_ids,
+        imported_modules,
+        importing_modules,
+        options
+    )()