def wrapSuperBuiltin(type_arg, object_arg, source_ref):
if type_arg is None and python_version >= 300:
type_arg = ExpressionVariableRef(variable_name="__class__",
source_ref=source_ref)
# Ought to be already closure taken.
type_arg.setVariable(
provider.getVariableForReference(variable_name="__class__"))
# If we already have this as a local variable, then use that
# instead.
type_arg_owner = type_arg.getVariable().getOwner()
if type_arg_owner is provider or \
not (type_arg_owner.isExpressionFunctionBody() or \
type_arg_owner.isExpressionClassBody()):
type_arg = None
if type_arg is None:
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError"
if python_version < 331 else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
if object_arg is None:
if provider.isExpressionGeneratorObjectBody() or \
provider.isExpressionCoroutineObjectBody() or \
provider.isExpressionAsyncgenObjectBody():
parameter_provider = provider.getParentVariableProvider()
else:
parameter_provider = provider
if parameter_provider.getParameters().getArgumentCount() > 0:
par1_name = parameter_provider.getParameters(
).getArgumentNames()[0]
object_arg = ExpressionVariableRef(variable_name=par1_name,
source_ref=source_ref)
object_arg.setVariable(
provider.getVariableForReference(
variable_name=par1_name))
if not object_arg.getVariable().isParameterVariable():
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError"
if python_version < 330 else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
else:
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="RuntimeError",
exception_value="super(): no arguments")
return ExpressionBuiltinSuper(super_type=type_arg,
super_object=object_arg,
source_ref=source_ref)
def wrapSuperBuiltin( type, object, source_ref ):
if type is None and python_version >= 300:
provider = node.getParentVariableProvider()
type = ExpressionVariableRef(
variable_name = "__class__",
source_ref = source_ref
)
# Ought to be already closure taken.
type.setVariable(
provider.getVariableForReference(
variable_name = "__class__"
)
)
from nuitka.nodes.NodeMakingHelpers import makeRaiseExceptionReplacementExpression
if not type.getVariable().isClosureReference():
return makeRaiseExceptionReplacementExpression(
expression = node,
exception_type = "SystemError"
if python_version < 331 else
"RuntimeError",
exception_value = "super(): __class__ cell not found",
)
if object is None and provider.getParameters().getArgumentCount() > 0:
par1_name = provider.getParameters().getArgumentNames()[0]
# TODO: Nested first argument would kill us here, need a test
# for that.
object = ExpressionVariableRef(
variable_name = par1_name,
source_ref = source_ref
)
object.setVariable(
node.getParentVariableProvider().getVariableForReference(
variable_name = par1_name
)
)
if not object.getVariable().isParameterVariable():
return makeRaiseExceptionReplacementExpression(
expression = node,
exception_type = "SystemError"
if python_version < 330 else
"RuntimeError",
exception_value = "super(): __class__ cell not found",
)
return ExpressionBuiltinSuper(
super_type = type,
super_object = object,
source_ref = source_ref
)
def wrapSuperBuiltin(type_arg, object_arg, source_ref):
if type_arg is None and python_version >= 300:
provider = node.getParentVariableProvider()
if python_version < 340 or True: # TODO: Temporarily reverted:
type_arg = ExpressionVariableRef(variable_name="__class__", source_ref=source_ref)
# Ought to be already closure taken.
type_arg.setVariable(provider.getVariableForClosure(variable_name="__class__"))
# If we already have this as a local variable, then use that
# instead.
if type_arg.getVariable().getOwner() is provider:
type_arg = None
else:
addVariableUsage(type_arg.getVariable(), provider)
else:
parent_provider = provider.getParentVariableProvider()
class_var = parent_provider.getTempVariable(temp_scope=None, name="__class__")
type_arg = ExpressionTempVariableRef(variable=class_var, source_ref=source_ref)
addVariableUsage(type_arg.getVariable(), provider)
if type_arg is None:
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError" if python_version < 331 else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
if object_arg is None:
if provider.getParameters().getArgumentCount() > 0:
par1_name = provider.getParameters().getArgumentNames()[0]
# TODO: Nested first argument would kill us here, need a
# test for that.
object_arg = ExpressionVariableRef(variable_name=par1_name, source_ref=source_ref)
object_arg.setVariable(provider.getVariableForReference(variable_name=par1_name))
if not object_arg.getVariable().isParameterVariable():
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError" if python_version < 330 else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
else:
return makeRaiseExceptionReplacementExpression(
expression=node, exception_type="RuntimeError", exception_value="super(): no arguments"
)
return ExpressionBuiltinSuper(super_type=type_arg, super_object=object_arg, source_ref=source_ref)
def wrapSuperBuiltin(type, object, source_ref):
if type is None and python_version >= 300:
provider = node.getParentVariableProvider()
type = ExpressionVariableRef(variable_name="__class__",
source_ref=source_ref)
# Ought to be already closure taken.
type.setVariable(
provider.getVariableForReference(variable_name="__class__"))
from nuitka.nodes.NodeMakingHelpers import makeRaiseExceptionReplacementExpression
if not type.getVariable().isClosureReference():
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError"
if python_version < 331 else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
if object is None and provider.getParameters().getArgumentCount(
) > 0:
par1_name = provider.getParameters().getArgumentNames()[0]
# TODO: Nested first argument would kill us here, need a test
# for that.
object = ExpressionVariableRef(variable_name=par1_name,
source_ref=source_ref)
object.setVariable(
node.getParentVariableProvider().getVariableForReference(
variable_name=par1_name))
if not object.getVariable().isParameterVariable():
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError"
if python_version < 330 else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
return ExpressionBuiltinSuper(super_type=type,
super_object=object,
source_ref=source_ref)
def computeBuiltinCall(call_node, called):
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
if new_node is None:
return call_node, None, None
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = "Replaced dynamic builtin import %s with static module import." % inspect_node.kind
elif inspect_node.isExpressionBuiltin(
) or inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to builtin with builtin call %s." % inspect_node.kind
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = "Replaced call to builtin %s with exception raising call." % inspect_node.kind
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = "Replaced call to builtin %s with unary operation %s." % (
inspect_node.kind, inspect_node.getOperator())
else:
assert False, (builtin_name, "->", inspect_node)
# TODO: One day, this should be enabled by default and call either the original
# built-in or the optimized above one. That should be done, once we can eliminate
# the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
from nuitka.nodes.ConditionalNodes import ExpressionConditional
from nuitka.nodes.ComparisonNodes import ExpressionComparisonIs
from nuitka.nodes.BuiltinRefNodes import (
ExpressionBuiltinExceptionRef,
ExpressionBuiltinOriginalRef,
ExpressionBuiltinRef,
)
from nuitka.nodes.ExceptionNodes import ExpressionRaiseException
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition=ExpressionComparisonIs(
left=ExpressionBuiltinRef(builtin_name=builtin_name,
source_ref=source_ref),
right=ExpressionBuiltinOriginalRef(
builtin_name=builtin_name, source_ref=source_ref),
source_ref=source_ref),
yes_expression=new_node,
no_expression=makeRaiseExceptionReplacementExpression(
exception_type="RuntimeError",
exception_value="Builtin '%s' was overloaded'" %
builtin_name,
expression=call_node),
source_ref=source_ref)
return new_node, tags, message
else:
# TODO: Consider giving warnings, whitelisted potentially
return call_node, None, None
def computeBuiltinCall(call_node, called):
# There is some dispatching for how to output various types of changes,
# with lots of cases, pylint: disable=R0912
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
# Lets just have this contract to return "None" when no change is meant
# to be done.
assert new_node is not call_node
if new_node is None:
return call_node, None, None
# For traces, we are going to ignore side effects, and output traces
# only based on the basis of it.
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = """\
Replaced dynamic __import__ %s with static module import.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionBuiltin() or inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to built-in '%s' with built-in call '%s'." % (builtin_name, inspect_node.kind)
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = """\
Replaced call to built-in '%s' with exception raising call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with unary operation '%s'.""" % (
inspect_node.kind,
inspect_node.getOperator(),
)
elif inspect_node.isExpressionCall():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOutlineBody():
tags = "new_expression"
message = (
"""\
Replaced call to built-in '%s' with outlined call."""
% builtin_name
)
else:
assert False, (builtin_name, "->", inspect_node)
# TODO: One day, this should be enabled by default and call either the
# original built-in or the optimized above one. That should be done,
# once we can eliminate the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition=ExpressionComparisonIs(
left=ExpressionBuiltinRef(builtin_name=builtin_name, source_ref=source_ref),
right=ExpressionBuiltinOriginalRef(builtin_name=builtin_name, source_ref=source_ref),
source_ref=source_ref,
),
expression_yes=new_node,
expression_no=makeRaiseExceptionReplacementExpression(
exception_type="RuntimeError",
exception_value="Built-in '%s' cannot be replaced." % (builtin_name),
expression=call_node,
),
source_ref=source_ref,
)
assert tags != ""
return new_node, tags, message
else:
if False and isDebug() and builtin_name not in _builtin_white_list:
warning("Not handling built-in '%s', consider support." % builtin_name)
return call_node, None, None
def computeBuiltinCall(call_node, called):
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
# Lets just have this contract to return "None" when no change is meant
# to be done.
assert new_node is not call_node
if new_node is None:
return call_node, None, None
# For traces, we are going to ignore side effects, and output traces
# only based on the basis of it.
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = """\
Replaced dynamic __import__ %s with static module import.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionBuiltin() or \
inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to builtin %s with builtin call %s." % (
builtin_name,
inspect_node.kind,
)
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = """\
Replaced call to builtin %s with exception raising call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = """\
Replaced call to builtin %s with unary operation %s.""" % (
inspect_node.kind,
inspect_node.getOperator()
)
elif inspect_node.isExpressionCall():
tags = "new_expression"
message = """\
Replaced call to builtin %s with call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionTryFinally():
tags = "new_expression"
message = """\
Replaced call to builtin %s with try/finally guarded call.""" % (
inspect_node.getExpression().kind,
)
else:
assert False, ( builtin_name, "->", inspect_node )
# TODO: One day, this should be enabled by default and call either the
# original built-in or the optimized above one. That should be done,
# once we can eliminate the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
from nuitka.nodes.NodeMakingHelpers import \
makeRaiseExceptionReplacementExpression
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinRef(
builtin_name = builtin_name,
source_ref = source_ref
),
right = ExpressionBuiltinOriginalRef(
builtin_name = builtin_name,
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = new_node,
no_expression = makeRaiseExceptionReplacementExpression(
exception_type = "RuntimeError",
exception_value = "Builtin '%s' was overloaded'" % (
builtin_name
),
expression = call_node
),
source_ref = source_ref
)
assert tags != ""
return new_node, tags, message
else:
# TODO: Consider giving warnings, whitelisted potentially
return call_node, None, None
def wrapSuperBuiltin(type_arg, object_arg, source_ref):
if type_arg is None and python_version >= 300:
if provider.isCompiledPythonModule():
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="RuntimeError",
exception_value="super(): no arguments",
)
class_variable = provider.getVariableForReference(
variable_name="__class__")
provider.trace_collection.getVariableCurrentTrace(
class_variable).addUsage()
type_arg = ExpressionVariableRef(
# Ought to be already closure taken due to "super" flag in
# tree building.
variable=class_variable,
source_ref=source_ref,
)
# If we already have this as a local variable, then use that
# instead.
type_arg_owner = type_arg.getVariable().getOwner()
if type_arg_owner is provider or not (
type_arg_owner.isExpressionFunctionBody()
or type_arg_owner.isExpressionClassBody()):
type_arg = None
if type_arg is None:
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError"
if python_version < 331 else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
if object_arg is None:
if (provider.isExpressionGeneratorObjectBody()
or provider.isExpressionCoroutineObjectBody()
or provider.isExpressionAsyncgenObjectBody()):
parameter_provider = provider.getParentVariableProvider()
else:
parameter_provider = provider
if parameter_provider.getParameters().getArgumentCount() > 0:
par1_name = parameter_provider.getParameters(
).getArgumentNames()[0]
object_variable = provider.getVariableForReference(
variable_name=par1_name)
provider.trace_collection.getVariableCurrentTrace(
object_variable).addUsage()
object_arg = ExpressionVariableRef(
variable=object_variable, source_ref=source_ref)
if not object_arg.getVariable().isParameterVariable():
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError"
if python_version < 300 else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
else:
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="RuntimeError",
exception_value="super(): no arguments",
)
return ExpressionBuiltinSuper(super_type=type_arg,
super_object=object_arg,
source_ref=source_ref)
def wrapSuperBuiltin(type_arg, object_arg, source_ref):
if type_arg is None and python_version >= 300:
provider = node.getParentVariableProvider()
type_arg = ExpressionVariableRef(
variable_name = "__class__",
source_ref = source_ref
)
# Ought to be already closure taken.
type_arg.setVariable(
provider.getVariableForReference(
variable_name = "__class__"
)
)
# If we already have this as a local variable, then use that
# instead.
type_arg_owner = type_arg.getVariable().getOwner()
if type_arg_owner is provider or \
not (type_arg_owner.isExpressionFunctionBody() or \
type_arg_owner.isExpressionClassBody()):
type_arg = None
else:
addVariableUsage(type_arg.getVariable(), provider)
if type_arg is None:
return makeRaiseExceptionReplacementExpression(
expression = node,
exception_type = "SystemError"
if python_version < 331 else
"RuntimeError",
exception_value = "super(): __class__ cell not found",
)
if object_arg is None:
if provider.isExpressionGeneratorObjectBody():
parameter_provider = provider.getParentVariableProvider()
else:
parameter_provider = provider
if parameter_provider.getParameters().getArgumentCount() > 0:
par1_name = parameter_provider.getParameters().getArgumentNames()[0]
object_arg = ExpressionVariableRef(
variable_name = par1_name,
source_ref = source_ref
)
object_arg.setVariable(
provider.getVariableForReference(
variable_name = par1_name
)
)
if not object_arg.getVariable().isParameterVariable():
return makeRaiseExceptionReplacementExpression(
expression = node,
exception_type = "SystemError"
if python_version < 330 else
"RuntimeError",
exception_value = "super(): __class__ cell not found",
)
else:
return makeRaiseExceptionReplacementExpression(
expression = node,
exception_type = "RuntimeError",
exception_value = "super(): no arguments"
)
return ExpressionBuiltinSuper(
super_type = type_arg,
super_object = object_arg,
source_ref = source_ref
)
def computeBuiltinCall(call_node, called):
# There is some dispatching for how to output various types of changes,
# with lots of cases, pylint: disable=R0912
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
# Lets just have this contract to return "None" when no change is meant
# to be done.
assert new_node is not call_node
if new_node is None:
return call_node, None, None
# For traces, we are going to ignore side effects, and output traces
# only based on the basis of it.
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = """\
Replaced dynamic __import__ %s with static module import.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionBuiltin() or \
inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to built-in '%s' with built-in call '%s'." % (
builtin_name,
inspect_node.kind,
)
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = """\
Replaced call to built-in '%s' with exception raising call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with unary operation '%s'.""" % (
inspect_node.kind,
inspect_node.getOperator()
)
elif inspect_node.isExpressionCall():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOutlineBody():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with outlined call.""" % builtin_name
else:
assert False, (builtin_name, "->", inspect_node)
# TODO: One day, this should be enabled by default and call either the
# original built-in or the optimized above one. That should be done,
# once we can eliminate the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinRef(
builtin_name = builtin_name,
source_ref = source_ref
),
right = ExpressionBuiltinOriginalRef(
builtin_name = builtin_name,
source_ref = source_ref
),
source_ref = source_ref
),
expression_yes = new_node,
expression_no = makeRaiseExceptionReplacementExpression(
exception_type = "RuntimeError",
exception_value = "Built-in '%s' cannot be replaced." % (
builtin_name
),
expression = call_node
),
source_ref = source_ref
)
assert tags != ""
return new_node, tags, message
else:
if False and isDebug() and builtin_name not in _builtin_white_list:
warning(
"Not handling built-in '%s', consider support." % builtin_name
)
return call_node, None, None
def wrapSuperBuiltin(type_arg, object_arg, source_ref):
if type_arg is None and python_version >= 300:
if provider.isCompiledPythonModule():
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="RuntimeError",
exception_value="super(): no arguments",
)
class_variable = provider.getVariableForReference(variable_name="__class__")
provider.trace_collection.getVariableCurrentTrace(class_variable).addUsage()
type_arg = ExpressionVariableRef(
# Ought to be already closure taken due to "super" flag in
# tree building.
variable=class_variable,
source_ref=source_ref,
)
# If we already have this as a local variable, then use that
# instead.
type_arg_owner = type_arg.getVariable().getOwner()
if type_arg_owner is provider or not (
type_arg_owner.isExpressionFunctionBody()
or type_arg_owner.isExpressionClassBody()
):
type_arg = None
if type_arg is None:
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError"
if python_version < 331
else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
if object_arg is None:
if (
provider.isExpressionGeneratorObjectBody()
or provider.isExpressionCoroutineObjectBody()
or provider.isExpressionAsyncgenObjectBody()
):
parameter_provider = provider.getParentVariableProvider()
else:
parameter_provider = provider
if parameter_provider.getParameters().getArgumentCount() > 0:
par1_name = parameter_provider.getParameters().getArgumentNames()[0]
object_variable = provider.getVariableForReference(
variable_name=par1_name
)
provider.trace_collection.getVariableCurrentTrace(
object_variable
).addUsage()
object_arg = ExpressionVariableRef(
variable=object_variable, source_ref=source_ref
)
if not object_arg.getVariable().isParameterVariable():
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="SystemError"
if python_version < 300
else "RuntimeError",
exception_value="super(): __class__ cell not found",
)
else:
return makeRaiseExceptionReplacementExpression(
expression=node,
exception_type="RuntimeError",
exception_value="super(): no arguments",
)
return ExpressionBuiltinSuper(
super_type=type_arg, super_object=object_arg, source_ref=source_ref
)
def computeBuiltinCall(call_node, called):
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
# Lets just have this contract to return "None" when no change is meant
# to be done.
assert new_node is not call_node
if new_node is None:
return call_node, None, None
# For traces, we are going to ignore side effects, and output traces
# only based on the basis of it.
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = """\
Replaced dynamic __import__ %s with static module import.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionBuiltin() or \
inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to builtin %s with builtin call %s." % (
builtin_name,
inspect_node.kind,
)
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = """\
Replaced call to builtin %s with exception raising call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = """\
Replaced call to builtin %s with unary operation %s.""" % (
inspect_node.kind,
inspect_node.getOperator()
)
elif inspect_node.isExpressionCall():
tags = "new_expression"
message = """\
Replaced call to builtin %s with call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionTryFinally():
tags = "new_expression"
message = """\
Replaced call to builtin %s with try/finally guarded call.""" % (
inspect_node.getExpression().kind,
)
else:
assert False, ( builtin_name, "->", inspect_node )
# TODO: One day, this should be enabled by default and call either the
# original built-in or the optimized above one. That should be done,
# once we can eliminate the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
from nuitka.nodes.NodeMakingHelpers import \
makeRaiseExceptionReplacementExpression
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinRef(
builtin_name = builtin_name,
source_ref = source_ref
),
right = ExpressionBuiltinOriginalRef(
builtin_name = builtin_name,
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = new_node,
no_expression = makeRaiseExceptionReplacementExpression(
exception_type = "RuntimeError",
exception_value = "Builtin '%s' was overloaded'" % (
builtin_name
),
expression = call_node
),
source_ref = source_ref
)
assert tags != ""
return new_node, tags, message
else:
# TODO: Consider giving warnings, whitelisted potentially
return call_node, None, None
def wrapSuperBuiltin(type, object, source_ref):
if type is None and python_version >= 300:
provider = node.getParentVariableProvider()
if python_version < 340 or True: # TODO: Temporarily reverted:
type = ExpressionVariableRef(
variable_name = "__class__",
source_ref = source_ref
)
# Ought to be already closure taken.
type.setVariable(
provider.getVariableForClosure(
variable_name = "__class__"
)
)
# If we already have this as a local variable, then use that
# instead.
if not type.getVariable().isClosureReference():
type = None
else:
from nuitka.VariableRegistry import addVariableUsage
addVariableUsage(type.getVariable(), provider)
else:
parent_provider = provider.getParentVariableProvider()
class_var = parent_provider.getTempVariable(
temp_scope = None,
name = "__class__"
)
type = ExpressionTempVariableRef(
variable = class_var.makeReference(parent_provider).makeReference(provider),
source_ref = source_ref
)
from nuitka.VariableRegistry import addVariableUsage
addVariableUsage(type.getVariable(), provider)
from nuitka.nodes.NodeMakingHelpers import \
makeRaiseExceptionReplacementExpression
if type is None:
return makeRaiseExceptionReplacementExpression(
expression = node,
exception_type = "SystemError"
if python_version < 331 else
"RuntimeError",
exception_value = "super(): __class__ cell not found",
)
if object is None:
if provider.getParameters().getArgumentCount() > 0:
par1_name = provider.getParameters().getArgumentNames()[0]
# TODO: Nested first argument would kill us here, need a
# test for that.
object = ExpressionVariableRef(
variable_name = par1_name,
source_ref = source_ref
)
object.setVariable(
provider.getVariableForReference(
variable_name = par1_name
)
)
if not object.getVariable().isParameterVariable():
return makeRaiseExceptionReplacementExpression(
expression = node,
exception_type = "SystemError"
if python_version < 330 else
"RuntimeError",
exception_value = "super(): __class__ cell not found",
)
else:
return makeRaiseExceptionReplacementExpression(
expression = node,
exception_type = "RuntimeError",
exception_value = "super(): no arguments"
)
return ExpressionBuiltinSuper(
super_type = type,
super_object = object,
source_ref = source_ref
)
def computeBuiltinCall( call_node, called ):
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[ builtin_name ]( call_node )
if new_node is None:
return call_node, None, None
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = "Replaced dynamic builtin import %s with static module import." % inspect_node.kind
elif inspect_node.isExpressionBuiltin() or inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to builtin with builtin call %s." % inspect_node.kind
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = "Replaced call to builtin %s with exception raising call." % inspect_node.kind
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = "Replaced call to builtin %s with unary operation %s." % ( inspect_node.kind, inspect_node.getOperator() )
else:
assert False, ( builtin_name, "->", inspect_node )
# TODO: One day, this should be enabled by default and call either the original
# built-in or the optimized above one. That should be done, once we can eliminate
# the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
from nuitka.nodes.ConditionalNodes import ExpressionConditional
from nuitka.nodes.ComparisonNodes import ExpressionComparisonIs
from nuitka.nodes.BuiltinRefNodes import (
ExpressionBuiltinExceptionRef,
ExpressionBuiltinOriginalRef,
ExpressionBuiltinRef,
)
from nuitka.nodes.ExceptionNodes import ExpressionRaiseException
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinRef(
builtin_name = builtin_name,
source_ref = source_ref
),
right = ExpressionBuiltinOriginalRef(
builtin_name = builtin_name,
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = new_node,
no_expression = makeRaiseExceptionReplacementExpression(
exception_type = "RuntimeError",
exception_value = "Builtin '%s' was overloaded'" % builtin_name,
expression = call_node
),
source_ref = source_ref
)
return new_node, tags, message
else:
# TODO: Consider giving warnings, whitelisted potentially
return call_node, None, None
