def syn_Subscript(self, ctx, e):
slice_ = e.slice
if isinstance(slice_, ast.Ellipsis):
raise _errors.TyError("stringing slice cannot be an Ellipsis.", e)
elif isinstance(slice_, ast.ExtSlice):
raise _errors.TyError("stringing slice can only have one dimension.", e)
elif isinstance(slice_, ast.Index):
ctx.ana(slice_.value, _numeric.num)
else: # if isinstance(slice_, ast.Slice):
lower, upper, step = slice_.lower, slice_.upper, slice_.step
if lower is not None:
ctx.ana(lower, _numeric.num)
if upper is not None:
ctx.ana(upper, _numeric.num)
if not _is_None(step):
ctx.ana(step, _numeric.num)
return self
python类Ellipsis()的实例源码
def test_size_ellipsis():
example = """
class Foo:
bar[1:2,
...]
"""
if sys.version_info < (3, 0):
check_size(example, 2)
else:
# ast.Ellipsis is a subclass of ast.expr in Python 3.
check_size(example, 3)
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 is_stub(node):
"""Check if the function is a stub definition:
For the function to be a stub, it should be fully annotated and should have no body.
The body should be a single `Pass` statement with optional docstring.
"""
if not is_annotated(node):
return False
if len(node.body) == 1 and isinstance(node.body[0], ast.Expr) and isinstance(node.body[0].value, ast.Ellipsis):
return True
return ((len(node.body) == 1 and isinstance(node.body[0], ast.Pass))
or (len(node.body) == 2 and isinstance(node.body[0], ast.Expr) and isinstance(node.body[1], ast.Pass)))
def init_inc_idx(cls, inc_idx):
if inc_idx != () and inc_idx != Ellipsis:
raise typy.TypeFormationError("Incomplete index of float_ type must be () or Ellipsis.")
return inc_idx
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 _infer_func_def(node, context, solver):
"""Infer the type for a function definition"""
if is_stub(node) or has_type_var(node, solver):
return_annotation = node.returns
args_annotations = []
for arg in node.args.args:
args_annotations.append(arg.annotation)
defaults_count = len(node.args.defaults)
if hasattr(node, "method_type"): # check if the node contains the manually added method flag
if node.method_type not in context.builtin_methods:
context.builtin_methods[node.method_type] = {}
context.builtin_methods[node.method_type][node.name] = AnnotatedFunction(args_annotations,
return_annotation,
defaults_count)
else:
context.set_type(node.name, AnnotatedFunction(args_annotations, return_annotation, defaults_count))
return solver.z3_types.none
func_context, args_types = _init_func_context(node, node.args.args, context, solver)
result_type = context.get_type(node.name)
result_type.args_count = len(node.args.args)
context.set_type(node.name, result_type)
context.add_func_ast(node.name, node)
if hasattr(node.args, "defaults"):
# Use the default args to infer the function parameters
_infer_args_defaults(args_types, node.args.defaults, context, solver)
defaults_len = len(node.args.defaults)
else:
defaults_len = 0
if node.returns:
return_type = solver.resolve_annotation(node.returns)
if inference_config["ignore_fully_annotated_function"] and is_annotated(node)\
or isinstance(node.body[0], ast.Expr) and isinstance(node.body[0].value, ast.Ellipsis):
# Ignore the body if it has return annotation and one of the following conditions:
# The configuration flag for doing so is set
# The body begins with ellipsis
body_type = return_type
else:
body_type = _infer_body(node.body, func_context, node.lineno, solver)
solver.add(body_type == return_type,
fail_message="Return type annotation in line {}".format(node.lineno))
else:
body_type = _infer_body(node.body, func_context, node.lineno, solver)
return_type = solver.new_z3_const("return")
solver.add(solver.z3_types.subtype(body_type, return_type),
fail_message="Return type in line {}".format(node.lineno))
# Putting higher weight for this soft constraint to give it higher priority over soft-constraint
# added by inheritance covariance/contravariance return type
solver.optimize.add_soft(body_type == return_type, weight=2)
func_type = solver.z3_types.funcs[len(args_types)]((defaults_len,) + args_types + (return_type,))
solver.add(result_type == func_type,
fail_message="Function definition in line {}".format(node.lineno))
return solver.z3_types.none
