def wrapExpressionBuiltinDictCreation(positional_args, dict_star_arg,
source_ref):
if len(positional_args) > 1:
from nuitka.nodes.NodeMakingHelpers import (
makeRaiseExceptionReplacementExpressionFromInstance,
wrapExpressionWithSideEffects)
result = makeRaiseExceptionReplacementExpressionFromInstance(
expression=node,
exception=TypeError(
"dict expected at most 1 arguments, got %d" %
len(positional_args)))
result = wrapExpressionWithSideEffects(
side_effects=positional_args, old_node=node, new_node=result)
if dict_star_arg:
result = wrapExpressionWithSideEffects(
side_effects=dict_star_arg, old_node=node, new_node=result)
return result
return ExpressionBuiltinDict(
pos_arg=positional_args[0] if positional_args else None,
pairs=dict_star_arg,
source_ref=source_ref)
def wrapExpressionBuiltinDictCreation(positional_args, dict_star_arg,
source_ref):
if len(positional_args) > 1:
result = makeRaiseExceptionReplacementExpressionFromInstance(
expression = node,
exception = TypeError(
"dict expected at most 1 arguments, got %d" % (
len(positional_args)
)
)
)
result = wrapExpressionWithSideEffects(
side_effects = positional_args,
old_node = node,
new_node = result
)
if dict_star_arg:
result = wrapExpressionWithSideEffects(
side_effects = dict_star_arg,
old_node = node,
new_node = result
)
return result
return ExpressionBuiltinDict(
pos_arg = positional_args[0] if positional_args else None,
pairs = dict_star_arg,
source_ref = source_ref
)
def extractBuiltinArgs(node,
builtin_spec,
builtin_class,
empty_special_class=None):
try:
kw = node.getCallKw()
# TODO: Could check for too many / too few, even if they are unknown, we might
# raise that error, but that need not be optimized immediately.
if not kw.isMappingWithConstantStringKeys():
return None
pairs = kw.getMappingStringKeyPairs()
if pairs and not builtin_spec.allowsKeywords():
raise TooManyArguments(
TypeError(builtin_spec.getKeywordRefusalText()))
args = node.getCallArgs()
if not args.canPredictIterationValues():
return None
positional = args.getIterationValues()
if not positional and not pairs and empty_special_class is not None:
return empty_special_class(source_ref=node.getSourceReference())
args_dict = matchCall(
func_name=builtin_spec.getName(),
args=builtin_spec.getArgumentNames(),
star_list_arg=builtin_spec.getStarListArgumentName(),
star_dict_arg=builtin_spec.getStarDictArgumentName(),
num_defaults=builtin_spec.getDefaultCount(),
positional=positional,
pairs=pairs)
except TooManyArguments as e:
from nuitka.nodes.NodeMakingHelpers import (
makeRaiseExceptionReplacementExpressionFromInstance,
wrapExpressionWithSideEffects)
return wrapExpressionWithSideEffects(
new_node=makeRaiseExceptionReplacementExpressionFromInstance(
expression=node, exception=e.getRealException()),
old_node=node,
side_effects=node.extractPreCallSideEffects())
args_list = []
for argument_name in builtin_spec.getArgumentNames():
args_list.append(args_dict[argument_name])
if builtin_spec.getStarListArgumentName() is not None:
args_list.append(args_dict[builtin_spec.getStarListArgumentName()])
if builtin_spec.getStarDictArgumentName() is not None:
args_list.append(args_dict[builtin_spec.getStarDictArgumentName()])
# Using list reference for passing the arguments without names, pylint: disable=W0142
return builtin_class(*args_list, source_ref=node.getSourceReference())
def computeExpressionCall( self, call_node, constraint_collection ):
# TODO: Until we have something to re-order the arguments, we need to skip this. For
# the immediate need, we avoid this complexity, as a re-ordering will be needed.
if call_node.getNamedArgumentPairs():
return call_node, None, None
call_spec = self.getParameters()
try:
args_dict = matchCall(
func_name = self.getName(),
args = call_spec.getArgumentNames(),
star_list_arg = call_spec.getStarListArgumentName(),
star_dict_arg = call_spec.getStarDictArgumentName(),
num_defaults = call_spec.getDefaultCount(),
positional = call_node.getPositionalArguments(),
pairs = ()
)
values = []
for positional_arg in call_node.getPositionalArguments():
for _arg_name, arg_value in iterItems( args_dict ):
if arg_value is positional_arg:
values.append( arg_value )
result = ExpressionFunctionCall(
function_body = self,
values = values,
source_ref = call_node.getSourceReference()
)
return (
result,
"new_statements", # TODO: More appropiate tag maybe.
"Replaced call to created function body '%s' with direct function call" % self.getName()
)
except TooManyArguments as e:
from nuitka.nodes.NodeMakingHelpers import (
makeRaiseExceptionReplacementExpressionFromInstance,
wrapExpressionWithSideEffects
)
result = wrapExpressionWithSideEffects(
new_node = makeRaiseExceptionReplacementExpressionFromInstance(
expression = call_node,
exception = e.getRealException()
),
old_node = call_node,
side_effects = call_node.extractPreCallSideEffects()
)
return (
result,
"new_statements,new_raise", # TODO: More appropiate tag maybe.
"Replaced call to created function body '%s' to argument error" % self.getName()
)
def computeExpression(self, constraint_collection):
function = self.getFunction()
if function.willRaiseException(BaseException):
return function, "new_raise", "Called function is a raise"
values = self.getArgumentValues()
for count, value in enumerate(values):
if value.willRaiseException(BaseException):
from .NodeMakingHelpers import wrapExpressionWithSideEffects
result = wrapExpressionWithSideEffects(
side_effects=[function] + list(values[:count]),
new_node=value,
old_node=self)
return result, "new_raise", "Called function arguments raise"
return self, None, None
def computeExpression( self, constraint_collection ):
function = self.getFunction()
if function.willRaiseException( BaseException ):
return function, "new_raise", "Called function is a raise"
values = self.getArgumentValues()
for count, value in enumerate( values ):
if value.willRaiseException( BaseException ):
from .NodeMakingHelpers import wrapExpressionWithSideEffects
result = wrapExpressionWithSideEffects(
side_effects = [ function ] + list( values[ : count ] ),
new_node = value,
old_node = self
)
return result, "new_raise", "Called function arguments raise"
return self, None, None
def extractBuiltinArgs(node, builtin_spec, builtin_class,
empty_special_class = None):
try:
kw = node.getCallKw()
# TODO: Could check for too many / too few, even if they are unknown, we
# might raise that error, but that need not be optimized immediately.
if not kw.isMappingWithConstantStringKeys():
return None
pairs = kw.getMappingStringKeyPairs()
if pairs and not builtin_spec.allowsKeywords():
raise TooManyArguments(
TypeError(builtin_spec.getKeywordRefusalText())
)
args = node.getCallArgs()
if not args.canPredictIterationValues():
return None
positional = args.getIterationValues()
if not positional and not pairs and empty_special_class is not None:
return empty_special_class(source_ref = node.getSourceReference())
args_dict = matchCall(
func_name = builtin_spec.getName(),
args = builtin_spec.getArgumentNames(),
star_list_arg = builtin_spec.getStarListArgumentName(),
star_dict_arg = builtin_spec.getStarDictArgumentName(),
num_defaults = builtin_spec.getDefaultCount(),
positional = positional,
pairs = pairs
)
except TooManyArguments as e:
from nuitka.nodes.NodeMakingHelpers import (
makeRaiseExceptionReplacementExpressionFromInstance,
wrapExpressionWithSideEffects
)
return wrapExpressionWithSideEffects(
new_node = makeRaiseExceptionReplacementExpressionFromInstance(
expression = node,
exception = e.getRealException()
),
old_node = node,
side_effects = node.extractPreCallSideEffects()
)
args_list = []
for argument_name in builtin_spec.getArgumentNames():
args_list.append(args_dict[argument_name])
if builtin_spec.getStarListArgumentName() is not None:
args_list.append(args_dict[builtin_spec.getStarListArgumentName()])
if builtin_spec.getStarDictArgumentName() is not None:
args_list.append(args_dict[builtin_spec.getStarDictArgumentName()])
# Using list reference for passing the arguments without names,
# pylint: disable=W0142
return builtin_class(
*args_list,
source_ref = node.getSourceReference()
)
def extractBuiltinArgs(node,
builtin_spec,
builtin_class,
empty_special_class=None):
# Many cases to deal with, pylint: disable=too-many-branches
try:
kw = node.subnode_kwargs
# TODO: Could check for too many / too few, even if they are unknown, we
# might raise that error, but that need not be optimized immediately.
if kw is not None:
if not kw.isMappingWithConstantStringKeys():
return None
pairs = kw.getMappingStringKeyPairs()
if pairs and not builtin_spec.allowsKeywords():
raise TooManyArguments(
TypeError(builtin_spec.getKeywordRefusalText()))
else:
pairs = ()
args = node.subnode_args
if args:
if not args.canPredictIterationValues():
return None
positional = args.getIterationValues()
else:
positional = ()
if not positional and not pairs and empty_special_class is not None:
return empty_special_class(source_ref=node.getSourceReference())
args_dict = matchCall(
func_name=builtin_spec.getName(),
args=builtin_spec.getArgumentNames(),
kw_only_args=builtin_spec.getKwOnlyParameterNames(),
star_list_arg=builtin_spec.getStarListArgumentName(),
star_dict_arg=builtin_spec.getStarDictArgumentName(),
num_defaults=builtin_spec.getDefaultCount(),
num_posonly=builtin_spec.getPosOnlyParameterCount(),
positional=positional,
pairs=pairs,
)
except TooManyArguments as e:
from nuitka.nodes.NodeMakingHelpers import (
makeRaiseExceptionReplacementExpressionFromInstance,
wrapExpressionWithSideEffects,
)
return wrapExpressionWithSideEffects(
new_node=makeRaiseExceptionReplacementExpressionFromInstance(
expression=node, exception=e.getRealException()),
old_node=node,
side_effects=node.extractSideEffectsPreCall(),
)
# Using list reference for passing the arguments without names where it
# it possible, otherwise dictionary to make those distinuishable.
args_list = []
for argument_name in builtin_spec.getArgumentNames():
args_list.append(args_dict[argument_name])
if builtin_spec.getStarListArgumentName() is not None:
args_list.append(args_dict[builtin_spec.getStarListArgumentName()])
if builtin_spec.getStarDictArgumentName() is not None:
args_list.append(args_dict[builtin_spec.getStarDictArgumentName()])
for argument_name in builtin_spec.getKwOnlyParameterNames():
args_list.append(args_dict[argument_name])
# Using list reference for passing the arguments without names,
result = builtin_class(*args_list, source_ref=node.getSourceReference())
if python_version < 0x380:
result.setCompatibleSourceReference(
node.getCompatibleSourceReference())
return result
