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 createPython3NamespacePath(package, source_ref):
return StatementAssignmentVariableName(
provider=package,
variable_name="__path__",
source=ExpressionCallNoKeywords(
called=ExpressionImportName(
module=makeExpressionImportModuleFixed(
module_name="_frozen_importlib"
if python_version < 0x350
else "_frozen_importlib_external",
source_ref=source_ref,
),
import_name="_NamespacePath",
level=0,
source_ref=source_ref,
),
args=makeExpressionMakeTupleOrConstant(
elements=(
makeConstantRefNode(
constant=package.getFullName().asString(),
user_provided=True,
source_ref=source_ref,
),
getNameSpacePathExpression(package=package, source_ref=source_ref),
makeConstantRefNode(constant=None, source_ref=source_ref),
),
user_provided=True,
source_ref=source_ref,
),
source_ref=source_ref,
),
source_ref=source_ref,
)
def _buildBasesTupleCreationNode(provider, elements, source_ref):
"""For use in Python3 classes for the bases."""
for element in elements:
if getKind(element) == "Starred":
return buildTupleUnpacking(provider=provider,
elements=elements,
source_ref=source_ref)
return makeExpressionMakeTupleOrConstant(
elements=buildNodeList(provider, elements, source_ref),
user_provided=True,
source_ref=source_ref,
)
def _makeCall(module_name, import_name, attribute_name, source_ref, *args):
return ExpressionCallNoKeywords(
called=makeExpressionAttributeLookup(
expression=makeExpressionImportModuleNameHard(
module_name=module_name, import_name=import_name, source_ref=source_ref
),
attribute_name=attribute_name,
source_ref=source_ref,
),
args=makeExpressionMakeTupleOrConstant(
elements=args, user_provided=True, source_ref=source_ref
),
source_ref=source_ref,
)
def buildTupleCreationNode(provider, node, source_ref):
if python_version >= 300:
for element in node.elts:
if getKind(element) == "Starred":
if python_version < 350:
_raiseStarredSyntaxError(element, source_ref)
else:
return buildTupleUnpacking(provider=provider,
elements=node.elts,
source_ref=source_ref)
return makeExpressionMakeTupleOrConstant(
elements=buildNodeList(provider, node.elts, source_ref),
user_provided=True,
source_ref=source_ref,
)
def makeCallNode(called, *args, **kwargs):
source_ref = args[-1]
if len(args) > 1:
args = makeExpressionMakeTupleOrConstant(
elements=args[:-1], user_provided=True, source_ref=source_ref
)
else:
args = None
if kwargs:
kwargs = makeDictCreationOrConstant2(
keys=tuple(kwargs.keys()),
values=tuple(kwargs.values()),
source_ref=source_ref,
)
else:
kwargs = None
return makeExpressionCall(
called=called, args=args, kw=kwargs, source_ref=source_ref
)
def _buildSetUnpacking(provider, elements, source_ref):
helper_args = []
for element in elements:
# We could be a lot cleverer about the tuples for non-starred
# arguments, but lets get this to work first. And then rely on
# future optimization to inline the list unpacking helper in a
# way that has the same effect.
if getKind(element) == "Starred":
helper_args.append(buildNode(provider, element.value, source_ref))
else:
helper_args.append(
makeExpressionMakeTupleOrConstant(
elements=(buildNode(provider, element, source_ref), ),
user_provided=True,
source_ref=source_ref,
))
result = ExpressionFunctionCall(
function=ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(
function_body=getSetUnpackingHelper(), source_ref=source_ref),
defaults=(),
kw_defaults=None,
annotations=None,
source_ref=source_ref,
),
values=(makeExpressionMakeTuple(helper_args, source_ref), ),
source_ref=source_ref,
)
result.setCompatibleSourceReference(
helper_args[-1].getCompatibleSourceReference())
return result
def _makeCallNode(
called, positional_args, keys, values, list_star_arg, dict_star_arg, source_ref
):
# Many variables, but only to cover the many complex call cases.
if list_star_arg is None and dict_star_arg is None:
result = makeExpressionCall(
called=called,
args=makeExpressionMakeTupleOrConstant(
elements=positional_args,
user_provided=True,
source_ref=source_ref,
),
kw=makeExpressionMakeDictOrConstant(
makeExpressionPairs(keys=keys, values=values),
user_provided=True,
source_ref=source_ref,
),
source_ref=source_ref,
)
# Bug compatible line numbers before Python 3.8
if python_version < 0x380:
if values:
result.setCompatibleSourceReference(
source_ref=values[-1].getCompatibleSourceReference()
)
elif positional_args:
result.setCompatibleSourceReference(
source_ref=positional_args[-1].getCompatibleSourceReference()
)
return result
else:
# Dispatch to complex helper function for each case. These do
# re-formulation of complex calls according to developer manual.
key = (
bool(positional_args),
bool(keys),
list_star_arg is not None,
dict_star_arg is not None,
)
table = {
(True, True, True, False): getFunctionCallHelperPosKeywordsStarList,
(True, False, True, False): getFunctionCallHelperPosStarList,
(False, True, True, False): getFunctionCallHelperKeywordsStarList,
(False, False, True, False): getFunctionCallHelperStarList,
(True, True, False, True): getFunctionCallHelperPosKeywordsStarDict,
(True, False, False, True): getFunctionCallHelperPosStarDict,
(False, True, False, True): getFunctionCallHelperKeywordsStarDict,
(False, False, False, True): getFunctionCallHelperStarDict,
(True, True, True, True): getFunctionCallHelperPosKeywordsStarListStarDict,
(True, False, True, True): getFunctionCallHelperPosStarListStarDict,
(False, True, True, True): getFunctionCallHelperKeywordsStarListStarDict,
(False, False, True, True): getFunctionCallHelperStarListStarDict,
}
get_helper = table[key]
helper_args = [called]
if positional_args:
helper_args.append(
makeExpressionMakeTupleOrConstant(
elements=positional_args,
user_provided=True,
source_ref=source_ref,
)
)
# Order of evaluation changed in Python3.5.
if python_version >= 0x350 and list_star_arg is not None:
helper_args.append(list_star_arg)
if keys:
helper_args.append(
makeExpressionMakeDictOrConstant(
pairs=makeExpressionPairs(keys=keys, values=values),
user_provided=True,
source_ref=source_ref,
)
)
# Order of evaluation changed in Python3.5.
if python_version < 0x350 and list_star_arg is not None:
helper_args.append(list_star_arg)
if dict_star_arg is not None:
helper_args.append(dict_star_arg)
result = ExpressionFunctionCall(
function=ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(
function_body=get_helper(), source_ref=source_ref
),
defaults=(),
kw_defaults=None,
annotations=None,
source_ref=source_ref,
),
values=helper_args,
source_ref=source_ref,
)
# Bug compatible line numbers before Python 3.8
if python_version < 0x380:
result.setCompatibleSourceReference(
source_ref=helper_args[-1].getCompatibleSourceReference()
)
return result
def buildClassNode2(provider, node, source_ref):
# This function is the Python2 special case with special re-formulation as
# according to developer manual, and it's very detailed, pylint: disable=too-many-locals
class_statement_nodes, class_doc = extractDocFromBody(node)
function_body = ExpressionClassBody(provider=provider,
name=node.name,
doc=class_doc,
source_ref=source_ref)
parent_module = provider.getParentModule()
code_object = CodeObjectSpec(
co_name=node.name,
co_kind="Class",
co_varnames=(),
co_freevars=(),
co_argcount=0,
co_posonlyargcount=0,
co_kwonlyargcount=0,
co_has_starlist=False,
co_has_stardict=False,
co_filename=parent_module.getRunTimeFilename(),
co_lineno=source_ref.getLineNumber(),
future_spec=parent_module.getFutureSpec(),
)
body = buildFrameNode(
provider=function_body,
nodes=class_statement_nodes,
code_object=code_object,
source_ref=source_ref,
)
if body is not None:
# The frame guard has nothing to tell its line number to.
body.source_ref = source_ref.atInternal()
locals_scope = function_body.getLocalsScope()
# The class body is basically a function that implicitly, at the end
# returns its locals and cannot have other return statements contained, and
# starts out with a variables "__module__" and potentially "__doc__" set.
statements = [
StatementSetLocalsDictionary(locals_scope=locals_scope,
source_ref=source_ref),
StatementAssignmentVariableName(
provider=function_body,
variable_name="__module__",
source=ExpressionModuleAttributeNameRef(
variable=provider.getParentModule().getVariableForReference(
"__name__"),
source_ref=source_ref,
),
source_ref=source_ref.atInternal(),
),
]
if class_doc is not None:
statements.append(
StatementAssignmentVariableName(
provider=function_body,
variable_name="__doc__",
source=makeConstantRefNode(constant=class_doc,
source_ref=source_ref,
user_provided=True),
source_ref=source_ref.atInternal(),
))
statements += (
body,
StatementReturn(
expression=ExpressionBuiltinLocalsRef(locals_scope=locals_scope,
source_ref=source_ref),
source_ref=source_ref,
),
)
body = makeStatementsSequenceFromStatement(
statement=makeTryFinallyStatement(
provider=function_body,
tried=mergeStatements(statements, True),
final=StatementReleaseLocals(locals_scope=locals_scope,
source_ref=source_ref),
source_ref=source_ref,
))
# The class body is basically a function that implicitly, at the end
# returns its locals and cannot have other return statements contained.
function_body.setBody(body)
temp_scope = provider.allocateTempScope("class_creation")
tmp_bases = provider.allocateTempVariable(temp_scope, "bases")
tmp_class_dict = provider.allocateTempVariable(temp_scope, "class_dict")
tmp_metaclass = provider.allocateTempVariable(temp_scope, "metaclass")
tmp_class = provider.allocateTempVariable(temp_scope, "class")
select_metaclass = ExpressionOutlineBody(provider=provider,
name="select_metaclass",
body=None,
source_ref=source_ref)
if node.bases:
tmp_base = select_metaclass.allocateTempVariable(temp_scope=None,
name="base")
statements = (
StatementAssignmentVariable(
variable=tmp_base,
source=ExpressionSubscriptLookup(
expression=ExpressionTempVariableRef(
variable=tmp_bases, source_ref=source_ref),
subscript=makeConstantRefNode(constant=0,
source_ref=source_ref,
user_provided=True),
source_ref=source_ref,
),
source_ref=source_ref,
),
makeTryFinallyStatement(
provider,
tried=StatementTry(
tried=makeStatementsSequenceFromStatement(
statement=StatementReturn(
expression=ExpressionAttributeLookup(
expression=ExpressionTempVariableRef(
variable=tmp_base, source_ref=source_ref),
attribute_name="__class__",
source_ref=source_ref,
),
source_ref=source_ref,
)),
except_handler=makeStatementsSequenceFromStatement(
statement=StatementReturn(
expression=ExpressionBuiltinType1(
value=ExpressionTempVariableRef(
variable=tmp_base, source_ref=source_ref),
source_ref=source_ref,
),
source_ref=source_ref,
)),
break_handler=None,
continue_handler=None,
return_handler=None,
source_ref=source_ref,
),
final=StatementReleaseVariable(variable=tmp_base,
source_ref=source_ref),
source_ref=source_ref,
public_exc=False,
),
)
else:
statements = (
StatementTry(
tried=makeStatementsSequenceFromStatement(
statement=StatementReturn(
# TODO: Should avoid checking __builtins__ for this.
expression=ExpressionVariableNameRef(
variable_name="__metaclass__",
provider=parent_module,
source_ref=source_ref,
),
source_ref=source_ref,
)),
except_handler=makeStatementsSequenceFromStatement(
statement=StatementReturn(
expression=ExpressionBuiltinAnonymousRef(
builtin_name="classobj", source_ref=source_ref),
source_ref=source_ref,
)),
break_handler=None,
continue_handler=None,
return_handler=None,
source_ref=source_ref,
), )
select_metaclass.setBody(
makeStatementsSequence(statements=statements,
allow_none=False,
source_ref=source_ref))
statements = [
StatementAssignmentVariable(
variable=tmp_bases,
source=makeExpressionMakeTupleOrConstant(
elements=buildNodeList(provider=provider,
nodes=node.bases,
source_ref=source_ref),
user_provided=True,
source_ref=source_ref,
),
source_ref=source_ref,
),
StatementAssignmentVariable(variable=tmp_class_dict,
source=function_body,
source_ref=source_ref),
StatementAssignmentVariable(
variable=tmp_metaclass,
source=ExpressionConditional(
condition=ExpressionDictOperationIn(
key=makeConstantRefNode(
constant="__metaclass__",
source_ref=source_ref,
user_provided=True,
),
dict_arg=ExpressionTempVariableRef(variable=tmp_class_dict,
source_ref=source_ref),
source_ref=source_ref,
),
expression_yes=ExpressionDictOperationGet(
dict_arg=ExpressionTempVariableRef(variable=tmp_class_dict,
source_ref=source_ref),
key=makeConstantRefNode(
constant="__metaclass__",
source_ref=source_ref,
user_provided=True,
),
source_ref=source_ref,
),
expression_no=select_metaclass,
source_ref=source_ref,
),
source_ref=source_ref,
),
StatementAssignmentVariable(
variable=tmp_class,
source=makeExpressionCall(
called=ExpressionTempVariableRef(variable=tmp_metaclass,
source_ref=source_ref),
args=makeExpressionMakeTuple(
elements=(
makeConstantRefNode(
constant=node.name,
source_ref=source_ref,
user_provided=True,
),
ExpressionTempVariableRef(variable=tmp_bases,
source_ref=source_ref),
ExpressionTempVariableRef(variable=tmp_class_dict,
source_ref=source_ref),
),
source_ref=source_ref,
),
kw=None,
source_ref=source_ref,
),
source_ref=source_ref,
),
]
for decorator in buildNodeList(provider, reversed(node.decorator_list),
source_ref):
statements.append(
StatementAssignmentVariable(
variable=tmp_class,
source=makeExpressionCall(
called=decorator,
args=makeExpressionMakeTuple(
elements=(ExpressionTempVariableRef(
variable=tmp_class, source_ref=source_ref), ),
source_ref=source_ref,
),
kw=None,
source_ref=decorator.getSourceReference(),
),
source_ref=decorator.getSourceReference(),
))
statements.append(
StatementAssignmentVariableName(
provider=provider,
variable_name=mangleName(node.name, provider),
source=ExpressionTempVariableRef(variable=tmp_class,
source_ref=source_ref),
source_ref=source_ref,
))
final = (
StatementReleaseVariable(variable=tmp_class, source_ref=source_ref),
StatementReleaseVariable(variable=tmp_bases, source_ref=source_ref),
StatementReleaseVariable(variable=tmp_class_dict,
source_ref=source_ref),
StatementReleaseVariable(variable=tmp_metaclass,
source_ref=source_ref),
)
return makeTryFinallyStatement(provider=function_body,
tried=statements,
final=final,
source_ref=source_ref)
