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 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