rapydscript-ng 0.7.24 → 0.8.1

package/src/ast.pyj

@@ -4,13 +4,14 @@ from __python__ import hash_literals
 
 from utils import noop
 
+
 def is_node_type(node, typ):
     return v'node instanceof typ'
 
 # Basic classes {{{
 
-class AST:
 
+class AST:
     properties = {}
 
     def __init__(self, initializer):
@@ -38,17 +39,18 @@ class AST_Token(AST):
         'col': 'The column number at which the token occurs',
         'pos': '',
         'endpos': '',
-        'nlb':'True iff there was a newline before this token',
-        'comments_before':'True iff there were comments before this token',
-        'file':'The filename in which this token occurs',
+        'nlb': 'True iff there was a newline before this token',
+        'comments_before': 'True iff there were comments before this token',
+        'file': 'The filename in which this token occurs',
         'leading_whitespace': 'The leading whitespace for the line on which this token occurs',
     }
 
+
 class AST_Node(AST):
-    "Base class of all AST nodes"
+    'Base class of all AST nodes'
     properties = {
-        'start': "[AST_Token] The first token of this node",
-        'end': "[AST_Token] The last token of this node"
+        'start': '[AST_Token] The first token of this node',
+        'end': '[AST_Token] The last token of this node'
     }
 
     def _walk(self, visitor):
@@ -59,12 +61,12 @@ class AST_Node(AST):
 
     def _dump(self, depth=100, omit={'start', 'end'}, offset=0, include_name=True):
         p = console.log
-        reset = "\x1b[0m"
-        yellow = "\x1b[33m"
-        blue = "\x1b[34m"
-        green = "\x1b[32m"
-        red = "\x1b[31m"
-        magenta = "\x1b[35m"
+        reset = '\x1b[0m'
+        yellow = '\x1b[33m'
+        blue = '\x1b[34m'
+        green = '\x1b[32m'
+        red = '\x1b[31m'
+        magenta = '\x1b[35m'
         pad = Array(offset + 1).join('  ')
 
         if include_name:
@@ -78,7 +80,7 @@ class AST_Node(AST):
                     p(pad + ' ' + blue + key + ': ' + reset + '[')
                     if depth > 1:
                         for element in self[key]:
-                            element._dump(depth-1, omit, offset+1, True)
+                            element._dump(depth - 1, omit, offset + 1, True)
                     else:
                         for element in self[key]:
                             p(pad + '   ' + yellow + element.constructor.name.slice(4) + reset)
@@ -95,10 +97,10 @@ class AST_Node(AST):
                     else:
                         p(pad + ' ' + blue + key + ': ' + yellow + tname + reset)
                         if depth > 1:
-                            self[key]._dump(depth-1, omit, offset+1, False)
-                elif jstype(self[key]) is "string":
+                            self[key]._dump(depth - 1, omit, offset + 1, False)
+                elif jstype(self[key]) is 'string':
                     p(pad + ' ' + blue + key + ': ' + green + '"' + self[key] + '"' + reset)
-                elif jstype(self[key]) is "number":
+                elif jstype(self[key]) is 'number':
                     p(pad + ' ' + blue + key + ': ' + green + self[key] + reset)
                 else:
                     # unexpected object
@@ -114,39 +116,44 @@ class AST_Node(AST):
 
 # Statements {{{
 
+
 class AST_Statement(AST_Node):
-    "Base class of all statements"
+    'Base class of all statements'
+
 
 class AST_Debugger(AST_Statement):
-    "Represents a debugger statement"
+    'Represents a debugger statement'
+
 
 class AST_Directive(AST_Statement):
     'Represents a directive, like "use strict";'
     properties = {
         'value': "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        'scope': "[AST_Scope/S] The scope that this directive affects"
+        'scope': '[AST_Scope/S] The scope that this directive affects'
     }
 
+
 class AST_SimpleStatement(AST_Statement):
-    "A statement consisting of an expression, i.e. a = 1 + 2"
-    properties =  {
-        'body': "[AST_Node] an expression node (should not be instanceof AST_Statement)"
+    'A statement consisting of an expression, i.e. a = 1 + 2'
+    properties = {
+        'body': '[AST_Node] an expression node (should not be instanceof AST_Statement)'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.body._walk(visitor)
         )
 
+
 class AST_Assert(AST_Statement):
     "An assert statement, e.g. assert True, 'an error message'"
     properties = {
-        'condition': "[AST_Node] the expression that should be tested",
-        'message': "[AST_Node*] the expression that is the error message or None",
+        'condition': '[AST_Node] the expression that should be tested',
+        'message': '[AST_Node*] the expression that is the error message or None',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.condition._walk(visitor)
             if self.message:
                 self.message._walk(visitor)
@@ -160,68 +167,76 @@ def walk_body(node, visitor):
         for stat in node.body:
             stat._walk(visitor)
 
+
 class AST_Block(AST_Statement):
-    "A body of statements (usually bracketed)"
-    properties =  {
-        'body': "[AST_Statement*] an array of statements"
+    'A body of statements (usually bracketed)'
+    properties = {
+        'body': '[AST_Statement*] an array of statements'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             walk_body(self, visitor)
         )
 
+
 class AST_BlockStatement(AST_Block):
-    "A block statement"
+    'A block statement'
+
 
 class AST_EmptyStatement(AST_Statement):
-    "The empty statement (empty block or simply a semicolon)"
+    'The empty statement (empty block or simply a semicolon)'
     properties = {
-        'stype': "[string] the type of empty statement. Is ; for semicolons",
+        'stype': '[string] the type of empty statement. Is ; for semicolons',
     }
 
     def _walk(self, visitor):
         return visitor._visit(self)
 
+
 class AST_StatementWithBody(AST_Statement):
-    "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`"
+    'Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`'
     properties = {
         'body': "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.body._walk(visitor)
         )
 
+
 class AST_DWLoop(AST_StatementWithBody):
-    "Base class for do/while statements"
+    'Base class for do/while statements'
     properties = {
-        'condition': "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
+        'condition': '[AST_Node] the loop condition.  Should not be instanceof AST_Statement'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.condition._walk(visitor)
             self.body._walk(visitor)
         )
 
+
 class AST_Do(AST_DWLoop):
-    "A `do` statement"
+    'A `do` statement'
+
 
 class AST_While(AST_DWLoop):
-    "A `while` statement"
+    'A `while` statement'
+
 
 class AST_ForIn(AST_StatementWithBody):
-    "A `for ... in` statement"
+    'A `for ... in` statement'
     properties = {
-        'init': "[AST_Node] the `for/in` initialization code",
-        'name': "[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",
+        'init': '[AST_Node] the `for/in` initialization code',
+        'name': '[AST_SymbolRef?] the loop variable, only if `init` is AST_Var',
         'object': "[AST_Node] the object that we're looping through"
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.init._walk(visitor)
             if (self.name) self.name._walk(visitor)
             self.object._walk(visitor)
@@ -229,40 +244,44 @@ class AST_ForIn(AST_StatementWithBody):
                 self.body._walk(visitor)
         )
 
+
 class AST_ForJS(AST_StatementWithBody):
-    "A `for ... in` statement"
+    'A `for ... in` statement'
     properties = {
-        'condition': "[AST_Verbatim] raw JavaScript conditional"
+        'condition': '[AST_Verbatim] raw JavaScript conditional'
     }
 
+
 class AST_ListComprehension(AST_ForIn):
-    "A list comprehension expression"
+    'A list comprehension expression'
     properties = {
-        'condition': "[AST_Node] the `if` condition",
-        'statement': "[AST_Node] statement to perform on each element before returning it"
+        'condition': '[AST_Node] the `if` condition',
+        'statement': '[AST_Node] statement to perform on each element before returning it'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.init._walk(visitor)
             self.object._walk(visitor)
             self.statement._walk(visitor)
             if (self.condition) self.condition._walk(visitor)
         )
 
+
 class AST_SetComprehension(AST_ListComprehension):
     'A set comprehension'
 
+
 class AST_DictComprehension(AST_ListComprehension):
     'A set comprehension'
     properties = {
-        'value_statement': "[AST_Node] statement to perform on each value before returning it",
-        'is_pydict': "[bool] True if this comprehension is for a python dict",
-        'is_jshash': "[bool] True if this comprehension is for a js hash",
+        'value_statement': '[AST_Node] statement to perform on each value before returning it',
+        'is_pydict': '[bool] True if this comprehension is for a python dict',
+        'is_jshash': '[bool] True if this comprehension is for a js hash',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.init._walk(visitor)
             self.object._walk(visitor)
             self.statement._walk(visitor)
@@ -270,22 +289,25 @@ class AST_DictComprehension(AST_ListComprehension):
             if (self.condition) self.condition._walk(visitor)
         )
 
+
 class AST_GeneratorComprehension(AST_ListComprehension):
     'A generator comprehension'
 
+
 class AST_With(AST_StatementWithBody):
-    "A `with` statement"
+    'A `with` statement'
     properties = {
-        'clauses': "[AST_WithClause*] the `with` clauses (comma separated)"
+        'clauses': '[AST_WithClause*] the `with` clauses (comma separated)'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             for exp in self.clauses:
                 exp._walk(visitor)
             self.body._walk(visitor)
         )
 
+
 class AST_WithClause(AST_Node):
     'A clause in a with statement'
     properties = {
@@ -294,7 +316,7 @@ class AST_WithClause(AST_Node):
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.expression._walk(visitor)
             if self.alias:
                 self.alias._walk(visitor)
@@ -303,45 +325,47 @@ class AST_WithClause(AST_Node):
 
 # Scope and functions {{{
 
+
 class AST_Scope(AST_Block):
-    "Base class for all statements introducing a lexical scope"
+    'Base class for all statements introducing a lexical scope'
     properties = {
-        'localvars': "[SymbolDef*] list of variables local to this scope",
-        'docstrings': "[AST_String*] list of docstrings for this scope",
+        'localvars': '[SymbolDef*] list of variables local to this scope',
+        'docstrings': '[AST_String*] list of docstrings for this scope',
     }
 
 
 class AST_Toplevel(AST_Scope):
-    "The toplevel scope"
+    'The toplevel scope'
     properties = {
-        'globals': "[Object/S] a map of name -> SymbolDef for all undeclared names",
-        'baselib': "[Object/s] a collection of used parts of baselib",
-        'imports': "[Object/S] a map of module_id->AST_Toplevel for all imported modules (this represents all imported modules across all source files)",
-        'imported_module_ids': "[string*] a list of module ids that were imported by this module, specifically",
-        'nonlocalvars': "[String*] a list of all non-local variable names (names that come from the global scope)",
-        'shebang': "[string] If #! line is present, it will be stored here",
-        'import_order': "[number] The global order in which this scope was imported",
-        'module_id': "[string] The id of this module",
-        'exports': "[SymbolDef*] list of names exported from this module",
-        'classes': "[Object/S] a map of class names to AST_Class for classes defined in this module",
-        'filename': "[string] The absolute path to the file from which this module was read",
-        'srchash': "[string] SHA1 hash of source code, used for caching",
+        'globals': '[Object/S] a map of name -> SymbolDef for all undeclared names',
+        'baselib': '[Object/s] a collection of used parts of baselib',
+        'imports': '[Object/S] a map of module_id->AST_Toplevel for all imported modules (this represents all imported modules across all source files)',
+        'imported_module_ids': '[string*] a list of module ids that were imported by this module, specifically',
+        'nonlocalvars': '[String*] a list of all non-local variable names (names that come from the global scope)',
+        'shebang': '[string] If #! line is present, it will be stored here',
+        'import_order': '[number] The global order in which this scope was imported',
+        'module_id': '[string] The id of this module',
+        'exports': '[SymbolDef*] list of names exported from this module',
+        'classes': '[Object/S] a map of class names to AST_Class for classes defined in this module',
+        'filename': '[string] The absolute path to the file from which this module was read',
+        'srchash': '[string] SHA1 hash of source code, used for caching',
         'comments_after': '[array] True iff there were comments before this token',
     }
 
+
 class AST_Import(AST_Statement):
-    "Container for a single import"
+    'Container for a single import'
 
     properties = {
         'module': "[AST_SymbolVar] name of the module we're importing",
-        'key':  "[string] The key by which this module is stored in the global modules mapping",
-        'alias': "[AST_SymbolAlias] The name this module is imported as, can be None. For import x as y statements.",
-        'argnames': "[AST_ImportedVar*] names of objects to be imported",
-        'body': "[AST_TopLevel] parsed contents of the imported file",
+        'key': '[string] The key by which this module is stored in the global modules mapping',
+        'alias': '[AST_SymbolAlias] The name this module is imported as, can be None. For import x as y statements.',
+        'argnames': '[AST_ImportedVar*] names of objects to be imported',
+        'body': '[AST_TopLevel] parsed contents of the imported file',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             if self.alias:
                 self.alias._walk(visitor)
             if self.argnames:
@@ -349,81 +373,103 @@ class AST_Import(AST_Statement):
                     arg._walk(visitor)
         )
 
+
 class AST_Imports(AST_Statement):
-    "Container for a single import"
+    'Container for a single import'
     properties = {
-        'imports': "[AST_Import+] array of imports",
+        'imports': '[AST_Import+] array of imports',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             for imp in self.imports:
                 imp._walk(visitor)
         )
 
+
 class AST_Decorator(AST_Node):
-    "Class for function decorators"
+    'Class for function decorators'
     properties = {
-        'expression': "[AST_Node] the decorator expression"
+        'expression': '[AST_Node] the decorator expression'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             if self.expression:
                 self.expression.walk(visitor)
         )
 
+
+class AST_ArgsDef(AST_Node):
+    'The formal argument definition list for a function'
+    properties = {
+        'args': '[AST_SymbolFunarg*] formal positional parameters',
+        'starargs': '[AST_SymbolFunarg?] *args parameter, or None',
+        'kwargs': '[AST_SymbolFunarg?] **kwargs parameter, or None',
+        'defaults': '[Object] map of parameter name to default value expression',
+        'has_defaults': '[bool] True if any parameter has a default value',
+        'is_simple_func': '[bool] True if no starargs, no kwargs, and no defaults',
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def ():
+            for arg in self.args:
+                arg._walk(visitor)
+            if self.starargs:
+                self.starargs._walk(visitor)
+            if self.kwargs:
+                self.kwargs._walk(visitor)
+        )
+
+
 class AST_Lambda(AST_Scope):
-    "Base class for functions"
+    'Base class for functions'
     properties = {
-        'name': "[AST_SymbolDeclaration?] the name of this function",
-        'argnames': "[AST_SymbolFunarg*] array of function arguments",
-        'decorators': "[AST_Decorator*] function decorators, if any",
-        'is_generator': "[bool*] True iff this function is a generator",
-        'is_expression': "[bool*] True iff this function is a function expression",
-        'is_anonymous': "[bool*] True iff this function is an anonymous function",
-        "return_annotation": "[AST_Node?] The return type annotation provided (if any)",
+        'name': '[AST_SymbolDeclaration?] the name of this function',
+        'argnames': '[AST_ArgsDef] the function argument definitions',
+        'decorators': '[AST_Decorator*] function decorators, if any',
+        'is_generator': '[bool*] True iff this function is a generator',
+        'is_async': '[bool*] True iff this function is an async function',
+        'is_expression': '[bool*] True iff this function is a function expression',
+        'is_anonymous': '[bool*] True iff this function is an anonymous function',
+        'return_annotation': '[AST_Node?] The return type annotation provided (if any)',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             if self.decorators:
                 for d in self.decorators:
                     d.walk(visitor)
             if self.name:
                 self.name._walk(visitor)
-
-            for arg in self.argnames:
-                arg._walk(visitor)
-            if self.argnames.starargs:
-                self.argnames.starargs._walk(visitor)
-            if self.argnames.kwargs:
-                self.argnames.kwargs._walk(visitor)
+            self.argnames._walk(visitor)
             walk_body(self, visitor)
         )
 
+
 class AST_Function(AST_Lambda):
-    "A function expression"
+    'A function expression'
+
 
 class AST_Class(AST_Scope):
-    "A class declaration"
+    'A class declaration'
     properties = {
-        'name': "[AST_SymbolDeclaration?] the name of this class",
-        'init': "[AST_Function] constructor for the class",
-        'parent': "[AST_Symbol?] parent class this class inherits from",
-        'bases': "[AST_Symbol*] list of base classes this class inherits from",
-        "static": "[dict] A hash whose keys are names of static methods for this class",
-        'external': "[boolean] true if class is declared elsewhere, but will be within current scope at runtime",
-        'bound': "[string*] list of methods that need to be bound to self",
-        'decorators': "[AST_Decorator*] function decorators, if any",
-        'module_id': "[string] The id of the module this class is defined in",
-        'statements': "[AST_Node*] list of statements in the class scope (excluding method definitions)",
+        'name': '[AST_SymbolDeclaration?] the name of this class',
+        'init': '[AST_Function] constructor for the class',
+        'parent': '[AST_Symbol?] parent class this class inherits from',
+        'bases': '[AST_Symbol*] list of base classes this class inherits from',
+        'static': '[dict] A hash whose keys are names of static methods for this class',
+        'external': '[boolean] true if class is declared elsewhere, but will be within current scope at runtime',
+        'bound': '[string*] list of methods that need to be bound to self',
+        'decorators': '[AST_Decorator*] function decorators, if any',
+        'module_id': '[string] The id of the module this class is defined in',
+        'statements': '[AST_Node*] list of statements in the class scope (excluding method definitions)',
         'dynamic_properties': '[dict] map of dynamic property names to property descriptors of the form {getter:AST_Method, setter:AST_Method',
         'classvars': '[dict] map containing all class variables as keys, to be used to easily test for existence of a class variable',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             if self.decorators:
                 for d in self.decorators:
                     d.walk(visitor)
@@ -432,65 +478,88 @@ class AST_Class(AST_Scope):
             if (self.parent) self.parent._walk(visitor)
         )
 
+
 class AST_Method(AST_Lambda):
-    "A class method definition"
+    'A class method definition'
     properties = {
-        "static": "[boolean] true if method is static",
-        "is_getter": "[boolean] true if method is a property getter",
-        "is_setter": "[boolean] true if method is a property setter",
+        'static': '[boolean] true if method is static',
+        'is_getter': '[boolean] true if method is a property getter',
+        'is_setter': '[boolean] true if method is a property setter',
     }
 
 # }}}
 
 # Jumps(break/continue/etc) {{{
 
+
 class AST_Jump(AST_Statement):
     "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)"
 
+
 class AST_Exit(AST_Jump):
-    "Base class for “exits” (`return` and `throw`)"
+    'Base class for “exits” (`return` and `throw`)'
     properties = {
-        'value': "[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return"
+        'value': '[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             if self.value:
                 self.value._walk(visitor)
         )
 
+
 class AST_Return(AST_Exit):
-    "A `return` statement"
+    'A `return` statement'
+
 
 class AST_Yield(AST_Return):
-    "A `yield` statement"
+    'A `yield` statement'
+    properties = {
+        'is_yield_from': '[bool] True iff this is a yield from, False otherwise'
+    }
+
+
+class AST_Await(AST_Node):
+    'An await expression'
     properties = {
-        'is_yield_from': "[bool] True iff this is a yield from, False otherwise"
+        'value': '[AST_Node] the expression being awaited'
     }
 
+    def _walk(self, visitor):
+        return visitor._visit(self, def ():
+            if self.value:
+                self.value._walk(visitor)
+        )
+
+
 class AST_Throw(AST_Exit):
-    "A `throw` statement"
+    'A `throw` statement'
+
 
 class AST_LoopControl(AST_Jump):
-    "Base class for loop control statements (`break` and `continue`)"
+    'Base class for loop control statements (`break` and `continue`)'
+
 
 class AST_Break(AST_LoopControl):
-    "A `break` statement"
+    'A `break` statement'
+
 
 class AST_Continue(AST_LoopControl):
-    "A `continue` statement"
+    'A `continue` statement'
 # }}}
 
+
 # If {{{
 class AST_If(AST_StatementWithBody):
-    "A `if` statement"
+    'A `if` statement'
     properties = {
-        'condition': "[AST_Node] the `if` condition",
-        'alternative': "[AST_Statement?] the `else` part, or null if not present"
+        'condition': '[AST_Node] the `if` condition',
+        'alternative': '[AST_Statement?] the `else` part, or null if not present'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.condition._walk(visitor)
             self.body._walk(visitor)
             if self.alternative:
@@ -500,39 +569,40 @@ class AST_If(AST_StatementWithBody):
 
 # EXCEPTIONS {{{
 
+
 class AST_Try(AST_Block):
-    "A `try` statement"
+    'A `try` statement'
     properties = {
-        'bcatch': "[AST_Catch?] the catch block, or null if not present",
-        'bfinally': "[AST_Finally?] the finally block, or null if not present",
+        'bcatch': '[AST_Catch?] the catch block, or null if not present',
+        'bfinally': '[AST_Finally?] the finally block, or null if not present',
         'belse': '[AST_Else?] the else block for null if not present',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             walk_body(self, visitor)
             if self.bcatch:
                 self.bcatch._walk(visitor)
-
             if self.belse:
                 self.belse._walk(visitor)
-
             if self.bfinally:
                 self.bfinally._walk(visitor)
         )
 
+
 class AST_Catch(AST_Block):
-    "A `catch` node; only makes sense as part of a `try` statement"
+    'A `catch` node; only makes sense as part of a `try` statement'
+
 
 class AST_Except(AST_Block):
-    "An `except` node for RapydScript, which resides inside the catch block"
+    'An `except` node for RapydScript, which resides inside the catch block'
     properties = {
-        'argname': "[AST_SymbolCatch] symbol for the exception",
-        'errors': "[AST_SymbolVar*] error classes to catch in this block"
+        'argname': '[AST_SymbolCatch] symbol for the exception',
+        'errors': '[AST_SymbolVar*] error classes to catch in this block'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(this, def():
+        return visitor._visit(this, def ():
             if (self.argname):
                 self.argname.walk(visitor)
             if (self.errors):
@@ -540,39 +610,44 @@ class AST_Except(AST_Block):
             walk_body(self, visitor)
         )
 
+
 class AST_Finally(AST_Block):
-    "A `finally` node; only makes sense as part of a `try` statement"
+    'A `finally` node; only makes sense as part of a `try` statement'
+
 
 class AST_Else(AST_Block):
     'An `else` node; only makes sense as part of `try` statement'
 
 # }}}
 
+
 # VAR/CONST {{{
 class AST_Definitions(AST_Statement):
-    "Base class for `var` or `const` nodes (variable declarations/initializations)"
+    'Base class for `var` or `const` nodes (variable declarations/initializations)'
     properties = {
-        'definitions': "[AST_VarDef*] array of variable definitions"
+        'definitions': '[AST_VarDef*] array of variable definitions'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             for def_ in self.definitions:
                 def_._walk(visitor)
         )
 
+
 class AST_Var(AST_Definitions):
-    "A `var` statement"
+    'A `var` statement'
+
 
 class AST_VarDef(AST_Node):
-    "A variable declaration; only appears in a AST_Definitions node"
+    'A variable declaration; only appears in a AST_Definitions node'
     properties = {
-        'name': "[AST_SymbolVar|AST_SymbolNonlocal] name of the variable",
+        'name': '[AST_SymbolVar|AST_SymbolNonlocal] name of the variable',
         'value': "[AST_Node?] initializer, or null if there's no initializer"
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.name._walk(visitor)
             if self.value:
                 self.value._walk(visitor)
@@ -581,61 +656,87 @@ class AST_VarDef(AST_Node):
 
 # Miscellaneous {{{
 
-class AST_BaseCall(AST_Node):
-    "A base class for function calls"
+
+class AST_CallArg(AST_Node):
+    'A single positional argument in a function call'
     properties = {
-        'args': "[AST_Node*] array of arguments"
+        'value': '[AST_Node] the argument expression',
+        'is_array': '[bool] True if this is a *arg (already an array/iterable)',
     }
 
-class AST_Call(AST_BaseCall):
-    "A function call expression"
+    def _walk(self, visitor):
+        return visitor._visit(self, def ():
+            self.value._walk(visitor)
+        )
+
+
+class AST_CallArgs(AST_Node):
+    'The argument list for a function call'
     properties = {
-        'expression': "[AST_Node] expression to invoke as function"
+        'args': '[AST_CallArg*] positional arguments',
+        'kwargs': '[pair*] keyword argument pairs [key_node, value_node]',
+        'kwarg_items': '[AST_SymbolRef*] **kwargs symbol references',
+        'starargs': '[bool] True if *args were used in this call',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
-            self.expression._walk(visitor)
+        return visitor._visit(self, def ():
             for arg in self.args:
                 arg._walk(visitor)
-            if self.args.kwargs:
-                for arg in self.args.kwargs:
-                    arg[0]._walk(visitor)
-                    arg[1]._walk(visitor)
-            if self.args.kwarg_items:
-                for arg in self.args.kwarg_items:
+            if self.kwargs:
+                for pair in self.kwargs:
+                    pair[0]._walk(visitor)
+                    pair[1]._walk(visitor)
+            if self.kwarg_items:
+                for arg in self.kwarg_items:
                     arg._walk(visitor)
         )
 
 
+class AST_BaseCall(AST_Node):
+    'A base class for function calls'
+    properties = {
+        'args': '[AST_CallArgs] the function call argument list'
+    }
+
+
+class AST_Call(AST_BaseCall):
+    'A function call expression'
+    properties = {
+        'expression': '[AST_Node] expression to invoke as function'
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def ():
+            self.expression._walk(visitor)
+            self.args._walk(visitor)
+        )
+
+
 class AST_ClassCall(AST_BaseCall):
-    "A function call expression"
+    'A function call expression'
     properties = {
-        "class": "[string] name of the class method belongs to",
-        'method': "[string] class method being called",
-        "static": "[boolean] defines whether the method is static"
+        'class': '[string] name of the class method belongs to',
+        'method': '[string] class method being called',
+        'static': '[boolean] defines whether the method is static'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             if (self.expression) self.expression._walk(visitor)
-            for arg in self.args:
-                arg._walk(visitor)
-            for arg in self.args.kwargs:
-                arg[0]._walk(visitor)
-                arg[1]._walk(visitor)
-            for arg in self.args.kwarg_items:
-                arg._walk(visitor)
+            self.args._walk(visitor)
         )
 
+
 class AST_New(AST_Call):
-    "An object instantiation. Derives from a function call since it has exactly the same properties"
+    'An object instantiation. Derives from a function call since it has exactly the same properties'
+
 
 class AST_Seq(AST_Node):
-    "A sequence expression (two comma-separated expressions)"
+    'A sequence expression (two comma-separated expressions)'
     properties = {
-        'car': "[AST_Node] first element in sequence",
-        'cdr': "[AST_Node] second element in sequence"
+        'car': '[AST_Node] first element in sequence',
+        'cdr': '[AST_Node] second element in sequence'
     }
 
     def to_array(self):
@@ -658,7 +759,7 @@ class AST_Seq(AST_Node):
             p = p.cdr
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.car._walk(visitor)
             if self.cdr:
                 self.cdr._walk(visitor)
@@ -680,7 +781,7 @@ class AST_Seq(AST_Node):
             return array[0].clone()
 
         ans = None
-        for i in range(array.length-1, -1, -1):
+        for i in range(array.length - 1, -1, -1):
             ans = AST_Seq.cons(array[i], ans)
 
         p = ans
@@ -691,120 +792,131 @@ class AST_Seq(AST_Node):
             p = p.cdr
         return ans
 
+
 class AST_PropAccess(AST_Node):
     'Base class for property access expressions, i.e. `a.foo` or `a["foo"]`'
     properties = {
-        'expression': "[AST_Node] the “container” expression",
+        'expression': '[AST_Node] the “container” expression',
         'property': "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node",
     }
 
+
 class AST_Dot(AST_PropAccess):
-    "A dotted property access expression"
+    'A dotted property access expression'
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.expression._walk(visitor)
         )
 
+
 class AST_Sub(AST_PropAccess):
     'Index-style property access, i.e. `a["foo"]`'
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.expression._walk(visitor)
             self.property._walk(visitor)
         )
 
+
 class AST_ItemAccess(AST_PropAccess):
     'Python index-style property access, i.e. `a.__getitem__("foo")`'
     properties = {
-        'assignment': "[AST_Node or None] Not None if this is an assignment (a[x] = y) rather than a simple access",
-        'assign_operator': "[String] The operator for a assignment like += or empty string if plain assignment",
+        'assignment': '[AST_Node or None] Not None if this is an assignment (a[x] = y) rather than a simple access',
+        'assign_operator': '[String] The operator for a assignment like += or empty string if plain assignment',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.expression._walk(visitor)
             self.property._walk(visitor)
             if self.assignment:
                 self.assignment._walk(visitor)
         )
 
+
 class AST_Splice(AST_PropAccess):
     'Index-style property access, i.e. `a[3:5]`'
     properties = {
-        'property2': "[AST_Node] the 2nd property to access - typically ending index for the array.",
-        'assignment': "[AST_Node] The data being spliced in."
+        'property2': '[AST_Node] the 2nd property to access - typically ending index for the array.',
+        'assignment': '[AST_Node] The data being spliced in.'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.expression._walk(visitor)
             self.property._walk(visitor)
             self.property2._walk(visitor)
         )
 
+
 class AST_Unary(AST_Node):
-    "Base class for unary expressions"
+    'Base class for unary expressions'
     properties = {
-        'operator': "[string] the operator",
-        'expression': "[AST_Node] expression that this unary operator applies to",
-        'parenthesized': "[bool] Whether this unary expression was parenthesized",
+        'operator': '[string] the operator',
+        'expression': '[AST_Node] expression that this unary operator applies to',
+        'parenthesized': '[bool] Whether this unary expression was parenthesized',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.expression._walk(visitor)
         )
 
+
 class AST_UnaryPrefix(AST_Unary):
-    "Unary prefix expression, i.e. `typeof i` or `del i`"
+    'Unary prefix expression, i.e. `typeof i` or `del i`'
+
 
 class AST_Binary(AST_Node):
-    "Binary expression, i.e. `a + b`"
+    'Binary expression, i.e. `a + b`'
     properties = {
-        'left': "[AST_Node] left-hand side expression",
-        'operator': "[string] the operator",
-        'right': "[AST_Node] right-hand side expression"
+        'left': '[AST_Node] left-hand side expression',
+        'operator': '[string] the operator',
+        'right': '[AST_Node] right-hand side expression'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.left._walk(visitor)
             self.right._walk(visitor)
         )
 
+
 class AST_Existential(AST_Node):
-    "Existential operator a?"
+    'Existential operator a?'
     properties = {
-        'expression': "[AST_Node] The expression whose existence we need to check",
-    'after': "[None|string|AST_Node] is None when there is nothing following this operator, is a string when there is as AST_PropAccess following this operator, is an AST_Node if it is used a a shorthand for the conditional ternary, i.e. a ? b == a if a? else b",
+        'expression': '[AST_Node] The expression whose existence we need to check',
+        'after': '[None|string|AST_Node] is None when there is nothing following this operator, is a string when there is as AST_PropAccess following this operator, is an AST_Node if it is used a a shorthand for the conditional ternary, i.e. a ? b == a if a? else b',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.expression._walk(visitor)
             if self.after is not None and jstype(self.after) is 'object':
                 self.after._walk(visitor)
         )
 
+
 class AST_Conditional(AST_Node):
-    "Conditional expression using the ternary operator, i.e. `a if b else c`"
+    'Conditional expression using the ternary operator, i.e. `a if b else c`'
     properties = {
-        'condition': "[AST_Node]",
-        'consequent': "[AST_Node]",
-        'alternative': "[AST_Node]",
+        'condition': '[AST_Node]',
+        'consequent': '[AST_Node]',
+        'alternative': '[AST_Node]',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.condition._walk(visitor)
             self.consequent._walk(visitor)
             self.alternative._walk(visitor)
         )
 
+
 class AST_Assign(AST_Binary):
-    "An assignment expression — `a = b + 5`"
+    'An assignment expression — `a = b + 5`'
 
     def is_chained(self):
         return is_node_type(self.right, AST_Assign) or (
@@ -820,7 +932,7 @@ class AST_Assign(AST_Binary):
                 continue
             if is_node_type(right, AST_Seq):
                 if is_node_type(right.car, AST_Assign):
-                    right = new AST_Seq({'car':right.car.right, 'cdr': right.cdr})
+                    right = new AST_Seq({'car': right.car.right, 'cdr': right.cdr})
                     continue
                 if is_node_type(right.cdr, AST_Assign):
                     right = right.cdr.right
@@ -836,7 +948,7 @@ class AST_Assign(AST_Binary):
             if is_node_type(next, AST_Seq):
                 if is_node_type(next.cdr, AST_Assign):
                     assign = next.cdr
-                    left_hand_sides.push(new AST_Seq({'car':next.car, 'cdr':assign.left}))
+                    left_hand_sides.push(new AST_Seq({'car': next.car, 'cdr': assign.left}))
                     next = assign.right
                     continue
             break
@@ -847,14 +959,15 @@ class AST_Assign(AST_Binary):
 
 # LITERALS {{{
 
+
 class AST_Array(AST_Node):
-    "An array literal"
+    'An array literal'
     properties = {
-        'elements': "[AST_Node*] array of elements"
+        'elements': '[AST_Node*] array of elements'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             for el in self.elements:
                 el._walk(visitor)
         )
@@ -874,194 +987,227 @@ class AST_Array(AST_Node):
             return ans
         return flatten(self.elements)
 
+
 class AST_Object(AST_Node):
-    "An object literal"
+    'An object literal'
     properties = {
-        'properties': "[AST_ObjectProperty*] array of properties",
-        'is_pydict': "[bool] True if this object is a python dict literal",
-        'is_jshash': "[bool] True if this object is a js hash literal",
+        'properties': '[AST_ObjectProperty*] array of properties',
+        'is_pydict': '[bool] True if this object is a python dict literal',
+        'is_jshash': '[bool] True if this object is a js hash literal',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             for prop in self.properties:
                 prop._walk(visitor)
         )
 
+
 class AST_ExpressiveObject(AST_Object):
     'An object literal with expressions for some keys'
 
+
 class AST_ObjectProperty(AST_Node):
-    "Base class for literal object properties"
+    'Base class for literal object properties'
     properties = {
-        'key': "[AST_Node] the property expression",
-        'value': "[AST_Node] property value.  For setters and getters this is an AST_Function.",
+        'key': '[AST_Node] the property expression',
+        'value': '[AST_Node] property value.  For setters and getters this is an AST_Function.',
         'quoted': '',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.key._walk(visitor)
             self.value._walk(visitor)
         )
 
+
 class AST_ObjectKeyVal(AST_ObjectProperty):
-    "A key: value object property"
+    'A key: value object property'
+
 
 class AST_Set(AST_Node):
-    "A set literal"
+    'A set literal'
     properties = {
-        'items': "[AST_SetItem*] array of items"
+        'items': '[AST_SetItem*] array of items'
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             for prop in self.items:
                 prop._walk(visitor)
         )
 
+
 class AST_SetItem(AST_Node):
-    "An item in a set literal"
+    'An item in a set literal'
     properties = {
-        'value': "[AST_Node] The value of this item",
+        'value': '[AST_Node] The value of this item',
     }
 
     def _walk(self, visitor):
-        return visitor._visit(self, def():
+        return visitor._visit(self, def ():
             self.value._walk(visitor)
         )
 
+
 class AST_Symbol(AST_Node):
-    "Base class for all symbols"
+    'Base class for all symbols'
     properties = {
-        'name': "[string] name of this symbol",
-        'scope': "[AST_Scope/S] the current scope (not necessarily the definition scope)",
-        'thedef': "[SymbolDef/S] the definition of this symbol"
+        'name': '[string] name of this symbol',
+        'scope': '[AST_Scope/S] the current scope (not necessarily the definition scope)',
+        'thedef': '[SymbolDef/S] the definition of this symbol'
     }
 
+
 class AST_SymbolAlias(AST_Symbol):
-    "An alias used in an import statement or with statement"
+    'An alias used in an import statement or with statement'
+
 
 class AST_SymbolDeclaration(AST_Symbol):
-    "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)"
+    'A declaration symbol (symbol in var/const, function name or argument, symbol in catch)'
     properties = {
-        'init': "[AST_Node*/S] array of initializers for this declaration."
+        'init': '[AST_Node*/S] array of initializers for this declaration.'
     }
 
+
 class AST_SymbolVar(AST_SymbolDeclaration):
-    "Symbol defining a variable"
+    'Symbol defining a variable'
+
 
 class AST_ImportedVar(AST_SymbolVar):
-    "Symbol defining an imported symbol"
+    'Symbol defining an imported symbol'
     properties = {
-        'alias': "AST_SymbolAlias the alias for this imported symbol"
+        'alias': 'AST_SymbolAlias the alias for this imported symbol'
     }
 
+
 class AST_SymbolNonlocal(AST_SymbolDeclaration):
-    "A nonlocal declaration"
+    'A nonlocal declaration'
+
 
 class AST_SymbolFunarg(AST_SymbolVar):
-    "Symbol naming a function argument, possibly with an annotation."
+    'Symbol naming a function argument, possibly with an annotation.'
     properties = {
-        'annotation': "[AST_Node?] The annotation provided for this argument (if any)"
+        'annotation': '[AST_Node?] The annotation provided for this argument (if any)'
     }
 
+
 class AST_SymbolDefun(AST_SymbolDeclaration):
-    "Symbol defining a function"
+    'Symbol defining a function'
+
 
 class AST_SymbolLambda(AST_SymbolDeclaration):
-    "Symbol naming a function expression"
+    'Symbol naming a function expression'
+
 
 class AST_SymbolCatch(AST_SymbolDeclaration):
-    "Symbol naming the exception in catch"
+    'Symbol naming the exception in catch'
+
 
 class AST_SymbolRef(AST_Symbol):
-    "Reference to some symbol (not definition/declaration)"
+    'Reference to some symbol (not definition/declaration)'
     properties = {
-        'parens': "[boolean/S] if true, this variable is wrapped in parentheses"
+        'parens': '[boolean/S] if true, this variable is wrapped in parentheses'
     }
 
+
 class AST_This(AST_Symbol):
-    "The `this` symbol"
+    'The `this` symbol'
+
 
 class AST_Constant(AST_Node):
-    "Base class for all constants"
+    'Base class for all constants'
+
 
 class AST_String(AST_Constant):
-    "A string literal"
+    'A string literal'
     properties = {
-        'value': "[string] the contents of this string"
+        'value': '[string] the contents of this string'
     }
 
+
 class AST_Verbatim(AST_Constant):
-    "Raw JavaScript code"
+    'Raw JavaScript code'
     properties = {
-        'value': "[string] A string of raw JS code"
+        'value': '[string] A string of raw JS code'
     }
 
+
 class AST_Number(AST_Constant):
-    "A number literal"
+    'A number literal'
     properties = {
-        'value': "[number] the numeric value"
+        'value': '[number] the numeric value'
     }
 
+
 class AST_RegExp(AST_Constant):
-    "A regexp literal"
+    'A regexp literal'
     properties = {
-        'value': "[RegExp] the actual regexp"
+        'value': '[RegExp] the actual regexp'
     }
 
+
 class AST_Atom(AST_Constant):
-    "Base class for atoms"
+    'Base class for atoms'
+
     def __init__(self, initializer):
         if initializer:
             self.start = initializer.start
             self.end = initializer.end
 
+
 class AST_Null(AST_Atom):
-    "The `null` atom"
+    'The `null` atom'
     value = None
 
+
 class AST_NaN(AST_Atom):
-    "The impossible value"
+    'The impossible value'
     value = v'NaN'
 
+
 class AST_Undefined(AST_Atom):
-    "The `undefined` value"
+    'The `undefined` value'
     value = v'undefined'
 
+
 class AST_Hole(AST_Atom):
-    "A hole in an array"
+    'A hole in an array'
     value = v'undefined'
 
+
 class AST_Infinity(AST_Atom):
-    "The `Infinity` value"
+    'The `Infinity` value'
     value = v'Infinity'
 
+
 class AST_Boolean(AST_Atom):
-    "Base class for booleans"
+    'Base class for booleans'
+
 
 class AST_False(AST_Boolean):
-    "The `false` atom"
+    'The `false` atom'
     value = False
 
+
 class AST_True(AST_Boolean):
-    "The `true` atom"
+    'The `true` atom'
     value = True
 
 # }}}
 
 # TreeWalker {{{
 
-class TreeWalker:
 
+class TreeWalker:
     def __init__(self, callback):
         self.visit = callback
         self.stack = []
 
     def _visit(self, node, descend):
         self.stack.push(node)
-        ret = self.visit(node, ((def(): descend.call(node);) if descend else noop))
+        ret = self.visit(node, ((def (): descend.call(node);) if descend else noop))
         if not ret and descend:
             descend.call(node)
 
@@ -1082,7 +1228,7 @@ class TreeWalker:
 
     def find_parent(self, type):
         stack = self.stack
-        for i in range(stack.length-1, -1, -1):
+        for i in range(stack.length - 1, -1, -1):
             x = stack[i]
             if is_node_type(x, type):
                 return x
@@ -1096,16 +1242,18 @@ class TreeWalker:
             if is_node_type(p, AST_If) and p.condition is self
             or is_node_type(p, AST_Conditional) and p.condition is self
             or is_node_type(p, AST_DWLoop) and p.condition is self
-            or is_node_type(p, AST_UnaryPrefix) and p.operator is "!" and p.expression is self:
+            or is_node_type(p, AST_UnaryPrefix) and p.operator is '!' and p.expression is self:
                 return True
-            if not (is_node_type(p, AST_Binary) and (p.operator is "&&" or p.operator is "||")):
+            if not (is_node_type(p, AST_Binary) and (p.operator is '&&' or p.operator is '||')):
                 return False
             self = p
 # }}}
 
+
 class Found(Exception):
     pass
 
+
 def has_calls(expression):
     # Technically, in JavaScript property access is also dynamic and can
     # involve function calls. However, there is no way to determine which
@@ -1114,7 +1262,7 @@ def has_calls(expression):
     if not expression:
         return False
     try:
-        expression.walk(new TreeWalker(def(node):
+        expression.walk(new TreeWalker(def (node):
             if is_node_type(node, AST_BaseCall) or is_node_type(node, AST_ItemAccess):
                 raise Found()
         ))