def convert_filled_arguments()

in XLM/src/utils.py [0:0]

• 72 lines of code
• 27 McCabe index (conditional complexity)

def convert_filled_arguments(script_model, f, lang, f_name=None):
    assert lang in {'java', 'cpp'}
    header = []
    detokenizer = getattr(code_tokenizer, f'detokenize_{lang}')
    arguments_extractor = getattr(code_tokenizer, f'extract_arguments_{lang}')
    arguments_gold = arguments_extractor(script_model)
    return_type_gold = get_return_type(script_model)

    arguments_filled = arguments_extractor(f)
    return_type_filled = get_return_type(f)

    if arguments_gold[0] == arguments_filled[0]:
        return None
    if f_name is None:
        get_name = getattr(code_tokenizer, f"get_function_name_{lang}")
        f_name = get_name(f)

    argument_types_gold = [t.strip() for t in arguments_gold[0]]
    arguments_strings = [make_arg_string(
        arg_type, f'param{i}') for i, arg_type in enumerate(argument_types_gold)]
    new_function_lines = [f'static {return_type_gold} f_filled({", ".join(arguments_strings)})',
                          '{',
                          ]

    new_params_strings = []
    for param_index, (param_type_gold, param_type_filled) in enumerate(zip(argument_types_gold, arguments_filled[0])):
        param_type_filled = param_type_filled.strip()
        param_type_gold = param_type_gold.strip()
        if param_type_filled == param_type_gold:
            new_params_strings.append(f'param{param_index}')
        elif lang == 'cpp':
            if 'vector' in param_type_filled:
                if 'int' not in argument_types_gold:
                    return None
                ints_indices = [i for i, t in enumerate(
                    argument_types_gold) if t == 'int' and i > param_index]
                if any([i > param_index for i in ints_indices]):
                    array_length_arg = min(
                        [i for i in ints_indices if i > param_index])
                else:
                    array_length_arg = min(ints_indices)
                new_function_lines.append(
                    f'{param_type_filled.replace("&", "")} vect_param{param_index}(param{param_index}, param{param_index} + param{array_length_arg});')
                new_params_strings.append(f'vect_param{param_index}')
            elif param_type_filled == 'string' and 'char' in param_type_gold:
                new_function_lines.append(
                    f'{param_type_filled.replace("&", "")} string_param{param_index}(param{param_index});')
                new_params_strings.append(f'string_param{param_index}')
            elif param_type_gold == 'string' and 'char' in param_type_filled:
                new_function_lines.append(
                    f'char char_arr_param{param_index}[param{param_index}.length() + 1];')
                new_function_lines.append(
                    f'strcopy(char_arr_param{param_index}, param{param_index}.c_str());')
                new_params_strings.append(f'char_arr_param{param_index}')
            else:
                new_params_strings.append(
                    f'({param_type_filled}) param{param_index}')
        elif lang == 'java':
            if (param_type_filled == 'String' and 'char' in param_type_gold) or param_type_filled == transform_to_java_object_type(param_type_gold):
                new_params_strings.append(
                    f'{param_type_filled}.valueOf(param{param_index})')
                header.append("#include <cstring>")
            elif param_type_gold == 'String':
                new_params_strings.append(f'param{param_index}.toCharArray()')
            else:
                new_params_strings.append(
                    f'({param_type_filled}) param{param_index}')
        else:
            return None

    inner_function_name = 'f_filled_inner'
    outer_f_return_string = f'{inner_function_name}({",".join(new_params_strings)})'
    if return_type_filled != return_type_gold:
        outer_f_return_string = f"({return_type_gold}) {outer_f_return_string}"
    new_function_lines += [f'return {outer_f_return_string};', '}']

    f = detokenizer(f.replace(f_name, inner_function_name))
    return '\n'.join(list(set(header))) + script_model.replace(TOFILL[lang], '\n'.join([f, '\n'] + new_function_lines))