def buildExtSliceNode(provider, node, source_ref):
elements = []
for dim in node.slice.dims:
dim_kind = getKind(dim)
if dim_kind == "Slice":
lower = buildNode(provider, dim.lower, source_ref, True)
upper = buildNode(provider, dim.upper, source_ref, True)
step = buildNode(provider, dim.step, source_ref, True)
element = makeExpressionBuiltinSlice(start=lower,
stop=upper,
step=step,
source_ref=source_ref)
elif dim_kind == "Ellipsis":
element = ExpressionConstantEllipsisRef(source_ref=source_ref)
elif dim_kind == "Index":
element = buildNode(provider=provider,
node=dim.value,
source_ref=source_ref)
else:
assert False, dim
elements.append(element)
return makeExpressionMakeTupleOrConstant(elements=elements,
user_provided=True,
source_ref=source_ref)
def buildSubscriptNode(provider, node, source_ref):
# Subscript expression nodes, various types are dispatched here.
assert getKind(node.ctx) == "Load", source_ref
# The subscript "[]" operator is one of many different things. This is
# expressed by this kind, there are "slice" lookups (two values, even if one
# is using default), and then "index" lookups. The form with three argument
# is really an "index" lookup, with a slice object. And the "..." lookup is
# also an index loop-up, with it as the argument. So this splits things into
# two different operations, "subscript" with a single "subscript" object. Or
# a slice lookup with a lower and higher boundary. These things should
# behave similar, but they are different slots.
kind = getKind(node.slice)
if kind == "Index":
return ExpressionSubscriptLookup(
subscribed = buildNode(provider, node.value, source_ref),
subscript = buildNode(provider, node.slice.value, source_ref),
source_ref = source_ref
)
elif kind == "Slice":
lower = buildNode(
provider = provider,
node = node.slice.lower,
source_ref = source_ref,
allow_none = True
)
upper = buildNode(
provider = provider,
node = node.slice.upper,
source_ref = source_ref,
allow_none = True
)
step = buildNode(
provider = provider,
node = node.slice.step,
source_ref = source_ref,
allow_none = True
)
# For Python3 there is no slicing operation, this is always done
# with subscript using a slice object. For Python2, it is only done
# if no "step" is provided.
use_sliceobj = step is not None or python_version >= 300
if use_sliceobj:
return ExpressionSubscriptLookup(
subscribed = buildNode(provider, node.value, source_ref),
subscript = ExpressionBuiltinSlice(
start = lower,
stop = upper,
step = step,
source_ref = source_ref
),
source_ref = source_ref
)
else:
return ExpressionSliceLookup(
expression = buildNode(provider, node.value, source_ref),
lower = lower,
upper = upper,
source_ref = source_ref
)
elif kind == "ExtSlice":
return ExpressionSubscriptLookup(
subscribed = buildNode(provider, node.value, source_ref),
subscript = buildExtSliceNode(provider, node, source_ref),
source_ref = source_ref
)
elif kind == "Ellipsis":
return ExpressionSubscriptLookup(
subscribed = buildNode(provider, node.value, source_ref),
subscript = ExpressionConstantEllipsisRef(
source_ref = source_ref
),
source_ref = source_ref
)
else:
assert False, kind
def buildEllipsisNode(source_ref):
return ExpressionConstantEllipsisRef(source_ref=source_ref,
user_provided=True)
def buildEllipsisNode(source_ref):
return ExpressionConstantEllipsisRef(source_ref=source_ref)
def decodeAssignTarget(provider, node, source_ref, allow_none=False):
# Many cases to deal with, because of the different assign targets,
# pylint: disable=too-many-branches,too-many-return-statements
if node is None and allow_none:
return None
if type(node) is str:
return "Name", mangleName(node, provider)
kind = getKind(node)
if hasattr(node, "ctx"):
assert getKind(node.ctx) in ("Store", "Del")
if kind == "Name":
return kind, mangleName(node.id, provider)
elif kind == "Attribute":
return kind, (buildNode(provider, node.value, source_ref), node.attr)
elif kind == "Subscript":
slice_kind = getKind(node.slice)
if slice_kind == "Index":
return (
"Subscript",
(
buildNode(provider, node.value, source_ref),
buildNode(provider, node.slice.value, source_ref),
),
)
elif slice_kind == "Slice":
lower = buildNode(provider, node.slice.lower, source_ref, True)
upper = buildNode(provider, node.slice.upper, source_ref, True)
if node.slice.step is not None:
step = buildNode(provider, node.slice.step, source_ref)
return (
"Subscript",
(
buildNode(provider, node.value, source_ref),
makeExpressionBuiltinSlice(start=lower,
stop=upper,
step=step,
source_ref=source_ref),
),
)
else:
return (
"Slice",
(buildNode(provider, node.value,
source_ref), lower, upper),
)
elif slice_kind == "ExtSlice":
return (
"Subscript",
(
buildNode(provider, node.value, source_ref),
buildExtSliceNode(provider, node, source_ref),
),
)
elif slice_kind == "Ellipsis":
return (
"Subscript",
(
buildNode(provider, node.value, source_ref),
ExpressionConstantEllipsisRef(source_ref=source_ref),
),
)
elif python_version >= 390:
return (
"Subscript",
(
buildNode(provider, node.value, source_ref),
buildNode(provider, node.slice, source_ref),
),
)
else:
assert False, slice_kind
elif kind in ("Tuple", "List"):
return (
"Tuple",
tuple(
decodeAssignTarget(
provider=provider,
node=sub_node,
source_ref=source_ref,
allow_none=False,
) for sub_node in node.elts),
)
elif kind == "Starred":
return (
"Starred",
decodeAssignTarget(
provider=provider,
node=node.value,
source_ref=source_ref,
allow_none=False,
),
)
else:
assert False, (source_ref, kind)
