def METHOD_NAME(self, node):
    """
    Visits a single function call as stored in a simple expression and, if template types are used for function parameters, checks if all actual parameter types are mutually consistent.
    :param node: a simple expression
    :type node: ASTSimpleExpression
    :rtype None:
    """
    assert isinstance(node, ASTSimpleExpression), \
        '(PyNestML.Visitor.FunctionCallVisitor) No or wrong type of simple expression provided (%s)!' % tuple(node)
    assert (node.get_scope() is not None), \
        "(PyNestML.Visitor.FunctionCallVisitor) No scope found, run symboltable creator!"
    scope = node.get_scope()
    if node.get_function_call() is None:
        return
    function_name = node.get_function_call().get_name()
    method_symbol = scope.resolve_to_symbol(function_name, SymbolKind.FUNCTION)
    if method_symbol is None and ASTUtils.is_function_delay_variable(node.get_function_call()):
        code, message = Messages.get_function_is_delay_variable(function_name)
        Logger.log_message(code=code, message=message, error_position=node.get_source_position(),
                           log_level=LoggingLevel.DEBUG)
        return
    # check if this function exists
    if method_symbol is None:
        code, message = Messages.get_could_not_resolve(function_name)
        Logger.log_message(code=code, message=message, error_position=node.get_source_position(),
                           log_level=LoggingLevel.ERROR)
        self._failure_occurred = True
        return
    template_symbol_to_actual_symbol = {}
    template_symbol_to_parameter_indices = {}
    # loop over all function parameters
    for arg_idx, arg_type in enumerate(method_symbol.param_types):
        if isinstance(arg_type, TemplateTypeSymbol):
            actual_symbol = node.get_function_call().get_args()[arg_idx].type
            if arg_type._i in template_symbol_to_actual_symbol.keys():
                if (not template_symbol_to_actual_symbol[arg_type._i].differs_only_in_magnitude(actual_symbol)) \
                        and (not template_symbol_to_actual_symbol[arg_type._i].is_castable_to(actual_symbol)):
                    # if the one cannot be cast into the other
                    code, message = Messages.templated_arg_types_inconsistent(function_name, arg_idx, template_symbol_to_parameter_indices[arg_type._i], failing_arg_type_str=actual_symbol.print_nestml_type(
                    ), other_type_str=template_symbol_to_actual_symbol[arg_type._i].print_nestml_type())
                    Logger.log_message(code=code, message=message,
                                       error_position=node.get_source_position(), log_level=LoggingLevel.ERROR)
                    self._failure_occurred = True
                    return
                template_symbol_to_parameter_indices[arg_type._i] += [arg_idx]
            else:
                template_symbol_to_actual_symbol[arg_type._i] = actual_symbol
                template_symbol_to_parameter_indices[arg_type._i] = [arg_idx]