admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 1 | # -*- coding: utf-8 -*- |
| 2 | """ |
| 3 | ast |
| 4 | ~~~ |
| 5 | |
| 6 | The `ast` module helps Python applications to process trees of the Python |
| 7 | abstract syntax grammar. The abstract syntax itself might change with |
| 8 | each Python release; this module helps to find out programmatically what |
| 9 | the current grammar looks like and allows modifications of it. |
| 10 | |
| 11 | An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as |
| 12 | a flag to the `compile()` builtin function or by using the `parse()` |
| 13 | function from this module. The result will be a tree of objects whose |
| 14 | classes all inherit from `ast.AST`. |
| 15 | |
| 16 | A modified abstract syntax tree can be compiled into a Python code object |
| 17 | using the built-in `compile()` function. |
| 18 | |
| 19 | Additionally various helper functions are provided that make working with |
| 20 | the trees simpler. The main intention of the helper functions and this |
| 21 | module in general is to provide an easy to use interface for libraries |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 22 | that work tightly with the python syntax ( template engines for example ). |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 23 | |
| 24 | |
| 25 | :copyright: Copyright 2008 by Armin Ronacher. |
| 26 | :license: Python License. |
| 27 | """ |
| 28 | from _ast import * |
| 29 | from _ast import __version__ |
| 30 | |
| 31 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 32 | def parse( source, filename='<unknown>', mode='exec' ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 33 | """ |
| 34 | Parse the source into an AST node. |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 35 | Equivalent to compile( source, filename, mode, PyCF_ONLY_AST ). |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 36 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 37 | return compile( source, filename, mode, PyCF_ONLY_AST ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 38 | |
| 39 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 40 | def literal_eval( node_or_string ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 41 | """ |
| 42 | Safely evaluate an expression node or a string containing a Python |
| 43 | expression. The string or node provided may only consist of the following |
| 44 | Python literal structures: strings, numbers, tuples, lists, dicts, booleans, |
| 45 | and None. |
| 46 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 47 | _safe_names = { 'None': None, 'True': True, 'False': False } |
| 48 | if isinstance( node_or_string, basestring ): |
| 49 | node_or_string = parse( node_or_string, mode='eval' ) |
| 50 | if isinstance( node_or_string, Expression ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 51 | node_or_string = node_or_string.body |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 52 | |
| 53 | def _convert( node ): |
| 54 | if isinstance( node, Str ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 55 | return node.s |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 56 | elif isinstance( node, Num ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 57 | return node.n |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 58 | elif isinstance( node, Tuple ): |
| 59 | return tuple( map( _convert, node.elts ) ) |
| 60 | elif isinstance( node, List ): |
| 61 | return list( map( _convert, node.elts ) ) |
| 62 | elif isinstance( node, Dict ): |
| 63 | return dict( ( _convert( k ), _convert( v ) ) for k, v |
| 64 | in zip( node.keys, node.values ) ) |
| 65 | elif isinstance( node, Name ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 66 | if node.id in _safe_names: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 67 | return _safe_names[ node.id ] |
| 68 | elif isinstance( node, BinOp ) and \ |
| 69 | isinstance( node.op, ( Add, Sub ) ) and \ |
| 70 | isinstance( node.right, Num ) and \ |
| 71 | isinstance( node.right.n, complex ) and \ |
| 72 | isinstance( node.left, Num ) and \ |
| 73 | isinstance( node.left.n, ( int, long, float ) ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 74 | left = node.left.n |
| 75 | right = node.right.n |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 76 | if isinstance( node.op, Add ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 77 | return left + right |
| 78 | else: |
| 79 | return left - right |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 80 | raise ValueError( 'malformed string' ) |
| 81 | return _convert( node_or_string ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 82 | |
| 83 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 84 | def dump( node, annotate_fields=True, include_attributes=False ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 85 | """ |
| 86 | Return a formatted dump of the tree in *node*. This is mainly useful for |
| 87 | debugging purposes. The returned string will show the names and the values |
| 88 | for fields. This makes the code impossible to evaluate, so if evaluation is |
| 89 | wanted *annotate_fields* must be set to False. Attributes such as line |
| 90 | numbers and column offsets are not dumped by default. If this is wanted, |
| 91 | *include_attributes* can be set to True. |
| 92 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 93 | def _format( node ): |
| 94 | if isinstance( node, AST ): |
| 95 | fields = [ ( a, _format( b ) ) for a, b in iter_fields( node ) ] |
| 96 | rv = '%s(%s' % ( node.__class__.__name__, ', '.join( |
| 97 | ( '%s=%s' % field for field in fields ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 98 | if annotate_fields else |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 99 | ( b for a, b in fields ) |
| 100 | ) ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 101 | if include_attributes and node._attributes: |
| 102 | rv += fields and ', ' or ' ' |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 103 | rv += ', '.join( '%s=%s' % ( a, _format( getattr( node, a ) ) ) |
| 104 | for a in node._attributes ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 105 | return rv + ')' |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 106 | elif isinstance( node, list ): |
| 107 | return '[%s]' % ', '.join( _format( x ) for x in node ) |
| 108 | return repr( node ) |
| 109 | if not isinstance( node, AST ): |
| 110 | raise TypeError( 'expected AST, got %r' % node.__class__.__name__ ) |
| 111 | return _format( node ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 112 | |
| 113 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 114 | def copy_location( new_node, old_node ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 115 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 116 | Copy source location ( `lineno` and `col_offset` attributes ) from |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 117 | *old_node* to *new_node* if possible, and return *new_node*. |
| 118 | """ |
| 119 | for attr in 'lineno', 'col_offset': |
| 120 | if attr in old_node._attributes and attr in new_node._attributes \ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 121 | and hasattr( old_node, attr ): |
| 122 | setattr( new_node, attr, getattr( old_node, attr ) ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 123 | return new_node |
| 124 | |
| 125 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 126 | def fix_missing_locations( node ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 127 | """ |
| 128 | When you compile a node tree with compile(), the compiler expects lineno and |
| 129 | col_offset attributes for every node that supports them. This is rather |
| 130 | tedious to fill in for generated nodes, so this helper adds these attributes |
| 131 | recursively where not already set, by setting them to the values of the |
| 132 | parent node. It works recursively starting at *node*. |
| 133 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 134 | def _fix( node, lineno, col_offset ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 135 | if 'lineno' in node._attributes: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 136 | if not hasattr( node, 'lineno' ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 137 | node.lineno = lineno |
| 138 | else: |
| 139 | lineno = node.lineno |
| 140 | if 'col_offset' in node._attributes: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 141 | if not hasattr( node, 'col_offset' ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 142 | node.col_offset = col_offset |
| 143 | else: |
| 144 | col_offset = node.col_offset |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 145 | for child in iter_child_nodes( node ): |
| 146 | _fix( child, lineno, col_offset ) |
| 147 | _fix( node, 1, 0 ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 148 | return node |
| 149 | |
| 150 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 151 | def increment_lineno( node, n=1 ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 152 | """ |
| 153 | Increment the line number of each node in the tree starting at *node* by *n*. |
| 154 | This is useful to "move code" to a different location in a file. |
| 155 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 156 | for child in walk( node ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 157 | if 'lineno' in child._attributes: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 158 | child.lineno = getattr( child, 'lineno', 0 ) + n |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 159 | return node |
| 160 | |
| 161 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 162 | def iter_fields( node ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 163 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 164 | Yield a tuple of ``( fieldname, value )`` for each field in ``node._fields`` |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 165 | that is present on *node*. |
| 166 | """ |
| 167 | for field in node._fields: |
| 168 | try: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 169 | yield field, getattr( node, field ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 170 | except AttributeError: |
| 171 | pass |
| 172 | |
| 173 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 174 | def iter_child_nodes( node ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 175 | """ |
| 176 | Yield all direct child nodes of *node*, that is, all fields that are nodes |
| 177 | and all items of fields that are lists of nodes. |
| 178 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 179 | for name, field in iter_fields( node ): |
| 180 | if isinstance( field, AST ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 181 | yield field |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 182 | elif isinstance( field, list ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 183 | for item in field: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 184 | if isinstance( item, AST ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 185 | yield item |
| 186 | |
| 187 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 188 | def get_docstring( node, clean=True ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 189 | """ |
| 190 | Return the docstring for the given node or None if no docstring can |
| 191 | be found. If the node provided does not have docstrings a TypeError |
| 192 | will be raised. |
| 193 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 194 | if not isinstance( node, ( FunctionDef, ClassDef, Module ) ): |
| 195 | raise TypeError( "%r can't have docstrings" % node.__class__.__name__ ) |
| 196 | if node.body and isinstance( node.body[ 0 ], Expr ) and \ |
| 197 | isinstance( node.body[ 0 ].value, Str ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 198 | if clean: |
| 199 | import inspect |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 200 | return inspect.cleandoc( node.body[ 0 ].value.s ) |
| 201 | return node.body[ 0 ].value.s |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 202 | |
| 203 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 204 | def walk( node ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 205 | """ |
| 206 | Recursively yield all descendant nodes in the tree starting at *node* |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 207 | ( including *node* itself ), in no specified order. This is useful if you |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 208 | only want to modify nodes in place and don't care about the context. |
| 209 | """ |
| 210 | from collections import deque |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 211 | todo = deque( [ node ] ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 212 | while todo: |
| 213 | node = todo.popleft() |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 214 | todo.extend( iter_child_nodes( node ) ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 215 | yield node |
| 216 | |
| 217 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 218 | class NodeVisitor( object ): |
| 219 | |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 220 | """ |
| 221 | A node visitor base class that walks the abstract syntax tree and calls a |
| 222 | visitor function for every node found. This function may return a value |
| 223 | which is forwarded by the `visit` method. |
| 224 | |
| 225 | This class is meant to be subclassed, with the subclass adding visitor |
| 226 | methods. |
| 227 | |
| 228 | Per default the visitor functions for the nodes are ``'visit_'`` + |
| 229 | class name of the node. So a `TryFinally` node visit function would |
| 230 | be `visit_TryFinally`. This behavior can be changed by overriding |
| 231 | the `visit` method. If no visitor function exists for a node |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 232 | ( return value `None` ) the `generic_visit` visitor is used instead. |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 233 | |
| 234 | Don't use the `NodeVisitor` if you want to apply changes to nodes during |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 235 | traversing. For this a special visitor exists ( `NodeTransformer` ) that |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 236 | allows modifications. |
| 237 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 238 | def visit( self, node ): |
| 239 | "Visit a node." |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 240 | method = 'visit_' + node.__class__.__name__ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 241 | visitor = getattr( self, method, self.generic_visit ) |
| 242 | return visitor( node ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 243 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 244 | def generic_visit( self, node ): |
| 245 | "Called if no explicit visitor function exists for a node." |
| 246 | for field, value in iter_fields( node ): |
| 247 | if isinstance( value, list ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 248 | for item in value: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 249 | if isinstance( item, AST ): |
| 250 | self.visit( item ) |
| 251 | elif isinstance( value, AST ): |
| 252 | self.visit( value ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 253 | |
| 254 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 255 | class NodeTransformer( NodeVisitor ): |
| 256 | |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 257 | """ |
| 258 | A :class:`NodeVisitor` subclass that walks the abstract syntax tree and |
| 259 | allows modification of nodes. |
| 260 | |
| 261 | The `NodeTransformer` will walk the AST and use the return value of the |
| 262 | visitor methods to replace or remove the old node. If the return value of |
| 263 | the visitor method is ``None``, the node will be removed from its location, |
| 264 | otherwise it is replaced with the return value. The return value may be the |
| 265 | original node in which case no replacement takes place. |
| 266 | |
| 267 | Here is an example transformer that rewrites all occurrences of name lookups |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 268 | ( ``foo`` ) to ``data[ 'foo' ]``:: |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 269 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 270 | class RewriteName( NodeTransformer ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 271 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 272 | def visit_Name( self, node ): |
| 273 | return copy_location( Subscript( |
| 274 | value=Name( id='data', ctx=Load() ), |
| 275 | slice=Index( value=Str( s=node.id ) ), |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 276 | ctx=node.ctx |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 277 | ), node ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 278 | |
| 279 | Keep in mind that if the node you're operating on has child nodes you must |
| 280 | either transform the child nodes yourself or call the :meth:`generic_visit` |
| 281 | method for the node first. |
| 282 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 283 | For nodes that were part of a collection of statements ( that applies to all |
| 284 | statement nodes ), the visitor may also return a list of nodes rather than |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 285 | just a single node. |
| 286 | |
| 287 | Usually you use the transformer like this:: |
| 288 | |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 289 | node = YourTransformer().visit( node ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 290 | """ |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 291 | def generic_visit( self, node ): |
| 292 | for field, old_value in iter_fields( node ): |
| 293 | old_value = getattr( node, field, None ) |
| 294 | if isinstance( old_value, list ): |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 295 | new_values = [] |
| 296 | for value in old_value: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 297 | if isinstance( value, AST ): |
| 298 | value = self.visit( value ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 299 | if value is None: |
| 300 | continue |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 301 | elif not isinstance( value, AST ): |
| 302 | new_values.extend( value ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 303 | continue |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 304 | new_values.append( value ) |
| 305 | old_value[ : ] = new_values |
| 306 | elif isinstance( old_value, AST ): |
| 307 | new_node = self.visit( old_value ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 308 | if new_node is None: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 309 | delattr( node, field ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 310 | else: |
Jeremy Ronquillo | 23fb216 | 2017-09-15 14:59:57 -0700 | [diff] [blame] | 311 | setattr( node, field, new_node ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 312 | return node |