def createPython3NamespacePath(package_name, module_relpath, source_ref):
return StatementAssignmentVariableName(
variable_name = "__path__",
source = ExpressionCallNoKeywords(
called = ExpressionImportName(
module = makeAbsoluteImportNode(
module_name = "_frozen_importlib"
if python_version < 350 else
"_frozen_importlib_external",
source_ref = source_ref
),
import_name = "_NamespacePath",
source_ref = source_ref
),
args = makeConstantRefNode(
constant = (
package_name,
[module_relpath],
None
),
source_ref = source_ref
),
source_ref = source_ref
),
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 createPathAssignment(source_ref):
if Options.getFileReferenceMode() == "original":
path_value = ExpressionConstantRef(
constant=[dirname(source_ref.getFilename())],
source_ref=source_ref,
user_provided=True)
else:
path_value = ExpressionMakeList(elements=(ExpressionCallNoKeywords(
called=ExpressionAttributeLookup(source=ExpressionImportModuleHard(
module_name="os", import_name="path", source_ref=source_ref),
attribute_name="dirname",
source_ref=source_ref),
args=ExpressionMakeTuple(
elements=(ExpressionModuleFileAttributeRef(
source_ref=source_ref, ), ),
source_ref=source_ref,
),
source_ref=source_ref,
), ),
source_ref=source_ref)
return StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(variable_name="__path__",
source_ref=source_ref),
source=path_value,
source_ref=source_ref)
def createPathAssignment(package, source_ref):
if Options.getFileReferenceMode() == "original":
path_value = makeConstantRefNode(
constant=[os.path.dirname(source_ref.getFilename())],
source_ref=source_ref,
user_provided=True)
else:
elements = [
ExpressionCallNoKeywords(
called=ExpressionAttributeLookup(
source=ExpressionImportModuleNameHard(
module_name="os",
import_name="path",
source_ref=source_ref),
attribute_name="dirname",
source_ref=source_ref),
args=ExpressionMakeTuple(
elements=(ExpressionModuleAttributeFileRef(
variable=package.getVariableForReference("__file__"),
source_ref=source_ref,
), ),
source_ref=source_ref,
),
source_ref=source_ref,
)
]
if package.canHaveExternalImports():
parts = package.getFullName().split('.')
for count in range(len(parts)):
path_part = _makeCall(
"os", "environ", "get", source_ref,
makeConstantRefNode(
constant="NUITKA_PACKAGE_%s" %
'_'.join(parts[:count + 1]),
source_ref=source_ref,
),
makeConstantRefNode(
constant="/notexist",
source_ref=source_ref,
))
if parts[count + 1:]:
path_part = _makeCall(
"os", "path", "join", source_ref, path_part,
makeConstantRefNode(
constant=os.path.join(*parts[count + 1:]),
source_ref=source_ref,
))
elements.append(path_part)
path_value = ExpressionMakeList(elements=elements,
source_ref=source_ref)
return StatementAssignmentVariableName(provider=package,
variable_name="__path__",
source=path_value,
source_ref=source_ref)
def createPython3NamespacePath(package_name, module_relpath, source_ref):
return StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = "__path__",
source_ref = source_ref
),
source = ExpressionCallNoKeywords(
called = ExpressionImportName(
module = ExpressionImportModule(
module_name = "_frozen_importlib",
import_list = (),
level = 0,
source_ref = source_ref
),
import_name = "_NamespacePath",
source_ref = source_ref
),
args = ExpressionConstantRef(
constant = (
package_name,
[module_relpath],
None
),
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
)
def _makeCall(module_name, import_name, attribute_name, source_ref, *args):
return ExpressionCallNoKeywords(called=ExpressionAttributeLookup(
source=ExpressionImportModuleNameHard(module_name=module_name,
import_name=import_name,
source_ref=source_ref),
attribute_name=attribute_name,
source_ref=source_ref),
args=ExpressionMakeTuple(
elements=args, source_ref=source_ref),
source_ref=source_ref)
def createNamespacePackage(package_name, module_relpath):
parts = package_name.split('.')
source_ref = SourceCodeReference.fromFilenameAndLine(
filename = module_relpath,
line = 1,
future_spec = FutureSpec(),
)
source_ref = source_ref.atInternal()
package_package_name = '.'.join(parts[:-1]) or None
package = PythonPackage(
name = parts[-1],
package_name = package_package_name,
source_ref = source_ref,
)
package.setBody(
makeStatementsSequenceFromStatement(
statement = (
StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = "__path__",
source_ref = source_ref
),
source = ExpressionCallNoKeywords(
called = ExpressionImportName(
module = ExpressionImportModule(
module_name = "_frozen_importlib",
import_list = (),
level = 0,
source_ref = source_ref
),
import_name = "_NamespacePath",
source_ref = source_ref
),
args = ExpressionConstantRef(
constant = (
package_name,
[module_relpath],
None
),
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
)
)
)
)
completeVariableClosures(package)
return source_ref, package
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 createPython3NamespacePath(package, module_relpath, source_ref):
return StatementAssignmentVariableName(
provider=package,
variable_name="__path__",
source=ExpressionCallNoKeywords(
called=ExpressionImportName(
module=makeExpressionAbsoluteImportNode(
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=makeConstantRefNode(
constant=(package.getFullName().asString(), [module_relpath],
None),
source_ref=source_ref,
),
source_ref=source_ref,
),
source_ref=source_ref,
)
def _buildClassNode3(provider, node, source_ref):
# Many variables, due to the huge re-formulation that is going on here, which just has
# the complexity, pylint: disable=R0914
# This function is the Python3 special case with special re-formulation as according
# to developer manual.
class_statements, class_doc = extractDocFromBody(node)
# The result will be a temp block that holds the temporary variables.
result = StatementTempBlock(source_ref=source_ref)
tmp_bases = result.getTempVariable("bases")
tmp_class_decl_dict = result.getTempVariable("class_decl_dict")
tmp_metaclass = result.getTempVariable("metaclass")
tmp_prepared = result.getTempVariable("prepared")
class_creation_function = ExpressionFunctionBody(
provider=provider,
is_class=True,
parameters=make_class_parameters,
name=node.name,
doc=class_doc,
source_ref=source_ref)
# Hack:
class_creation_function.parent = provider
body = buildStatementsNode(provider=class_creation_function,
nodes=class_statements,
frame=True,
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()
statements = [
StatementSetLocals(new_locals=ExpressionTempVariableRef(
variable=tmp_prepared.makeReference(result),
source_ref=source_ref),
source_ref=source_ref.atInternal()),
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__module__", source_ref=source_ref),
source=ExpressionConstantRef(
constant=provider.getParentModule().getName(),
source_ref=source_ref),
source_ref=source_ref.atInternal())
]
if class_doc is not None:
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__doc__", source_ref=source_ref),
source=ExpressionConstantRef(constant=class_doc,
source_ref=source_ref),
source_ref=source_ref.atInternal()))
if Utils.python_version >= 330:
if provider.isExpressionFunctionBody():
qualname = provider.getName() + ".<locals>." + node.name
else:
qualname = node.name
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__qualname__", source_ref=source_ref),
source=ExpressionConstantRef(constant=qualname,
source_ref=source_ref),
source_ref=source_ref.atInternal()))
statements += [
body,
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(variable_name="__class__",
source_ref=source_ref),
source=ExpressionCall(
called=ExpressionTempVariableRef(
variable=tmp_metaclass.makeReference(result),
source_ref=source_ref),
args=ExpressionMakeTuple(
elements=(ExpressionConstantRef(constant=node.name,
source_ref=source_ref),
ExpressionTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref),
ExpressionBuiltinLocals(source_ref=source_ref)),
source_ref=source_ref),
kw=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(result),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref.atInternal()),
StatementReturn(expression=ExpressionVariableRef(
variable_name="__class__", source_ref=source_ref),
source_ref=source_ref.atInternal())
]
body = makeStatementsSequence(statements=statements,
allow_none=True,
source_ref=source_ref)
# The class body is basically a function that implicitely, at the end returns its
# locals and cannot have other return statements contained.
class_creation_function.setBody(body)
# The class body is basically a function that implicitely, at the end returns its
# created class and cannot have other return statements contained.
decorated_body = ExpressionFunctionCall(
function=ExpressionFunctionCreation(function_ref=ExpressionFunctionRef(
function_body=class_creation_function, source_ref=source_ref),
defaults=(),
kw_defaults=None,
annotations=None,
source_ref=source_ref),
values=(),
source_ref=source_ref)
for decorator in buildNodeList(provider, reversed(node.decorator_list),
source_ref):
decorated_body = ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(elements=(decorated_body, ),
source_ref=source_ref),
source_ref=decorator.getSourceReference())
statements = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref),
source=ExpressionMakeTuple(elements=buildNodeList(
provider, node.bases, source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class_decl_dict.makeReference(result),
source_ref=source_ref),
source=ExpressionMakeDict(pairs=[
ExpressionKeyValuePair(
key=ExpressionConstantRef(constant=keyword.arg,
source_ref=source_ref),
value=buildNode(provider, keyword.value, source_ref),
source_ref=source_ref) for keyword in node.keywords
],
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_metaclass.makeReference(result),
source_ref=source_ref),
source=ExpressionSelectMetaclass(
metaclass=ExpressionConditional(
condition=ExpressionComparison(
comparator="In",
left=ExpressionConstantRef(constant="metaclass",
source_ref=source_ref),
right=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(result),
source_ref=source_ref),
source_ref=source_ref),
yes_expression=ExpressionDictOperationGet(
dicte=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(result),
source_ref=source_ref),
key=ExpressionConstantRef(constant="metaclass",
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionConditional(
condition=ExpressionTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref),
no_expression=ExpressionBuiltinRef(
builtin_name="type", source_ref=source_ref),
yes_expression=ExpressionBuiltinType1(
value=ExpressionSubscriptLookup(
expression=ExpressionTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref),
subscript=ExpressionConstantRef(
constant=0, source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
bases=ExpressionTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementConditional(
condition=ExpressionComparison(
comparator="In",
left=ExpressionConstantRef(constant="metaclass",
source_ref=source_ref),
right=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(result),
source_ref=source_ref),
source_ref=source_ref),
no_branch=None,
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementDictOperationRemove(
dicte=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(result),
source_ref=source_ref),
key=ExpressionConstantRef(constant="metaclass",
source_ref=source_ref),
source_ref=source_ref)),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_prepared.makeReference(result),
source_ref=source_ref),
source=ExpressionConditional(
condition=ExpressionBuiltinHasattr(
object=ExpressionTempVariableRef(
variable=tmp_metaclass.makeReference(result),
source_ref=source_ref),
name=ExpressionConstantRef(constant="__prepare__",
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionConstantRef(constant={},
source_ref=source_ref),
yes_expression=ExpressionCall(
called=ExpressionAttributeLookup(
expression=ExpressionTempVariableRef(
variable=tmp_metaclass.makeReference(result),
source_ref=source_ref),
attribute_name="__prepare__",
source_ref=source_ref),
args=ExpressionMakeTuple(
elements=(ExpressionConstantRef(constant=node.name,
source_ref=source_ref),
ExpressionTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref)),
source_ref=source_ref),
kw=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(result),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(variable_ref=ExpressionTargetVariableRef(
variable_name=node.name, source_ref=source_ref),
source=decorated_body,
source_ref=source_ref)
]
result.setBody(
StatementsSequence(statements=statements, source_ref=source_ref))
return result
def _buildClassNode3(provider, node, source_ref):
# Many variables, due to the huge re-formulation that is going on here,
# which just has the complexity, pylint: disable=R0914,R0915
# This function is the Python3 special case with special re-formulation as
# according to developer manual.
class_statement_nodes, class_doc = extractDocFromBody(node)
# We need a scope for the temporary variables, and they might be closured.
temp_scope = provider.allocateTempScope(name="class_creation",
allow_closure=True)
tmp_bases = provider.allocateTempVariable(temp_scope=temp_scope,
name="bases")
tmp_class_decl_dict = provider.allocateTempVariable(temp_scope=temp_scope,
name="class_decl_dict")
tmp_metaclass = provider.allocateTempVariable(temp_scope=temp_scope,
name="metaclass")
tmp_prepared = provider.allocateTempVariable(temp_scope=temp_scope,
name="prepared")
class_creation_function = ExpressionClassBody(provider=provider,
name=node.name,
doc=class_doc,
flags=set(),
source_ref=source_ref)
if python_version >= 340 and False: # TODO: Temporarily reverted:
tmp_class = class_creation_function.allocateTempVariable(
temp_scope=None, name="__class__")
class_target_variable_ref = ExpressionTargetTempVariableRef(
variable=tmp_class, source_ref=source_ref)
class_variable_ref = ExpressionTempVariableRef(variable=tmp_class,
source_ref=source_ref)
else:
class_variable = class_creation_function.getVariableForAssignment(
"__class__")
class_target_variable_ref = ExpressionTargetVariableRef(
variable_name="__class__",
variable=class_variable,
source_ref=source_ref)
class_variable_ref = ExpressionVariableRef(variable_name="__class__",
variable=class_variable,
source_ref=source_ref)
code_object = CodeObjectSpec(co_name=node.name,
co_kind="Class",
co_varnames=(),
co_argcount=0,
co_kwonlyargcount=0,
co_has_starlist=False,
co_has_stardict=False)
body = buildFrameNode(provider=class_creation_function,
nodes=class_statement_nodes,
code_object=code_object,
source_ref=source_ref)
source_ref_orig = source_ref
if body is not None:
# The frame guard has nothing to tell its line number to.
body.source_ref = source_ref
module_variable = class_creation_function.getVariableForAssignment(
"__module__")
statements = [
StatementSetLocals(new_locals=ExpressionTempVariableRef(
variable=tmp_prepared, source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__module__",
variable=module_variable,
source_ref=source_ref),
source=makeConstantRefNode(
constant=provider.getParentModule().getFullName(),
source_ref=source_ref,
user_provided=True),
source_ref=source_ref)
]
if class_doc is not None:
doc_variable = class_creation_function.getVariableForAssignment(
"__doc__")
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__doc__",
variable=doc_variable,
source_ref=source_ref),
source=makeConstantRefNode(constant=class_doc,
source_ref=source_ref,
user_provided=True),
source_ref=source_ref))
# The "__qualname__" attribute is new in Python 3.3.
if python_version >= 330:
qualname = class_creation_function.getFunctionQualname()
qualname_variable = class_creation_function.getVariableForAssignment(
"__qualname__")
if python_version < 340:
qualname_ref = makeConstantRefNode(constant=qualname,
source_ref=source_ref,
user_provided=True)
else:
qualname_ref = ExpressionFunctionQualnameRef(
function_body=class_creation_function,
source_ref=source_ref,
)
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__qualname__",
variable=qualname_variable,
source_ref=source_ref),
source=qualname_ref,
source_ref=source_ref))
if python_version >= 340:
qualname_assign = statements[-1]
if python_version >= 360 and \
class_creation_function.needsAnnotationsDictionary():
annotations_variable = class_creation_function.getVariableForAssignment(
"__annotations__")
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__annotations__",
variable=annotations_variable,
source_ref=source_ref),
source=makeConstantRefNode(constant={},
source_ref=source_ref,
user_provided=True),
source_ref=source_ref))
statements.append(body)
statements += [
StatementAssignmentVariable(
variable_ref=class_target_variable_ref,
source=ExpressionCall(
called=ExpressionTempVariableRef(variable=tmp_metaclass,
source_ref=source_ref),
args=makeSequenceCreationOrConstant(
sequence_kind="tuple",
elements=(makeConstantRefNode(constant=node.name,
source_ref=source_ref,
user_provided=True),
ExpressionTempVariableRef(variable=tmp_bases,
source_ref=source_ref),
ExpressionBuiltinLocals(source_ref=source_ref)),
source_ref=source_ref),
kw=ExpressionTempVariableRef(variable=tmp_class_decl_dict,
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementReturn(expression=class_variable_ref, source_ref=source_ref)
]
body = makeStatementsSequence(statements=statements,
allow_none=True,
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.
class_creation_function.setBody(body)
class_creation_function.registerProvidedVariable(tmp_bases)
class_creation_function.registerProvidedVariable(tmp_class_decl_dict)
class_creation_function.registerProvidedVariable(tmp_metaclass)
class_creation_function.registerProvidedVariable(tmp_prepared)
# The class body is basically a function that implicitly, at the end
# returns its created class and cannot have other return statements
# contained.
decorated_body = ExpressionFunctionCall(
function=ExpressionFunctionCreation(function_ref=ExpressionFunctionRef(
function_body=class_creation_function, source_ref=source_ref),
code_object=code_object,
defaults=(),
kw_defaults=None,
annotations=None,
source_ref=source_ref),
values=(),
source_ref=source_ref)
for decorator in buildNodeList(provider, reversed(node.decorator_list),
source_ref):
decorated_body = ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(elements=(decorated_body, ),
source_ref=source_ref),
source_ref=decorator.getSourceReference())
statements = (
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_bases, source_ref=source_ref),
source=makeSequenceCreationOrConstant(sequence_kind="tuple",
elements=buildNodeList(
provider, node.bases,
source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class_decl_dict, source_ref=source_ref),
source=makeDictCreationOrConstant(keys=[
makeConstantRefNode(constant=keyword.arg,
source_ref=source_ref,
user_provided=True)
for keyword in node.keywords
],
values=[
buildNode(
provider, keyword.value,
source_ref)
for keyword in node.keywords
],
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_metaclass, source_ref=source_ref),
source=ExpressionSelectMetaclass(metaclass=ExpressionConditional(
condition=ExpressionComparisonIn(
left=makeConstantRefNode(constant="metaclass",
source_ref=source_ref,
user_provided=True),
right=ExpressionTempVariableRef(
variable=tmp_class_decl_dict, source_ref=source_ref),
source_ref=source_ref),
expression_yes=ExpressionDictOperationGet(
dict_arg=ExpressionTempVariableRef(
variable=tmp_class_decl_dict, source_ref=source_ref),
key=makeConstantRefNode(constant="metaclass",
source_ref=source_ref,
user_provided=True),
source_ref=source_ref),
expression_no=ExpressionConditional(
condition=ExpressionTempVariableRef(variable=tmp_bases,
source_ref=source_ref),
expression_no=ExpressionBuiltinRef(builtin_name="type",
source_ref=source_ref),
expression_yes=ExpressionBuiltinType1(
value=ExpressionSubscriptLookup(
subscribed=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),
source_ref=source_ref),
source_ref=source_ref),
bases=ExpressionTempVariableRef(
variable=tmp_bases,
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref_orig),
StatementConditional(
condition=ExpressionComparisonIn(
left=makeConstantRefNode(constant="metaclass",
source_ref=source_ref,
user_provided=True),
right=ExpressionTempVariableRef(variable=tmp_class_decl_dict,
source_ref=source_ref),
source_ref=source_ref),
no_branch=None,
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementDictOperationRemove(
dict_arg=ExpressionTempVariableRef(
variable=tmp_class_decl_dict, source_ref=source_ref),
key=makeConstantRefNode(constant="metaclass",
source_ref=source_ref,
user_provided=True),
source_ref=source_ref)),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_prepared, source_ref=source_ref),
source=ExpressionConditional(
condition=ExpressionBuiltinHasattr( # pylint: disable=E1120,E1123
object=ExpressionTempVariableRef(variable=tmp_metaclass,
source_ref=source_ref),
name=makeConstantRefNode(constant="__prepare__",
source_ref=source_ref,
user_provided=True),
source_ref=source_ref),
expression_no=makeConstantRefNode(constant={},
source_ref=source_ref,
user_provided=True),
expression_yes=ExpressionCall(
called=ExpressionAttributeLookup(
source=ExpressionTempVariableRef(
variable=tmp_metaclass, source_ref=source_ref),
attribute_name="__prepare__",
source_ref=source_ref),
args=ExpressionMakeTuple(
elements=(makeConstantRefNode(constant=node.name,
source_ref=source_ref,
user_provided=True),
ExpressionTempVariableRef(
variable=tmp_bases,
source_ref=source_ref)),
source_ref=source_ref),
kw=ExpressionTempVariableRef(variable=tmp_class_decl_dict,
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(variable_ref=ExpressionTargetVariableRef(
variable_name=node.name, source_ref=source_ref),
source=decorated_body,
source_ref=source_ref),
)
if python_version >= 340:
class_assign = statements[-1]
class_creation_function.qualname_setup = class_assign, qualname_assign
final = (StatementReleaseVariable(variable=tmp_bases,
source_ref=source_ref),
StatementReleaseVariable(variable=tmp_class_decl_dict,
source_ref=source_ref),
StatementReleaseVariable(variable=tmp_metaclass,
source_ref=source_ref),
StatementReleaseVariable(variable=tmp_prepared,
source_ref=source_ref))
return makeTryFinallyStatement(provider=provider,
tried=statements,
final=final,
source_ref=source_ref)
def buildFunctionNode(provider, node, source_ref):
# Functions have way too many details, pylint: disable=R0912,R0914
assert getKind(node) == "FunctionDef"
function_statement_nodes, function_doc = extractDocFromBody(node)
function_kind, flags, _written_variables, _non_local_declarations, _global_declarations = \
detectFunctionBodyKind(
nodes = function_statement_nodes
)
outer_body, function_body, code_object = buildFunctionWithParsing(
provider=provider,
function_kind=function_kind,
name=node.name,
function_doc=function_doc,
flags=flags,
node=node,
source_ref=source_ref)
if function_kind == "Function":
code_body = function_body
elif function_kind == "Generator":
code_body = ExpressionGeneratorObjectBody(provider=function_body,
name=node.name,
flags=flags,
source_ref=source_ref)
for variable in function_body.getVariables():
code_body.getVariableForReference(variable.getName())
else:
assert False, function_kind
if function_kind == "Generator":
function_body.setBody(
makeStatementsSequenceFromStatement(statement=StatementReturn(
expression=ExpressionMakeGeneratorObject(
generator_ref=ExpressionFunctionRef(
function_body=code_body, source_ref=source_ref),
code_object=code_object,
source_ref=source_ref),
source_ref=source_ref)))
decorators = buildNodeList(provider=provider,
nodes=reversed(node.decorator_list),
source_ref=source_ref)
defaults = buildNodeList(provider=provider,
nodes=node.args.defaults,
source_ref=source_ref)
kw_defaults = buildParameterKwDefaults(provider=provider,
node=node,
function_body=function_body,
source_ref=source_ref)
function_statements_body = buildFrameNode(provider=code_body,
nodes=function_statement_nodes,
code_object=code_object,
source_ref=source_ref)
if function_kind == "Function":
# TODO: Generators might have to raise GeneratorExit instead.
function_statements_body = _insertFinalReturnStatement(
function_statements_body=function_statements_body,
return_class=StatementReturn,
source_ref=source_ref)
if function_statements_body.isStatementsFrame():
function_statements_body = makeStatementsSequenceFromStatement(
statement=function_statements_body)
code_body.setBody(function_statements_body)
annotations = buildParameterAnnotations(provider, node, source_ref)
function_creation = ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(function_body=outer_body,
source_ref=source_ref),
code_object=code_object,
defaults=defaults,
kw_defaults=kw_defaults,
annotations=annotations,
source_ref=source_ref)
# Add the "staticmethod" decorator to __new__ methods if not provided.
# CPython made these optional, but secretly applies them when it does
# "class __new__". We add them earlier, so our optimization will see it.
if node.name == "__new__" and \
provider.isExpressionClassBody():
for decorator in decorators:
if decorator.isExpressionVariableRef() and \
decorator.getVariableName() == "staticmethod":
break
else:
decorators.append(
ExpressionBuiltinRef(builtin_name="staticmethod",
source_ref=source_ref))
if python_version >= 360 and \
node.name == "__init_subclass__" and \
provider.isExpressionClassBody():
for decorator in decorators:
if decorator.isExpressionVariableRef() and \
decorator.getVariableName() == "classmethod":
break
else:
decorators.append(
ExpressionBuiltinRef(builtin_name="classmethod",
source_ref=source_ref))
decorated_function = function_creation
for decorator in decorators:
decorated_function = ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(elements=(decorated_function, ),
source_ref=source_ref),
source_ref=decorator.getSourceReference())
result = StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(variable_name=mangleName(
node.name, provider),
source_ref=source_ref),
source=decorated_function,
source_ref=source_ref)
if python_version >= 340:
function_body.qualname_setup = result.getTargetVariableRef()
return result
def buildFunctionNode(provider, node, source_ref):
assert getKind(node) == "FunctionDef"
function_statements, function_doc = extractDocFromBody(node)
function_body = ExpressionFunctionBody(
provider = provider,
name = node.name,
doc = function_doc,
parameters = buildParameterSpec(node.name, node, source_ref),
source_ref = source_ref
)
# Hack:
function_body.parent = provider
decorators = buildNodeList(
provider = provider,
nodes = reversed(node.decorator_list),
source_ref = source_ref
)
defaults = buildNodeList(
provider = provider,
nodes = node.args.defaults,
source_ref = source_ref
)
kw_defaults = buildParameterKwDefaults(
provider, node, function_body, source_ref
)
pushIndicatorVariable(Ellipsis)
function_statements_body = buildStatementsNode(
provider = function_body,
nodes = function_statements,
frame = True,
source_ref = source_ref
)
popIndicatorVariable()
if function_body.isGenerator():
# TODO: raise generator exit?
pass
elif function_statements_body is None:
function_statements_body = makeStatementsSequenceFromStatement(
statement = StatementReturn(
expression = ExpressionConstantRef(
constant = None,
source_ref = source_ref.atInternal()
),
source_ref = source_ref.atInternal()
)
)
elif not function_statements_body.isStatementAborting():
function_statements_body.setStatements(
function_statements_body.getStatements() +
(
StatementReturn(
expression = ExpressionConstantRef(
constant = None,
source_ref = source_ref
),
source_ref = source_ref.atInternal()
),
)
)
function_body.setBody(
function_statements_body
)
annotations = buildParameterAnnotations(provider, node, source_ref)
function_creation = ExpressionFunctionCreation(
function_ref = ExpressionFunctionRef(
function_body,
source_ref = source_ref
),
defaults = defaults,
kw_defaults = kw_defaults,
annotations = annotations,
source_ref = source_ref
)
# Add the staticmethod decorator to __new__ methods if not provided.
# CPython made these optional, but applies them to every class __new__. We
# add them early, so our optimization will see it.
if node.name == "__new__" and not decorators and \
provider.isExpressionFunctionBody() and provider.isClassDictCreation():
decorators = (
ExpressionBuiltinRef(
builtin_name = "staticmethod",
source_ref = source_ref
),
)
decorated_function = function_creation
for decorator in decorators:
decorated_function = ExpressionCallNoKeywords(
called = decorator,
args = ExpressionMakeTuple(
elements = (decorated_function,),
source_ref = source_ref
),
source_ref = decorator.getSourceReference()
)
result = StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = node.name,
source_ref = source_ref
),
source = decorated_function,
source_ref = source_ref
)
if Utils.python_version >= 340:
function_body.qualname_setup = result.getTargetVariableRef()
return result
def buildAsyncFunctionNode(provider, node, source_ref):
# We are creating a function here that creates coroutine objects, with
# many details each, pylint: disable=too-many-locals
assert getKind(node) == "AsyncFunctionDef"
function_statement_nodes, function_doc = extractDocFromBody(node)
function_kind, flags = detectFunctionBodyKind(
nodes=function_statement_nodes, start_value="Coroutine")
creator_function_body, _, code_object = buildFunctionWithParsing(
provider=provider,
function_kind=function_kind,
name=node.name,
flags=(),
function_doc=function_doc,
node=node,
source_ref=source_ref)
if function_kind == "Coroutine":
function_body = ExpressionCoroutineObjectBody(
provider=creator_function_body,
name=node.name,
flags=flags,
source_ref=source_ref)
else:
function_body = ExpressionAsyncgenObjectBody(
provider=creator_function_body,
name=node.name,
flags=flags,
source_ref=source_ref)
for variable in creator_function_body.getVariables():
function_body.getVariableForReference(variable.getName())
decorators = buildNodeList(provider=provider,
nodes=reversed(node.decorator_list),
source_ref=source_ref)
defaults = buildNodeList(provider=provider,
nodes=node.args.defaults,
source_ref=source_ref)
function_statements_body = buildFrameNode(provider=function_body,
nodes=function_statement_nodes,
code_object=code_object,
source_ref=source_ref)
function_statements_body = _insertFinalReturnStatement(
function_statements_body=function_statements_body,
return_statement=StatementGeneratorReturnNone(source_ref=source_ref))
if function_statements_body.isStatementsFrame():
function_statements_body = makeStatementsSequenceFromStatement(
statement=function_statements_body)
function_body.setBody(function_statements_body)
annotations = buildParameterAnnotations(provider, node, source_ref)
kw_defaults = buildParameterKwDefaults(provider=provider,
node=node,
function_body=creator_function_body,
source_ref=source_ref)
if function_kind == "Coroutine":
creation_node = ExpressionMakeCoroutineObject(
coroutine_ref=ExpressionFunctionRef(function_body=function_body,
source_ref=source_ref),
code_object=code_object,
source_ref=source_ref)
else:
creation_node = ExpressionMakeAsyncgenObject(
asyncgen_ref=ExpressionFunctionRef(function_body=function_body,
source_ref=source_ref),
code_object=code_object,
source_ref=source_ref)
creator_function_body.setBody(
makeStatementsSequenceFromStatement(statement=StatementReturn(
expression=creation_node, source_ref=source_ref)))
function_creation = ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(function_body=creator_function_body,
source_ref=source_ref),
code_object=code_object,
defaults=defaults,
kw_defaults=kw_defaults,
annotations=annotations,
source_ref=source_ref)
decorated_function = function_creation
for decorator in decorators:
decorated_function = ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(elements=(decorated_function, ),
source_ref=source_ref),
source_ref=decorator.getSourceReference())
result = StatementAssignmentVariableName(variable_name=mangleName(
node.name, provider),
source=decorated_function,
source_ref=source_ref)
function_body.qualname_setup = result.getVariableName()
# Share the non-local declarations. TODO: This may also apply to generators
# and async generators.
creator_function_body.non_local_declarations = function_body.non_local_declarations
return result
def buildFunctionNode(provider, node, source_ref):
assert getKind(node) == "FunctionDef"
function_statements, function_doc = extractDocFromBody(node)
function_body = ExpressionFunctionBody(provider=provider,
name=node.name,
doc=function_doc,
parameters=buildParameterSpec(
provider, node.name, node,
source_ref),
is_class=False,
source_ref=source_ref)
decorators = buildNodeList(provider=provider,
nodes=reversed(node.decorator_list),
source_ref=source_ref)
defaults = buildNodeList(provider=provider,
nodes=node.args.defaults,
source_ref=source_ref)
kw_defaults = buildParameterKwDefaults(provider=provider,
node=node,
function_body=function_body,
source_ref=source_ref)
function_statements_body = buildStatementsNode(provider=function_body,
nodes=function_statements,
frame=True,
source_ref=source_ref)
if function_body.isGenerator():
# TODO: raise generator exit?
pass
else:
function_statements_body = _insertFinalReturnStatement(
function_statements_body=function_statements_body,
source_ref=source_ref)
if function_statements_body.isStatementsFrame():
function_statements_body = makeStatementsSequenceFromStatement(
statement=function_statements_body)
function_body.setBody(function_statements_body)
annotations = buildParameterAnnotations(provider, node, source_ref)
function_creation = ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(function_body=function_body,
source_ref=source_ref),
defaults=defaults,
kw_defaults=kw_defaults,
annotations=annotations,
source_ref=source_ref)
# Add the "staticmethod" decorator to __new__ methods if not provided.
# CPython made these optional, but secretly applies them when it does
# "class __new__". We add them earlier, so our optimization will see it.
if node.name == "__new__" and \
not decorators and \
provider.isExpressionClassBody():
decorators = (ExpressionBuiltinRef(builtin_name="staticmethod",
source_ref=source_ref), )
decorated_function = function_creation
for decorator in decorators:
decorated_function = ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(elements=(decorated_function, ),
source_ref=source_ref),
source_ref=decorator.getSourceReference())
result = StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(variable_name=mangleName(
node.name, provider),
source_ref=source_ref),
source=decorated_function,
source_ref=source_ref)
if Utils.python_version >= 340:
function_body.qualname_setup = result.getTargetVariableRef()
return result
def wrapEvalBuiltin(source, globals_arg, locals_arg, source_ref):
provider = node.getParentVariableProvider()
outline_body = ExpressionOutlineBody(
provider = node.getParentVariableProvider(),
name = "eval_call",
source_ref = source_ref
)
globals_ref, locals_ref, tried, final = wrapEvalGlobalsAndLocals(
provider = provider,
globals_node = globals_arg,
locals_node = locals_arg,
temp_scope = outline_body.getOutlineTempScope(),
source_ref = source_ref
)
# The wrapping should not relocate to the "source_ref".
assert globals_arg is None or \
globals_ref.getSourceReference() == \
globals_arg.getSourceReference()
assert locals_arg is None or \
locals_ref.getSourceReference() == \
locals_arg.getSourceReference()
source_variable = outline_body.allocateTempVariable(
temp_scope = None,
name = "source"
)
final.setStatements(
final.getStatements() + (
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = source_variable,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
)
)
strip_choice = ExpressionConstantRef(
constant = (" \t",),
source_ref = source_ref
)
if python_version >= 300:
strip_choice = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinType1(
value = ExpressionTempVariableRef(
variable = source_variable,
source_ref = source_ref
),
source_ref = source_ref
),
right = ExpressionBuiltinRef(
builtin_name = "bytes",
source_ref = source_ref
),
source_ref = source_ref
),
expression_yes = ExpressionConstantRef(
constant = (b" \t",),
source_ref = source_ref
),
expression_no = strip_choice,
source_ref = source_ref
)
# Source needs some special treatment for eval, if it's a string, it
# must be stripped.
string_fixup = [
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = source_variable,
source_ref = source_ref
),
source = ExpressionCallNoKeywords(
called = ExpressionAttributeLookup(
source = ExpressionTempVariableRef(
variable = source_variable,
source_ref = source_ref
),
attribute_name = "strip",
source_ref = source_ref
),
args = strip_choice,
source_ref = source_ref
),
source_ref = source_ref
)
]
statements = (
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = source_variable,
source_ref = source_ref
),
source = source,
source_ref = source_ref,
),
StatementConditional(
condition = ExpressionOperationNOT(
operand = ExpressionBuiltinIsinstance(
instance = ExpressionTempVariableRef(
variable = source_variable,
source_ref = source_ref
),
classes = ExpressionBuiltinAnonymousRef(
builtin_name = "code",
source_ref = source_ref,
),
source_ref = source_ref
),
source_ref = source_ref
),
yes_branch = StatementsSequence(
statements = string_fixup,
source_ref = source_ref
),
no_branch = None,
source_ref = source_ref
),
StatementReturn(
expression = ExpressionBuiltinEval(
source_code = ExpressionTempVariableRef(
variable = source_variable,
source_ref = source_ref
),
globals_arg = globals_ref,
locals_arg = locals_ref,
source_ref = source_ref
),
source_ref = source_ref
)
)
tried = makeStatementsSequence(
statements = (
tried,
) + statements,
allow_none = False,
source_ref = source_ref
)
outline_body.setBody(
makeStatementsSequenceFromStatement(
statement = makeTryFinallyStatement(
provider = outline_body,
tried = tried,
final = final,
source_ref = source_ref
)
)
)
return outline_body
def _buildWithNode(provider, context_expr, assign_target, body, source_ref):
with_source = buildNode(provider, context_expr, source_ref)
temp_scope = provider.allocateTempScope("with")
tmp_source_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="source")
tmp_exit_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="exit")
tmp_enter_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="enter")
tmp_indicator_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="indicator")
statements = (buildAssignmentStatements(provider=provider,
node=assign_target,
allow_none=True,
source=ExpressionTempVariableRef(
variable=tmp_enter_variable,
source_ref=source_ref),
source_ref=source_ref), body)
with_body = makeStatementsSequence(statements=statements,
allow_none=True,
source_ref=source_ref)
if Options.isFullCompat() and with_body is not None:
with_exit_source_ref = with_body.getStatements()[-1].\
getSourceReference()
else:
with_exit_source_ref = source_ref
# The "__enter__" and "__exit__" were normal attribute lookups under
# CPython2.6, but that changed with CPython2.7.
if Utils.python_version < 270:
attribute_lookup_class = ExpressionAttributeLookup
else:
attribute_lookup_class = ExpressionSpecialAttributeLookup
statements = [
# First assign the with context to a temporary variable.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_source_variable, source_ref=source_ref),
source=with_source,
source_ref=source_ref),
# Next, assign "__enter__" and "__exit__" attributes to temporary
# variables.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_exit_variable, source_ref=source_ref),
source=attribute_lookup_class(source=ExpressionTempVariableRef(
variable=tmp_source_variable, source_ref=source_ref),
attribute_name="__exit__",
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_enter_variable, source_ref=source_ref),
source=ExpressionCallEmpty(called=attribute_lookup_class(
source=ExpressionTempVariableRef(variable=tmp_source_variable,
source_ref=source_ref),
attribute_name="__enter__",
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_indicator_variable, source_ref=source_ref),
source=ExpressionConstantRef(constant=True, source_ref=source_ref),
source_ref=source_ref),
]
source_ref = source_ref.atInternal()
statements += [
makeTryFinallyStatement(
tried=makeTryExceptSingleHandlerNode(
tried=with_body,
exception_name="BaseException",
handler_body=StatementsSequence(
statements=(
# Prevents final block from calling __exit__ as
# well.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_indicator_variable,
source_ref=source_ref),
source=ExpressionConstantRef(
constant=False, source_ref=source_ref),
source_ref=source_ref),
StatementConditional(
condition=ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(
variable=tmp_exit_variable,
source_ref=source_ref),
args=ExpressionMakeTuple(
elements=(
ExpressionCaughtExceptionTypeRef(
source_ref=source_ref),
ExpressionCaughtExceptionValueRef(
source_ref=source_ref),
ExpressionCaughtExceptionTracebackRef(
source_ref=source_ref),
),
source_ref=source_ref),
source_ref=source_ref),
no_branch=makeStatementsSequenceFromStatement(
statement=StatementRaiseException(
exception_type=None,
exception_value=None,
exception_trace=None,
exception_cause=None,
source_ref=source_ref)),
yes_branch=None,
source_ref=source_ref),
),
source_ref=source_ref),
public_exc=Utils.python_version >= 270,
source_ref=source_ref),
final=StatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=tmp_indicator_variable,
source_ref=source_ref),
right=ExpressionConstantRef(constant=True,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementExpressionOnly(
expression=ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(
variable=tmp_exit_variable,
source_ref=source_ref),
args=ExpressionConstantRef(constant=(None, None,
None),
source_ref=source_ref),
source_ref=with_exit_source_ref),
source_ref=source_ref)),
no_branch=None,
source_ref=source_ref),
source_ref=source_ref)
]
return makeTryFinallyStatement(
tried=statements,
final=(
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_source_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_enter_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_exit_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_indicator_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
),
source_ref=source_ref)
def getNameSpacePathExpression(package, source_ref):
"""Create the __path__ expression for a package."""
reference_mode = Options.getFileReferenceMode()
if reference_mode == "original":
return makeConstantRefNode(
constant=[package.getCompileTimeDirectory()],
source_ref=source_ref,
)
elif reference_mode == "frozen":
return makeConstantRefNode(
constant=[],
source_ref=source_ref,
)
else:
elements = [
ExpressionCallNoKeywords(
called=makeExpressionAttributeLookup(
expression=makeExpressionImportModuleNameHard(
module_name="os", import_name="path", source_ref=source_ref
),
attribute_name="dirname",
source_ref=source_ref,
),
args=makeExpressionMakeTuple(
elements=(
ExpressionModuleAttributeFileRef(
variable=package.getVariableForReference("__file__"),
source_ref=source_ref,
),
),
source_ref=source_ref,
),
source_ref=source_ref,
)
]
if package.canHaveExternalImports():
parts = package.getFullName().asString().split(".")
for count in range(len(parts)):
path_part = _makeCall(
"os",
"environ",
"get",
source_ref,
makeConstantRefNode(
constant="NUITKA_PACKAGE_%s" % "_".join(parts[: count + 1]),
source_ref=source_ref,
),
makeConstantRefNode(constant="/notexist", source_ref=source_ref),
)
if parts[count + 1 :]:
path_part = _makeCall(
"os",
"path",
"join",
source_ref,
path_part,
makeConstantRefNode(
constant=os.path.join(*parts[count + 1 :]),
source_ref=source_ref,
),
)
elements.append(path_part)
return makeExpressionMakeList(elements=elements, source_ref=source_ref)
def buildAsyncFunctionNode(provider, node, source_ref):
# We are creating a function here that creates coroutine objects, with
# many details each, pylint: disable=R0914
assert getKind(node) == "AsyncFunctionDef"
function_statement_nodes, function_doc = extractDocFromBody(node)
creator_function_body, _, code_object = buildFunctionWithParsing(
provider=provider,
function_kind="Coroutine",
name=node.name,
flags=set(),
function_doc=function_doc,
node=node,
source_ref=source_ref)
function_body = ExpressionCoroutineObjectBody(
provider=creator_function_body,
name=node.name,
flags=set(),
source_ref=source_ref)
decorators = buildNodeList(provider=provider,
nodes=reversed(node.decorator_list),
source_ref=source_ref)
defaults = buildNodeList(provider=provider,
nodes=node.args.defaults,
source_ref=source_ref)
function_statements_body = buildFrameNode(provider=function_body,
nodes=function_statement_nodes,
code_object=code_object,
source_ref=source_ref)
function_statements_body = _insertFinalReturnStatement(
function_statements_body=function_statements_body,
return_class=StatementGeneratorReturn,
source_ref=source_ref)
if function_statements_body.isStatementsFrame():
function_statements_body = makeStatementsSequenceFromStatement(
statement=function_statements_body)
function_body.setBody(function_statements_body)
annotations = buildParameterAnnotations(provider, node, source_ref)
kw_defaults = buildParameterKwDefaults(provider=provider,
node=node,
function_body=creator_function_body,
source_ref=source_ref)
creator_function_body.setBody(
makeStatementsSequenceFromStatement(
statement=StatementReturn(expression=ExpressionMakeCoroutineObject(
coroutine_ref=ExpressionFunctionRef(
function_body=function_body, source_ref=source_ref),
code_object=code_object,
source_ref=source_ref),
source_ref=source_ref)))
function_creation = ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(function_body=creator_function_body,
source_ref=source_ref),
code_object=code_object,
defaults=defaults,
kw_defaults=kw_defaults,
annotations=annotations,
source_ref=source_ref)
decorated_function = function_creation
for decorator in decorators:
decorated_function = ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(elements=(decorated_function, ),
source_ref=source_ref),
source_ref=decorator.getSourceReference())
result = StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(variable_name=mangleName(
node.name, provider),
source_ref=source_ref),
source=decorated_function,
source_ref=source_ref)
function_body.qualname_setup = result.getTargetVariableRef()
return result
def _buildWithNode(provider, context_expr, assign_target, body, sync, source_ref):
# Many details, pylint: disable=too-many-branches,too-many-locals
with_source = buildNode(provider, context_expr, source_ref)
if python_version < 0x380 and Options.is_fullcompat:
source_ref = with_source.getCompatibleSourceReference()
temp_scope = provider.allocateTempScope("with")
tmp_source_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="source"
)
tmp_exit_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="exit"
)
tmp_enter_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="enter"
)
# Indicator variable, will end up with C bool type, and need not be released.
tmp_indicator_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="indicator", temp_type="bool"
)
statements = (
buildAssignmentStatements(
provider=provider,
node=assign_target,
allow_none=True,
source=ExpressionTempVariableRef(
variable=tmp_enter_variable, source_ref=source_ref
),
source_ref=source_ref,
),
body,
)
with_body = makeStatementsSequence(
statements=statements, allow_none=True, source_ref=source_ref
)
if body and python_version < 0x3A0:
deepest = body
while deepest.getVisitableNodes():
deepest = deepest.getVisitableNodes()[-1]
if python_version < 0x370:
body_lineno = deepest.getCompatibleSourceReference().getLineNumber()
else:
body_lineno = deepest.getSourceReference().getLineNumber()
with_exit_source_ref = source_ref.atLineNumber(body_lineno)
else:
with_exit_source_ref = source_ref
# The "__enter__" and "__exit__" were normal attribute lookups under
# CPython2.6, but that changed with CPython2.7.
if python_version < 0x270:
attribute_lookup_maker = makeExpressionAttributeLookup
else:
attribute_lookup_maker = ExpressionAttributeLookupSpecial
enter_value = ExpressionCallEmpty(
called=attribute_lookup_maker(
expression=ExpressionTempVariableRef(
variable=tmp_source_variable, source_ref=source_ref
),
attribute_name="__enter__" if sync else "__aenter__",
source_ref=source_ref,
),
source_ref=source_ref,
)
exit_value_exception = ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(
variable=tmp_exit_variable, source_ref=with_exit_source_ref
),
args=makeExpressionMakeTuple(
elements=(
ExpressionCaughtExceptionTypeRef(source_ref=with_exit_source_ref),
ExpressionCaughtExceptionValueRef(source_ref=with_exit_source_ref),
ExpressionCaughtExceptionTracebackRef(source_ref=source_ref),
),
source_ref=source_ref,
),
source_ref=with_exit_source_ref,
)
exit_value_no_exception = ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(
variable=tmp_exit_variable, source_ref=source_ref
),
args=makeConstantRefNode(constant=(None, None, None), source_ref=source_ref),
source_ref=with_exit_source_ref,
)
# For "async with", await the entered value and exit value must be awaited.
if not sync:
exit_value_exception = ExpressionYieldFromWaitable(
expression=ExpressionAsyncWaitExit(
expression=exit_value_exception, source_ref=source_ref
),
source_ref=source_ref,
)
exit_value_no_exception = ExpressionYieldFromWaitable(
ExpressionAsyncWaitExit(
expression=exit_value_no_exception, source_ref=source_ref
),
source_ref=source_ref,
)
# First assign the with context to a temporary variable.
statements = [
StatementAssignmentVariable(
variable=tmp_source_variable, source=with_source, source_ref=source_ref
)
]
# Before 3.9, __aenter__ is immediately awaited, after we first do __aexit__ lookup.
if not sync and python_version < 0x390:
enter_value = ExpressionYieldFromWaitable(
expression=ExpressionAsyncWaitEnter(
expression=enter_value, source_ref=source_ref
),
source_ref=source_ref,
)
attribute_enter_assignment = StatementAssignmentVariable(
variable=tmp_enter_variable, source=enter_value, source_ref=source_ref
)
attribute_exit_assignment = StatementAssignmentVariable(
variable=tmp_exit_variable,
source=attribute_lookup_maker(
expression=ExpressionTempVariableRef(
variable=tmp_source_variable, source_ref=source_ref
),
attribute_name="__exit__" if sync else "__aexit__",
source_ref=source_ref,
),
source_ref=source_ref,
)
# Next, assign "__enter__" and "__exit__" attributes to temporary variables, and
# depending on Python versions switch the order of these lookups and the order of
# awaiting enter.
# Normal "with" statements are enter, exit ordered after 3.6, and "async with"
# are since 3.9, and since 3.9 the enter is not awaited, until an exit is present.
if python_version >= 0x390 and not sync:
enter_await_statement = StatementAssignmentVariable(
variable=tmp_enter_variable,
source=ExpressionYieldFromWaitable(
expression=ExpressionAsyncWaitEnter(
expression=ExpressionTempVariableRef(
variable=tmp_enter_variable, source_ref=source_ref
),
source_ref=source_ref,
),
source_ref=source_ref,
),
source_ref=source_ref,
)
attribute_assignments = (
attribute_enter_assignment,
attribute_exit_assignment,
enter_await_statement,
)
elif python_version >= 0x360 and sync:
attribute_assignments = (attribute_enter_assignment, attribute_exit_assignment)
else:
attribute_assignments = (attribute_exit_assignment, attribute_enter_assignment)
statements.extend(attribute_assignments)
statements.append(
StatementAssignmentVariable(
variable=tmp_indicator_variable,
source=makeConstantRefNode(constant=True, source_ref=source_ref),
source_ref=source_ref,
)
)
statements += (
makeTryFinallyStatement(
provider=provider,
tried=makeTryExceptSingleHandlerNodeWithPublish(
provider=provider,
tried=with_body,
exception_name="BaseException",
handler_body=StatementsSequence(
statements=(
# Prevents final block from calling __exit__ as
# well.
StatementAssignmentVariable(
variable=tmp_indicator_variable,
source=makeConstantRefNode(
constant=False, source_ref=source_ref
),
source_ref=source_ref,
),
makeStatementConditional(
condition=exit_value_exception,
no_branch=makeReraiseExceptionStatement(
source_ref=with_exit_source_ref
),
yes_branch=None,
source_ref=with_exit_source_ref,
),
),
source_ref=source_ref,
),
public_exc=python_version >= 0x270,
source_ref=source_ref,
),
final=makeStatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=tmp_indicator_variable, source_ref=source_ref
),
right=makeConstantRefNode(constant=True, source_ref=source_ref),
source_ref=source_ref,
),
yes_branch=StatementExpressionOnly(
expression=exit_value_no_exception, source_ref=source_ref
),
no_branch=None,
source_ref=source_ref,
),
source_ref=source_ref,
),
)
return makeTryFinallyStatement(
provider=provider,
tried=statements,
final=(
StatementReleaseVariable(
variable=tmp_source_variable, source_ref=with_exit_source_ref
),
StatementReleaseVariable(
variable=tmp_enter_variable, source_ref=with_exit_source_ref
),
StatementReleaseVariable(
variable=tmp_exit_variable, source_ref=with_exit_source_ref
),
),
source_ref=source_ref,
)
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=R0914
class_statement_nodes, class_doc = extractDocFromBody(node)
function_body = ExpressionClassBody(provider=provider,
name=node.name,
doc=class_doc,
flags=set(),
source_ref=source_ref)
code_object = CodeObjectSpec(co_name=node.name,
co_kind="Class",
co_varnames=(),
co_argcount=0,
co_kwonlyargcount=0,
co_has_starlist=False,
co_has_stardict=False)
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()
# 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 = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__module__", source_ref=source_ref),
source=makeConstantRefNode(
constant=provider.getParentModule().getFullName(),
source_ref=source_ref,
user_provided=True),
source_ref=source_ref.atInternal())
]
if class_doc is not None:
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__doc__", source_ref=source_ref),
source=makeConstantRefNode(constant=class_doc,
source_ref=source_ref,
user_provided=True),
source_ref=source_ref.atInternal()))
statements += [
body,
StatementReturn(
expression=ExpressionBuiltinLocals(source_ref=source_ref),
source_ref=source_ref.atInternal())
]
body = makeStatementsSequence(statements=statements,
allow_none=True,
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")
statements = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_bases, source_ref=source_ref),
source=makeSequenceCreationOrConstant(sequence_kind="tuple",
elements=buildNodeList(
provider, node.bases,
source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class_dict, source_ref=source_ref),
source=ExpressionFunctionCall(function=ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(function_body=function_body,
source_ref=source_ref),
code_object=None,
defaults=(),
kw_defaults=None,
annotations=None,
source_ref=source_ref),
values=(),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_metaclass, source_ref=source_ref),
source=ExpressionConditional(
condition=ExpressionComparisonIn(
left=makeConstantRefNode(constant="__metaclass__",
source_ref=source_ref,
user_provided=True),
right=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=ExpressionSelectMetaclass(
metaclass=None,
bases=ExpressionTempVariableRef(variable=tmp_bases,
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class, source_ref=source_ref),
source=ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(variable=tmp_metaclass,
source_ref=source_ref),
args=ExpressionMakeTuple(
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),
source_ref=source_ref),
source_ref=source_ref),
]
for decorator in buildNodeList(provider, reversed(node.decorator_list),
source_ref):
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class, source_ref=source_ref),
source=ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(
elements=(ExpressionTempVariableRef(
variable=tmp_class, source_ref=source_ref), ),
source_ref=source_ref),
source_ref=decorator.getSourceReference()),
source_ref=decorator.getSourceReference()))
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(variable_name=node.name,
source_ref=source_ref),
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)
def _buildClassNode3(provider, node, source_ref):
# Many variables, due to the huge re-formulation that is going on here,
# which just has the complexity, pylint: disable=R0914
# This function is the Python3 special case with special re-formulation as
# according to developer manual.
class_statements, class_doc = extractDocFromBody(node)
# We need a scope for the temporary variables, and they might be closured.
temp_scope = provider.allocateTempScope(name="class_creation",
allow_closure=True)
tmp_bases = provider.allocateTempVariable(temp_scope=temp_scope,
name="bases")
tmp_class_decl_dict = provider.allocateTempVariable(temp_scope=temp_scope,
name="class_decl_dict")
tmp_metaclass = provider.allocateTempVariable(temp_scope=temp_scope,
name="metaclass")
tmp_prepared = provider.allocateTempVariable(temp_scope=temp_scope,
name="prepared")
class_creation_function = ExpressionFunctionBody(
provider=provider,
is_class=True,
parameters=make_class_parameters,
name=node.name,
doc=class_doc,
source_ref=source_ref)
# Hack: This allows some APIs to work although this is not yet officially a
# child yet.
class_creation_function.parent = provider
body = buildStatementsNode(provider=class_creation_function,
nodes=class_statements,
frame=True,
source_ref=source_ref)
source_ref_orig = source_ref
if body is not None:
# The frame guard has nothing to tell its line number to.
body.source_ref = source_ref
module_variable = class_creation_function.getVariableForAssignment(
"__module__")
statements = [
StatementSetLocals(new_locals=ExpressionTempVariableRef(
variable=tmp_prepared.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__module__",
variable=module_variable,
source_ref=source_ref),
source=ExpressionConstantRef(
constant=provider.getParentModule().getFullName(),
source_ref=source_ref,
user_provided=True),
source_ref=source_ref)
]
if class_doc is not None:
doc_variable = class_creation_function.getVariableForAssignment(
"__doc__")
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__doc__",
variable=doc_variable,
source_ref=source_ref),
source=ExpressionConstantRef(constant=class_doc,
source_ref=source_ref,
user_provided=True),
source_ref=source_ref))
# The "__qualname__" attribute is new in Python 3.3.
if Utils.python_version >= 330:
qualname = class_creation_function.getFunctionQualname()
qualname_variable = class_creation_function.getVariableForAssignment(
"__qualname__")
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__qualname__",
variable=qualname_variable,
source_ref=source_ref),
source=ExpressionConstantRef(constant=qualname,
source_ref=source_ref,
user_provided=True),
source_ref=source_ref))
if Utils.python_version >= 340 and False: # TODO: Temporarily reverted:
tmp_class = class_creation_function.allocateTempVariable(
temp_scope=None, name="__class__")
class_target_variable_ref = ExpressionTargetTempVariableRef(
variable=tmp_class.makeReference(class_creation_function),
source_ref=source_ref)
class_variable_ref = ExpressionTempVariableRef(
variable=tmp_class.makeReference(class_creation_function),
source_ref=source_ref)
else:
class_variable = class_creation_function.getVariableForAssignment(
"__class__")
class_target_variable_ref = ExpressionTargetVariableRef(
variable_name="__class__",
variable=class_variable,
source_ref=source_ref)
class_variable_ref = ExpressionVariableRef(variable_name="__class__",
variable=class_variable,
source_ref=source_ref)
statements += [
body,
StatementAssignmentVariable(
variable_ref=class_target_variable_ref,
source=ExpressionCall(
called=ExpressionTempVariableRef(
variable=tmp_metaclass.makeReference(provider),
source_ref=source_ref),
args=makeSequenceCreationOrConstant(
sequence_kind="tuple",
elements=(ExpressionConstantRef(constant=node.name,
source_ref=source_ref,
user_provided=True),
ExpressionTempVariableRef(
variable=tmp_bases.makeReference(provider),
source_ref=source_ref),
ExpressionBuiltinLocals(source_ref=source_ref)),
source_ref=source_ref),
kw=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementReturn(expression=class_variable_ref, source_ref=source_ref)
]
body = makeStatementsSequence(statements=statements,
allow_none=True,
source_ref=source_ref)
# The class body is basically a function that implicitely, at the end
# returns its locals and cannot have other return statements contained.
class_creation_function.setBody(body)
# The class body is basically a function that implicitely, at the end
# returns its created class and cannot have other return statements
# contained.
decorated_body = ExpressionFunctionCall(
function=ExpressionFunctionCreation(function_ref=ExpressionFunctionRef(
function_body=class_creation_function, source_ref=source_ref),
defaults=(),
kw_defaults=None,
annotations=None,
source_ref=source_ref),
values=(),
source_ref=source_ref)
for decorator in buildNodeList(provider, reversed(node.decorator_list),
source_ref):
decorated_body = ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(elements=(decorated_body, ),
source_ref=source_ref),
source_ref=decorator.getSourceReference())
statements = (
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_bases.makeReference(provider),
source_ref=source_ref),
source=makeSequenceCreationOrConstant(sequence_kind="tuple",
elements=buildNodeList(
provider, node.bases,
source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class_decl_dict.makeReference(provider),
source_ref=source_ref),
source=makeDictCreationOrConstant(keys=[
ExpressionConstantRef(constant=keyword.arg,
source_ref=source_ref,
user_provided=True)
for keyword in node.keywords
],
values=[
buildNode(
provider, keyword.value,
source_ref)
for keyword in node.keywords
],
lazy_order=False,
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_metaclass.makeReference(provider),
source_ref=source_ref),
source=ExpressionSelectMetaclass(metaclass=ExpressionConditional(
condition=ExpressionComparison(
comparator="In",
left=ExpressionConstantRef(constant="metaclass",
source_ref=source_ref,
user_provided=True),
right=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
yes_expression=ExpressionDictOperationGet(
dicte=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(provider),
source_ref=source_ref),
key=ExpressionConstantRef(constant="metaclass",
source_ref=source_ref,
user_provided=True),
source_ref=source_ref),
no_expression=ExpressionConditional(
condition=ExpressionTempVariableRef(
variable=tmp_bases.makeReference(provider),
source_ref=source_ref),
no_expression=ExpressionBuiltinRef(builtin_name="type",
source_ref=source_ref),
yes_expression=ExpressionBuiltinType1(
value=ExpressionSubscriptLookup(
expression=ExpressionTempVariableRef(
variable=tmp_bases.makeReference(provider),
source_ref=source_ref),
subscript=ExpressionConstantRef(
constant=0,
source_ref=source_ref,
user_provided=True),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
bases=ExpressionTempVariableRef(
variable=tmp_bases.
makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref_orig),
StatementConditional(
condition=ExpressionComparison(
comparator="In",
left=ExpressionConstantRef(constant="metaclass",
source_ref=source_ref,
user_provided=True),
right=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
no_branch=None,
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementDictOperationRemove(
dicte=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(provider),
source_ref=source_ref),
key=ExpressionConstantRef(constant="metaclass",
source_ref=source_ref,
user_provided=True),
source_ref=source_ref)),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_prepared.makeReference(provider),
source_ref=source_ref),
source=ExpressionConditional(
condition=ExpressionBuiltinHasattr(
object=ExpressionTempVariableRef(
variable=tmp_metaclass.makeReference(provider),
source_ref=source_ref),
name=ExpressionConstantRef(constant="__prepare__",
source_ref=source_ref,
user_provided=True),
source_ref=source_ref),
no_expression=ExpressionConstantRef(constant={},
source_ref=source_ref,
user_provided=True),
yes_expression=ExpressionCall(
called=ExpressionAttributeLookup(
expression=ExpressionTempVariableRef(
variable=tmp_metaclass.makeReference(provider),
source_ref=source_ref),
attribute_name="__prepare__",
source_ref=source_ref),
args=ExpressionMakeTuple(elements=(
ExpressionConstantRef(constant=node.name,
source_ref=source_ref,
user_provided=True),
ExpressionTempVariableRef(
variable=tmp_bases.makeReference(provider),
source_ref=source_ref)),
source_ref=source_ref),
kw=ExpressionTempVariableRef(
variable=tmp_class_decl_dict.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(variable_ref=ExpressionTargetVariableRef(
variable_name=node.name, source_ref=source_ref),
source=decorated_body,
source_ref=source_ref),
)
final = (StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_bases.makeReference(provider), source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class_decl_dict.makeReference(provider),
source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_metaclass.makeReference(provider),
source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_prepared.makeReference(provider),
source_ref=source_ref),
tolerant=True,
source_ref=source_ref))
return makeTryFinallyStatement(tried=statements,
final=final,
source_ref=source_ref)
def _buildWithNode(provider, context_expr, assign_target, body, body_lineno,
sync, source_ref):
# Many details, pylint: disable=too-many-locals
with_source = buildNode(provider, context_expr, source_ref)
if Options.isFullCompat():
source_ref = with_source.getCompatibleSourceReference()
temp_scope = provider.allocateTempScope("with")
tmp_source_variable = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "source"
)
tmp_exit_variable = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "exit"
)
tmp_enter_variable = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "enter"
)
tmp_indicator_variable = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "indicator"
)
statements = (
buildAssignmentStatements(
provider = provider,
node = assign_target,
allow_none = True,
source = ExpressionTempVariableRef(
variable = tmp_enter_variable,
source_ref = source_ref
),
source_ref = source_ref
),
body
)
with_body = makeStatementsSequence(
statements = statements,
allow_none = True,
source_ref = source_ref
)
if Options.isFullCompat():
if body:
deepest = body
while deepest.getVisitableNodes():
deepest = deepest.getVisitableNodes()[-1]
body_lineno = deepest.getCompatibleSourceReference().getLineNumber()
with_exit_source_ref = source_ref.atLineNumber(body_lineno)
else:
with_exit_source_ref = source_ref
# The "__enter__" and "__exit__" were normal attribute lookups under
# CPython2.6, but that changed with CPython2.7.
if python_version < 270:
attribute_lookup_class = ExpressionAttributeLookup
else:
attribute_lookup_class = ExpressionAttributeLookupSpecial
enter_value = ExpressionCallEmpty(
called = attribute_lookup_class(
source = ExpressionTempVariableRef(
variable = tmp_source_variable,
source_ref = source_ref
),
attribute_name = "__enter__" if sync else "__aenter__",
source_ref = source_ref
),
source_ref = source_ref
)
exit_value_exception = ExpressionCallNoKeywords(
called = ExpressionTempVariableRef(
variable = tmp_exit_variable,
source_ref = with_exit_source_ref
),
args = ExpressionMakeTuple(
elements = (
ExpressionCaughtExceptionTypeRef(
source_ref = with_exit_source_ref
),
ExpressionCaughtExceptionValueRef(
source_ref = with_exit_source_ref
),
ExpressionCaughtExceptionTracebackRef(
source_ref = source_ref
),
),
source_ref = source_ref
),
source_ref = with_exit_source_ref
)
exit_value_no_exception = ExpressionCallNoKeywords(
called = ExpressionTempVariableRef(
variable = tmp_exit_variable,
source_ref = source_ref
),
args = makeConstantRefNode(
constant = (None, None, None),
source_ref = source_ref
),
source_ref = with_exit_source_ref
)
# For "async with", await the entered value and exit value must be awaited.
if not sync:
enter_value = ExpressionAsyncWait(
expression = enter_value,
source_ref = source_ref
)
exit_value_exception = ExpressionAsyncWait(
expression = exit_value_exception,
source_ref = source_ref
)
exit_value_no_exception = ExpressionAsyncWait(
expression = exit_value_no_exception,
source_ref = source_ref
)
statements = [
# First assign the with context to a temporary variable.
StatementAssignmentVariable(
variable = tmp_source_variable,
source = with_source,
source_ref = source_ref
)
]
attribute_assignments = [
# Next, assign "__enter__" and "__exit__" attributes to temporary
# variables.
StatementAssignmentVariable(
variable = tmp_exit_variable,
source = attribute_lookup_class(
source = ExpressionTempVariableRef(
variable = tmp_source_variable,
source_ref = source_ref
),
attribute_name = "__exit__" if sync else "__aexit__",
source_ref = source_ref
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable = tmp_enter_variable,
source = enter_value,
source_ref = source_ref
)
]
if python_version >= 360 and sync:
attribute_assignments.reverse()
statements += attribute_assignments
statements.append(
StatementAssignmentVariable(
variable = tmp_indicator_variable,
source = makeConstantRefNode(
constant = True,
source_ref = source_ref
),
source_ref = source_ref
)
)
statements += [
makeTryFinallyStatement(
provider = provider,
tried = makeTryExceptSingleHandlerNodeWithPublish(
provider = provider,
tried = with_body,
exception_name = "BaseException",
handler_body = StatementsSequence(
statements = (
# Prevents final block from calling __exit__ as
# well.
StatementAssignmentVariable(
variable = tmp_indicator_variable,
source = makeConstantRefNode(
constant = False,
source_ref = source_ref
),
source_ref = source_ref
),
makeConditionalStatement(
condition = exit_value_exception,
no_branch = makeReraiseExceptionStatement(
source_ref = with_exit_source_ref
),
yes_branch = None,
source_ref = with_exit_source_ref
),
),
source_ref = source_ref
),
public_exc = python_version >= 270,
source_ref = source_ref
),
final = StatementConditional(
condition = ExpressionComparisonIs(
left = ExpressionTempVariableRef(
variable = tmp_indicator_variable,
source_ref = source_ref
),
right = makeConstantRefNode(
constant = True,
source_ref = source_ref
),
source_ref = source_ref
),
yes_branch = makeStatementsSequenceFromStatement(
statement = StatementExpressionOnly(
expression = exit_value_no_exception,
source_ref = source_ref
)
),
no_branch = None,
source_ref = source_ref
),
source_ref = source_ref
)
]
return makeTryFinallyStatement(
provider = provider,
tried = statements,
final = (
StatementReleaseVariable(
variable = tmp_source_variable,
source_ref = with_exit_source_ref
),
StatementReleaseVariable(
variable = tmp_enter_variable,
source_ref = with_exit_source_ref
),
StatementReleaseVariable(
variable = tmp_exit_variable,
source_ref = with_exit_source_ref
),
StatementReleaseVariable(
variable = tmp_indicator_variable,
source_ref = with_exit_source_ref
),
),
source_ref = source_ref
)
def _buildClassNode2(provider, node, source_ref):
class_statements, class_doc = extractDocFromBody(node)
# This function is the Python3 special case with special re-formulation as according
# to developer manual.
# The result will be a temp block that holds the temporary variables.
result = StatementTempBlock(source_ref=source_ref)
tmp_bases = result.getTempVariable("bases")
tmp_class_dict = result.getTempVariable("class_dict")
tmp_metaclass = result.getTempVariable("metaclass")
tmp_class = result.getTempVariable("class")
class_creation_function = ExpressionFunctionBody(
provider=provider,
is_class=True,
parameters=make_class_parameters,
name=node.name,
doc=class_doc,
source_ref=source_ref)
body = buildStatementsNode(provider=class_creation_function,
nodes=class_statements,
frame=True,
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()
# The class body is basically a function that implicitely, 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 = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__module__", source_ref=source_ref),
source=ExpressionConstantRef(
constant=provider.getParentModule().getName(),
source_ref=source_ref),
source_ref=source_ref.atInternal())
]
if class_doc is not None:
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(
variable_name="__doc__", source_ref=source_ref),
source=ExpressionConstantRef(constant=class_doc,
source_ref=source_ref),
source_ref=source_ref.atInternal()))
statements += [
body,
StatementReturn(
expression=ExpressionBuiltinLocals(source_ref=source_ref),
source_ref=source_ref.atInternal())
]
body = makeStatementsSequence(statements=statements,
allow_none=True,
source_ref=source_ref)
# The class body is basically a function that implicitely, at the end returns its
# locals and cannot have other return statements contained.
class_creation_function.setBody(body)
statements = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref),
source=ExpressionMakeTuple(elements=buildNodeList(
provider, node.bases, source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class_dict.makeReference(result),
source_ref=source_ref),
source=ExpressionFunctionCall(function=ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(
function_body=class_creation_function,
source_ref=source_ref),
defaults=(),
kw_defaults=None,
annotations=None,
source_ref=source_ref),
values=(),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_metaclass.makeReference(result),
source_ref=source_ref),
source=ExpressionConditional(
condition=ExpressionComparison(
comparator="In",
left=ExpressionConstantRef(constant="__metaclass__",
source_ref=source_ref),
right=ExpressionTempVariableRef(
variable=tmp_class_dict.makeReference(result),
source_ref=source_ref),
source_ref=source_ref),
yes_expression=ExpressionDictOperationGet(
dicte=ExpressionTempVariableRef(
variable=tmp_class_dict.makeReference(result),
source_ref=source_ref),
key=ExpressionConstantRef(constant="__metaclass__",
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionSelectMetaclass(
metaclass=None,
bases=ExpressionTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class.makeReference(result),
source_ref=source_ref),
source=ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(
variable=tmp_metaclass.makeReference(result),
source_ref=source_ref),
args=ExpressionMakeTuple(elements=(
ExpressionConstantRef(constant=node.name,
source_ref=source_ref),
ExpressionTempVariableRef(
variable=tmp_bases.makeReference(result),
source_ref=source_ref),
ExpressionTempVariableRef(
variable=tmp_class_dict.makeReference(result),
source_ref=source_ref)),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref)
]
for decorator in buildNodeList(provider, reversed(node.decorator_list),
source_ref):
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_class.makeReference(result),
source_ref=source_ref),
source=ExpressionCallNoKeywords(
called=decorator,
args=ExpressionMakeTuple(
elements=(ExpressionTempVariableRef(
variable=tmp_class.makeReference(result),
source_ref=source_ref), ),
source_ref=source_ref),
source_ref=decorator.getSourceReference()),
source_ref=decorator.getSourceReference()))
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetVariableRef(variable_name=node.name,
source_ref=source_ref),
source=ExpressionTempVariableRef(
variable=tmp_class.makeReference(result),
source_ref=source_ref),
source_ref=source_ref))
result.setBody(
StatementsSequence(statements=statements, source_ref=source_ref))
return result
