def atom_rewrite(loc, name, number, strs, namedc, ellipsis, dict, is_dict, is_gen, is_list, comp, yield_expr): if name: return ast.Name(name.value, ast.Load(), **loc @ name) if number: return ast.Num(eval(number.value), **loc @ number) if strs: return str_maker(*strs) if ellipsis: return ast.Ellipsis() if namedc: return ast.NameConstant(eval(namedc.value), **loc @ namedc) if is_dict: return dict or ex_ast.ExDict([], [], ast.Load(), **loc @ is_dict) if is_gen: if yield_expr: return yield_expr return comp(is_tuple=True) if comp else ast.Tuple([], ast.Load(), ** loc @ is_gen) if is_list: return comp(is_list=True) if comp else ast.List([], ast.Load(), ** loc @ is_list) raise TypeError
def value2pyliteral(val): # noqa: C901 """ Transforms a python value into a literal in AST form. """ if val is None: return ast.NameConstant(value=None) elif val is ...: return ast.Ellipsis() elif val is True: return ast.NameConstant(value=True) elif val is False: return ast.NameConstant(value=False) elif isinstance(val, int): return ast.Num(n=val) elif isinstance(val, float): return ast.Num(n=val) elif isinstance(val, str): return ast.Str(s=val) elif isinstance(val, bytes): return ast.Bytes(s=val) elif isinstance(val, tuple): return ast.Tuple(elts=[value2pyliteral(item) for item in val]) elif isinstance(val, list): return ast.List(elts=[value2pyliteral(item) for item in val]) elif isinstance(val, dict): return ast.Dict( # .keys() and .values() have been documented to return things in the # same order since Py2 keys=[value2pyliteral(item) for item in val.keys()], values=[value2pyliteral(item) for item in val.values()], ) elif isinstance(val, set): return ast.Set(elts=[value2pyliteral(item) for item in val]) else: raise ValueError(f"Can't translate {val!r} into a literal")
def test_deprecated_constant_nodes(self): self.assertAstEqualsSource( ast.Assign(targets=[ast.Name(id='spam')], value=ast.Num(3)), "spam = 3") self.assertAstEqualsSource( ast.Assign(targets=[ast.Name(id='spam')], value=ast.Num(-93)), "spam = -93") self.assertAstEqualsSource( ast.Assign(targets=[ast.Name(id='spam')], value=ast.Num(837.3888)), "spam = 837.3888") self.assertAstEqualsSource( ast.Assign(targets=[ast.Name(id='spam')], value=ast.Num(-0.9877)), "spam = -0.9877") self.assertAstEqualsSource(ast.Ellipsis(), "...") if sys.version_info >= (3, 0): self.assertAstEqualsSource( ast.Assign(targets=[ast.Name(id='spam')], value=ast.Bytes(b"Bytes")), "spam = b'Bytes'") self.assertAstEqualsSource( ast.Assign(targets=[ast.Name(id='spam')], value=ast.Str("String")), "spam = 'String'")
def ellipsis_word_visitor(node: concat.parse.EllipsisWordNode): """Converts a EllipsisWordNode to the Python expression `push(...)`.""" load = ast.Load() ellipsis = ast.Ellipsis() push_func = ast.Name(id='push', ctx=load) py_node = ast.Call(func=push_func, args=[ellipsis], keywords=[]) py_node.lineno, py_node.col_offset = node.location return py_node
def visit_Constant(self, node): if isinstance(node.value, (bool, int, long, float, complex)): new_node = ast.Num(node.value) elif node.value is Ellipsis: new_node = ast.Ellipsis() else: new_node = ast.Str(node.value) ast.copy_location(new_node, node) return new_node
def make_unconcat_slice(axis, lower, upper): dims = [] for i in range(axis): dims.append(ast.Slice(lower=None, upper=None, step=None)) dims.append(ast.Slice(lower=lower, upper=upper, step=None)) dims.append(ast.Ellipsis()) ext_slice = ast.ExtSlice(dims=dims) return ext_slice
def visit_Constant(self, node): if node.value is None: new_node = ast.NameConstant(node.value) elif node.value is Ellipsis: new_node = ast.Ellipsis() elif isinstance(node.value, bool): new_node = ast.NameConstant(node.value) elif isinstance(node.value, (int, float, complex)): new_node = ast.Num(node.value) elif isinstance(node.value, str): new_node = ast.Str(node.value) else: new_node = ast.Bytes(node.value) return ast.copy_location(new_node, node)
def test__get_literal_value(self): new_context = context.Context() value = ast.Num(42) expected = value.n self.assertEqual(expected, new_context._get_literal_value(value)) value = ast.Str('spam') expected = value.s self.assertEqual(expected, new_context._get_literal_value(value)) value = ast.List([ast.Str('spam'), ast.Num(42)], ast.Load()) expected = [ast.Str('spam').s, ast.Num(42).n] self.assertListEqual(expected, new_context._get_literal_value(value)) value = ast.Tuple([ast.Str('spam'), ast.Num(42)], ast.Load()) expected = (ast.Str('spam').s, ast.Num(42).n) self.assertTupleEqual(expected, new_context._get_literal_value(value)) value = ast.Set([ast.Str('spam'), ast.Num(42)]) expected = set([ast.Str('spam').s, ast.Num(42).n]) self.assertSetEqual(expected, new_context._get_literal_value(value)) value = ast.Dict(['spam', 'eggs'], [42, 'foo']) expected = dict(spam=42, eggs='foo') self.assertDictEqual(expected, new_context._get_literal_value(value)) value = ast.Ellipsis() self.assertIsNone(new_context._get_literal_value(value)) value = ast.Name('spam', ast.Load()) expected = value.id self.assertEqual(expected, new_context._get_literal_value(value)) if six.PY3: value = ast.NameConstant(True) expected = str(value.value) self.assertEqual(expected, new_context._get_literal_value(value)) if six.PY3: value = ast.Bytes(b'spam') expected = value.s self.assertEqual(expected, new_context._get_literal_value(value)) self.assertIsNone(new_context._get_literal_value(None))
def _annotation_for_value(value: object) -> Optional[ast.expr]: if value is None: return None name = type(value).__name__ if isinstance(value, (dict, list, set, tuple)): ann_elem = _annotation_for_elements(value) if isinstance(value, dict): ann_value = _annotation_for_elements(value.values()) if ann_value is None: ann_elem = None elif ann_elem is not None: ann_elem = ast.Tuple(elts=[ann_elem, ann_value]) if ann_elem is not None: if name == 'tuple': ann_elem = ast.Tuple(elts=[ann_elem, ast.Ellipsis()]) return ast.Subscript(value=ast.Name(id=name), slice=ast.Index(value=ann_elem)) return ast.Name(id=name)
def visit_AnnAssign(self, node: ast.AnnAssign) -> ast.Assign: # Here, we replace `x: A = a` with just `x = a`. In case there's no value, # we set the value to an `...`. E.g: `x: A` changes to `x = ...`. # # We need to be a little careful about ensuring that newly created nodes # get the line and column information copied to them. This helps us avoid # an extra pass over the AST with ast.fix_missing_locations() value = node.value if value is None: value = ast.Ellipsis() value.kind = None _copy_attrs(node, value) assign = ast.Assign(targets=[node.target], value=value, type_comment=None) _copy_attrs(node, assign) return assign
def test_simple_types(self): # string, integer, float, force casting xml = Parser(self.get_xml("basic_types.xml")) module = xml.parse() code = compile(module, "<ast>", "exec") mymodule = ast.Module([ ast.Expr(ast.Str("batuhan")), ast.Expr(ast.Num(15)), ast.Expr(ast.Num(15.5)), ast.Expr(ast.Str("13")), ast.Expr(ast.Ellipsis()), ast.Expr(ast.Bytes(bytes("a", "ASCII"))), ast.Expr(ast.Bytes(bytes("ş", "utf-8"))), ]) ast.fix_missing_locations(mymodule) mycode = compile(mymodule, "<ast>", "exec") pprint(mymodule) self.assertEqual(code, mycode)
def _maybe_inject_class_argument(hint_tree: ast.FunctionType, func_obj: Function) -> ast.FunctionType: """ Inject `self` or `cls` args into a type comment to align with PEP 3107-style annotations. Because PEP 484 does not describe a method to provide partial function-level type comments, there is a potential for ambiguity in the context of both class methods and classmethods when aligning type comments to method arguments. These two class methods, for example, should lint equivalently: def bar(self, a): # type: (int) -> int ... def bar(self, a: int) -> int ... When this example type comment is parsed by `ast` and then matched with the method's arguments, it associates the `int` hint to `self` rather than `a`, so a dummy hint needs to be provided in situations where `self` or `class` are not hinted in the type comment in order to achieve equivalent linting results to PEP-3107 style annotations. A dummy `ast.Ellipses` constant is injected if the following criteria are met: 1. The function node is either a class method or classmethod 2. The number of hinted args is at least 1 less than the number of function args """ if not func_obj.is_class_method: # Short circuit return hint_tree if func_obj.class_decorator_type != ClassDecoratorType.STATICMETHOD: if len(hint_tree.argtypes) < (len(func_obj.args) - 1): # Subtract 1 to skip return arg # Ignore mypy's objection to this assignment, Ellipsis subclasses expr so I'm not # sure how to make Mypy happy with this but I think it still makes semantic sense hint_tree.argtypes = [ ast.Ellipsis() ] + hint_tree.argtypes # type: ignore[assignment, operator] # noqa: E501 return hint_tree
def test__get_literal_value(self): new_context = context.Context() value = ast.Num(42) expected = value.n self.assertEqual(expected, new_context._get_literal_value(value)) value = ast.Str("spam") expected = value.s self.assertEqual(expected, new_context._get_literal_value(value)) value = ast.List([ast.Str("spam"), ast.Num(42)], ast.Load()) expected = [ast.Str("spam").s, ast.Num(42).n] self.assertListEqual(expected, new_context._get_literal_value(value)) value = ast.Tuple([ast.Str("spam"), ast.Num(42)], ast.Load()) expected = (ast.Str("spam").s, ast.Num(42).n) self.assertTupleEqual(expected, new_context._get_literal_value(value)) value = ast.Set([ast.Str("spam"), ast.Num(42)]) expected = {ast.Str("spam").s, ast.Num(42).n} self.assertSetEqual(expected, new_context._get_literal_value(value)) value = ast.Dict(["spam", "eggs"], [42, "foo"]) expected = dict(spam=42, eggs="foo") self.assertDictEqual(expected, new_context._get_literal_value(value)) value = ast.Ellipsis() self.assertIsNone(new_context._get_literal_value(value)) value = ast.Name("spam", ast.Load()) expected = value.id self.assertEqual(expected, new_context._get_literal_value(value)) value = ast.Bytes(b"spam") expected = value.s self.assertEqual(expected, new_context._get_literal_value(value)) self.assertIsNone(new_context._get_literal_value(None))
def as_ast(dct): """See https://docs.python.org/2/library/ast.html""" if dct['ast_type'] == "Module": return ast.Module(dct["body"]) elif dct['ast_type'] == "Interactive": return ast.Interactive(dct["body"]) elif dct['ast_type'] == "Expression": return ast.Expression(dct["body"]) elif dct['ast_type'] == "Suite": return ast.Suite(dct["body"]) elif dct['ast_type'] == "FunctionDef": return ast.FunctionDef(dct["name"], dct["args"], dct["body"], dct["decorator_list"]) elif dct['ast_type'] == "ClassDef": return ast.ClassDef(dct["name"], dct["bases"], dct["body"], dct["decorator_list"]) elif dct['ast_type'] == "Return": return ast.Return(dct["value"]) elif dct['ast_type'] == "Delete": return ast.Delete(dct["targets"]) elif dct['ast_type'] == "Assign": return ast.Assign(dct["targets"], dct["value"]) elif dct['ast_type'] == "AugAssign": return ast.AugAssign(dct["target"], dct["op"], dct["value"]) elif dct['ast_type'] == "Print": return ast.Print(dct["dest"], dct["values"], dct["nl"]) elif dct['ast_type'] == "For": return ast.For(dct["target"], dct["iter"], dct["body"], dct["orelse"]) elif dct['ast_type'] == "While": return ast.While(dct["test"], dct["body"], dct["orelse"]) elif dct['ast_type'] == "If": return ast.If(dct["test"], dct["body"], dct["orelse"]) elif dct['ast_type'] == "With": return ast.With(dct["context_expr"], dct["optional_vars"], dct["body"]) elif dct['ast_type'] == "Raise": return ast.Raise(dct["type"], dct["inst"], dct["tback"]) elif dct['ast_type'] == "TryExcept": return ast.TryExcept(dct["body"], dct["handlers"], dct["orelse"]) elif dct['ast_type'] == "TryFinally": return ast.TryFinally(dct["body"], dct["finalbody"]) elif dct['ast_type'] == "Assert": return ast.Assert(dct["test"], dct["msg"]) elif dct['ast_type'] == "Import": return ast.Import(dct["names"]) elif dct['ast_type'] == "ImportFrom": return ast.ImportFrom(dct["module"], dct["names"], dct["level"]) elif dct['ast_type'] == "Exec": return ast.Exec(dct["body"], dct["globals"], dct["locals"]) elif dct['ast_type'] == "Global": return ast.Global(dct["names"]) elif dct['ast_type'] == "Expr": return ast.Expr(dct["value"]) elif dct['ast_type'] == "Pass": return ast.Pass() elif dct['ast_type'] == "Break": return ast.Break() elif dct['ast_type'] == "Continue": return ast.Continue() elif dct['ast_type'] == "BoolOp": return ast.BoolOp(dct["op"], dct["values"]) elif dct['ast_type'] == "BinOp": return ast.BinOp(dct["left"], dct["op"], dct["right"]) elif dct['ast_type'] == "UnaryOp": return ast.UnaryOp(dct["op"], dct["operand"]) elif dct['ast_type'] == "Lambda": return ast.Lambda(dct["args"], dct["body"]) elif dct['ast_type'] == "IfExp": return ast.IfExp(dct["test"], dct["body"], dct["orelse"]) elif dct['ast_type'] == "Dict": return ast.Dict(dct["keys"], dct["values"]) elif dct['ast_type'] == "Set": return ast.Set(dct["elts"]) elif dct['ast_type'] == "ListComp": return ast.ListComp(dct["elt"], dct["generators"]) elif dct['ast_type'] == "SetComp": return ast.SetComp(dct["elt"], dct["generators"]) elif dct['ast_type'] == "DictComp": return ast.DictComp(dct["key"], dct["value"], dct["generators"]) elif dct['ast_type'] == "GeneratorExp": return ast.GeneratorExp(dct["elt"], dct["generators"]) elif dct['ast_type'] == "Yield": return ast.Yield(dct["value"]) elif dct['ast_type'] == "Compare": return ast.Compare(dct["left"], dct["ops"], dct["comparators"]) elif dct['ast_type'] == "Call": return ast.Call(dct["func"], dct["args"], dct["keywords"], dct["starargs"], dct["kwargs"]) elif dct['ast_type'] == "Repr": return ast.Repr(dct["value"]) elif dct['ast_type'] == "Num": return ast.Num(dct["n"]) elif dct['ast_type'] == "Str": # Converting to ASCII return ast.Str(dct["s"].encode('ascii', 'ignore')) elif dct['ast_type'] == "Attribute": return ast.Attribute(dct["value"], dct["attr"], dct["ctx"]) elif dct['ast_type'] == "Subscript": return ast.Subscript(dct["value"], dct["slice"], dct["ctx"]) elif dct['ast_type'] == "Name": return ast.Name(dct["id"], dct["ctx"]) elif dct['ast_type'] == "List": return ast.List(dct["elts"], dct["ctx"]) elif dct['ast_type'] == "Tuple": return ast.Tuple(dct["elts"], dct["ctx"]) elif dct['ast_type'] == "Load": return ast.Load() elif dct['ast_type'] == "Store": return ast.Store() elif dct['ast_type'] == "Del": return ast.Del() elif dct['ast_type'] == "AugLoad": return ast.AugLoad() elif dct['ast_type'] == "AugStore": return ast.AugStore() elif dct['ast_type'] == "Param": return ast.Param() elif dct['ast_type'] == "Ellipsis": return ast.Ellipsis() elif dct['ast_type'] == "Slice": return ast.Slice(dct["lower"], dct["upper"], dct["step"]) elif dct['ast_type'] == "ExtSlice": return ast.ExtSlice(dct["dims"]) elif dct['ast_type'] == "Index": return ast.Index(dct["value"]) elif dct['ast_type'] == "And": return ast.And() elif dct['ast_type'] == "Or": return ast.Or() elif dct['ast_type'] == "Add": return ast.Add() elif dct['ast_type'] == "Sub": return ast.Sub() elif dct['ast_type'] == "Mult": return ast.Mult() elif dct['ast_type'] == "Div": return ast.Div() elif dct['ast_type'] == "Mod": return ast.Mod() elif dct['ast_type'] == "Pow": return ast.Pow() elif dct['ast_type'] == "LShift": return ast.LShift() elif dct['ast_type'] == "RShift": return ast.RShift() elif dct['ast_type'] == "BitOr": return ast.BitOr() elif dct['ast_type'] == "BitXor": return ast.BitXor() elif dct['ast_type'] == "BitAnd": return ast.BitAnd() elif dct['ast_type'] == "FloorDiv": return ast.FloorDiv() elif dct['ast_type'] == "Invert": return ast.Invert() elif dct['ast_type'] == "Not": return ast.Not() elif dct['ast_type'] == "UAdd": return ast.UAdd() elif dct['ast_type'] == "USub": return ast.USub() elif dct['ast_type'] == "Eq": return ast.Eq() elif dct['ast_type'] == "NotEq": return ast.NotEq() elif dct['ast_type'] == "Lt": return ast.Lt() elif dct['ast_type'] == "LtE": return ast.LtE() elif dct['ast_type'] == "Gt": return ast.Gt() elif dct['ast_type'] == "GtE": return ast.GtE() elif dct['ast_type'] == "Is": return ast.Is() elif dct['ast_type'] == "IsNot": return ast.IsNot() elif dct['ast_type'] == "In": return ast.In() elif dct['ast_type'] == "NotIn": return ast.NotIn() elif dct['ast_type'] == "comprehension": return ast.comprehension(dct["target"], dct["iter"], dct["ifs"]) elif dct['ast_type'] == "ExceptHandler": return ast.ExceptHandler(dct["type"], dct["name"], dct["body"]) elif dct['ast_type'] == "arguments": return ast.arguments(dct["args"], dct["vararg"], dct["kwarg"], dct["defaults"]) elif dct['ast_type'] == "keyword": return ast.keyword(dct["arg"], dct["value"]) elif dct['ast_type'] == "alias": return ast.alias(dct["name"], dct["asname"]) else: return dct
def test_empty_init(self): # Jython 2.5.0 did not allow empty constructors for many ast node types # but CPython ast nodes do allow this. For the moment, I don't see a # reason to allow construction of the super types (like ast.AST and # ast.stmt) as well as the op types that are implemented as enums in # Jython (like boolop), but I've left them in but commented out for # now. We may need them in the future since CPython allows this, but # it may fall under implementation detail. #ast.AST() ast.Add() ast.And() ast.Assert() ast.Assign() ast.Attribute() ast.AugAssign() ast.AugLoad() ast.AugStore() ast.BinOp() ast.BitAnd() ast.BitOr() ast.BitXor() ast.BoolOp() ast.Break() ast.Call() ast.ClassDef() ast.Compare() ast.Continue() ast.Del() ast.Delete() ast.Dict() ast.Div() ast.Ellipsis() ast.Eq() ast.Exec() ast.Expr() ast.Expression() ast.ExtSlice() ast.FloorDiv() ast.For() ast.FunctionDef() ast.GeneratorExp() ast.Global() ast.Gt() ast.GtE() ast.If() ast.IfExp() ast.Import() ast.ImportFrom() ast.In() ast.Index() ast.Interactive() ast.Invert() ast.Is() ast.IsNot() ast.LShift() ast.Lambda() ast.List() ast.ListComp() ast.Load() ast.Lt() ast.LtE() ast.Mod() ast.Module() ast.Mult() ast.Name() ast.Not() ast.NotEq() ast.NotIn() ast.Num() ast.Or() ast.Param() ast.Pass() ast.Pow() ast.Print() ast.RShift() ast.Raise() ast.Repr() ast.Return() ast.Slice() ast.Store() ast.Str() ast.Sub() ast.Subscript() ast.Suite() ast.TryExcept() ast.TryFinally() ast.Tuple() ast.UAdd() ast.USub() ast.UnaryOp() ast.While() ast.With() ast.Yield() ast.alias() ast.arguments() #ast.boolop() #ast.cmpop() ast.comprehension() #ast.excepthandler() #ast.expr() #ast.expr_context() ast.keyword()
def test_Ellipsis(self): self.verify(ast.Ellipsis(), '...')
def p_atom11(self, p): ''' atom : ELLIPSIS ''' p[0] = ast.Ellipsis()
def Ellipsis(draw) -> ast.Ellipsis: return ast.Ellipsis()
def generate_ellipsis(max_depth=None): return ast.Ellipsis()
def dynamize_node(node, ty, replacement_chance=.1): def lhts_elts(node): if isinstance(node, ast.Call): return node.args[0] elif isinstance(node, ast.Subscript): return node.slice.value def tuple_elts(node): if isinstance(node, ast.Tuple): return node.elts elif isinstance(node, ast.Call): return node.args elif isinstance(node, ast.Subscript): return node.slice.value.elts def dict_keys(node): if isinstance(node, ast.Call): return node.args[0] elif isinstance(node, ast.Subscript): return node.slice.value.elts[0] def dict_vals(node): if isinstance(node, ast.Call): return node.args[1] elif isinstance(node, ast.Subscript): return node.slice.value.elts[1] def fn_to(node): if isinstance(node, ast.Call): return node.args[1] elif isinstance(node, ast.Subscript): return node.slice.value.elts[1] def fn_args(node): if isinstance(node, ast.Call): return node.args[0].elts elif isinstance(node, ast.Subscript): return node.slice.value.elts[0].elts def struct_keys(node): return node.keys def struct_vals(node): return node.values if random.random() < replacement_chance: return weight(ty), dyn(node) elif any( isinstance(ty, cls) for cls in {retic_ast.List, retic_ast.HTuple, retic_ast.Set}): w, elts = dynamize_node(lhts_elts(node), ty.elts) if w > 0: if isinstance(ty, retic_ast.List): return w, fix_location( ast.Subscript(value=ast.Name(id='List', ctx=ast.Load()), slice=ast.Index(value=elts), ctx=ast.Load()), node) elif isinstance(ty, retic_ast.Set): return w, fix_location( ast.Subscript(value=ast.Name(id='Set', ctx=ast.Load()), slice=ast.Index(value=elts), ctx=ast.Load()), node) elif isinstance(ty, retic_ast.HTuple): return w, fix_location( ast.Subscript( value=ast.Name(id='Tuple', ctx=ast.Load()), slice=ast.Index(value=ast.Tuple( elts=[elts, ast.Ellipsis()], ctx=ast.Load())), ctx=ast.Load()), node) else: return 0, node elif isinstance(ty, retic_ast.Tuple): ws, elts = zip(*[ dynamize_node(elt, ty) for elt, ty in zip(tuple_elts(node), ty.elts) ]) w = sum(ws) if w > 0: return w, fix_location( ast.Subscript( value=ast.Name(id='Tuple', ctx=ast.Load()), slice=ast.Index( value=ast.Tuple(elts=list(elts), ctx=ast.Load())), ctx=ast.Load()), node) else: return 0, node elif isinstance(ty, retic_ast.Dict): wk, keys = dynamize_node(dict_keys(node), ty.keys) wv, vals = dynamize_node(dict_vals(node), ty.values) if wk + wv > 0: return wk + wv, fix_location( ast.Subscript( value=ast.Name(id='Dict', ctx=ast.Load()), slice=ast.Index( value=ast.Tuple(elts=[keys, vals], ctx=ast.Load())), ctx=ast.Load()), node) else: return 0, node elif isinstance(ty, retic_ast.Function): wt, to = dynamize_node(fn_to(node), ty.to) if isinstance(ty.froms, retic_ast.PosAT): if len(fn_args(node)) > 0: was, args = zip(*[ dynamize_node(elt, ty) for elt, ty in zip(fn_args(node), ty.froms.types) ]) wa = sum(was) else: args = [] wa = 0 if wt + wa > 0: return wt + wa, fix_location( ast.Subscript( value=ast.Name(id='Callable', ctx=ast.Load()), slice=ast.Index(value=ast.Tuple( elts=[ast.List(elts=list(args), ctx=ast.Load), to], ctx=ast.Load())), ctx=ast.Load()), node) else: return 0, node else: assert isinstance(ty.froms, retic_ast.ArbAT) if wt > 0: return wt, fix_location( ast.Subscript( value=ast.Name(id='Callable', ctx=ast.Load()), slice=ast.Index(value=ast.Tuple( elts=[ast.Ellipsis(), to], ctx=ast.Load())), ctx=ast.Load()), node) else: return 0, node elif isinstance(ty, retic_ast.Structural): mems = [(k, dynamize_node(v, ty.members[k.s])) for k, v in zip(struct_keys(node), struct_vals(node))] w = 0 keys = [] vals = [] for k, (we, v) in mems: w += we keys.append(k) vals.append(v) if w > 0: return w, fix_location(ast.Dict(keys=keys, values=vals), node) else: return 0, node else: return 0, node
def visit(self, node): if node is Ellipsis: node = ast.Ellipsis() result = super(TypeInferer, self).visit(node) return result
def visitEllipsis(self, n, *args): return ast.Ellipsis()