def makeStaticmethod0(source_ref): # pylint: disable=unused-argument return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError("classmethod expected 1 arguments, got 0"), )
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 makeOrd0(source_ref): # pylint: disable=unused-argument return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError("ord() takes exactly one argument (0 given)"), )
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 type_extractor(node): args = node.getCallArgs() if args is None: iter_length = 0 else: iter_length = args.getIterationLength() if iter_length == 1: return BuiltinOptimization.extractBuiltinArgs( node = node, builtin_class = ExpressionBuiltinType1, builtin_spec = BuiltinOptimization.builtin_type1_spec ) elif iter_length == 3: return BuiltinOptimization.extractBuiltinArgs( node = node, builtin_class = ExpressionBuiltinType3, builtin_spec = BuiltinOptimization.builtin_type3_spec ) else: return makeRaiseExceptionReplacementExpressionFromInstance( expression = node, exception = TypeError("type() takes 1 or 3 arguments") )
def makeFormat0(source_ref): # pylint: disable=unused-argument return makeRaiseExceptionReplacementExpressionFromInstance( expression = node, exception = TypeError("format() takes at least 1 argument (0 given)") )
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 makeFormat0(source_ref): # pylint: disable=unused-argument return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError("format() takes at least 1 argument (0 given)"), )
def makeSum0(source_ref): # pylint: disable=W0613 return makeRaiseExceptionReplacementExpressionFromInstance( expression = node, exception = TypeError("sum expected at least 1 arguments, got 0") )
def makeRange0(source_ref): # pylint: disable=unused-argument return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError("range expected at least 1 arguments, got 0"), )
def makeOpen0(source_ref): # pylint: disable=W0613 return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError("Required argument 'name' (pos 1) not found" if python_version < 300 else "Required argument 'file' (pos 1) not found"))
def makeXrange0(source_ref): # pylint: disable=W0613 return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError( "xrange requires 1-3 int arguments" if python_version < 300 else "range expected 1 arguments, got 0"))
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 makeOpen0(source_ref): # pylint: disable=unused-argument try: open() except Exception as e: # We want to broad here, pylint: disable=broad-except return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=e) else: raise NuitkaAssumptionError( "open without argument is expected to raise")
def makeSum0(source_ref): # pylint: disable=unused-argument return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError( "sum expected at least 1 arguments, got 0" if python_version < 380 else "sum() takes at least 1 positional argument (0 given)"), )
def makeOpen0(source_ref): # pylint: disable=unused-argument try: open() except Exception as e: # We want to broad here, pylint: disable=broad-except return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=e ) else: raise NuitkaAssumptionError("open without argument is expected to raise")
def makeXrange0(source_ref): # pylint: disable=unused-argument if python_version < 300: exception_message = "xrange requires 1-3 int arguments" elif python_version < 380: exception_message = "range expected 1 arguments, got 0" else: exception_message = "range expected 1 argument, got 0" return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError(exception_message))
def makeOpen0(source_ref): # pylint: disable=W0613 return makeRaiseExceptionReplacementExpressionFromInstance( expression = node, exception = TypeError( "Required argument 'name' (pos 1) not found" if python_version < 300 else "Required argument 'file' (pos 1) not found" ) )
def makeXrange0(source_ref): # pylint: disable=unused-argument return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError( "xrange requires 1-3 int arguments" if python_version < 300 else "range expected 1 arguments, got 0" ), )
def makeAny0(source_ref): exception_message = "any() takes exactly one argument (0 given)" return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError(exception_message))
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
def makeSum0(source_ref): # pylint: disable=W0613 return makeRaiseExceptionReplacementExpressionFromInstance( expression=node, exception=TypeError("sum expected at least 1 arguments, got 0"))