def METHOD_NAME(self, node: ASTSimpleExpression) -> None:
    """
    Visits a single function call as stored in a simple expression and derives the correct type of all its
    parameters.
    :param node: a simple expression
    """
    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()
    function_name = node.get_function_call().get_name()
    method_symbol = scope.resolve_to_symbol(function_name, SymbolKind.FUNCTION)
    # check if this is a delay variable
    symbol = ASTUtils.get_delay_variable_symbol(node.get_function_call())
    if method_symbol is None and symbol is not None:
        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)
        node.type = symbol.get_type_symbol()
        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)
        node.type = ErrorTypeSymbol()
        return
    return_type = method_symbol.get_return_type()
    if isinstance(return_type, TemplateTypeSymbol):
        for i, arg_type in enumerate(method_symbol.param_types):
            if arg_type == return_type:
                return_type = node.get_function_call().get_args()[i].type
                break
        if isinstance(return_type, TemplateTypeSymbol):
            # error: return type template not found among parameter type templates
            assert False, "return type template not found among parameter type templates"
        # check for consistency among actual derived types for template parameters
        from pynestml.cocos.co_co_function_argument_template_types_consistent import \
            CorrectTemplatedArgumentTypesVisitor
        correctTemplatedArgumentTypesVisitor = CorrectTemplatedArgumentTypesVisitor()
        correctTemplatedArgumentTypesVisitor._failure_occurred = False
        node.accept(correctTemplatedArgumentTypesVisitor)
        if correctTemplatedArgumentTypesVisitor._failure_occurred:
            return_type = ErrorTypeSymbol()
    return_type.referenced_object = node
    # return type of the convolve function is the type of the second parameter multiplied by the unit of time (s)
    if function_name == PredefinedFunctions.CONVOLVE:
        # Deviations from the assumptions made here are handled in the convolveCoco
        buffer_parameter = node.get_function_call().get_args()[1]
        if buffer_parameter.get_variable() is not None:
            buffer_name = buffer_parameter.get_variable().get_name()
            buffer_symbol_resolve = scope.resolve_to_symbol(buffer_name, SymbolKind.VARIABLE)
            if buffer_symbol_resolve is not None:
                node.type = buffer_symbol_resolve.get_type_symbol() * UnitTypeSymbol(PredefinedUnits.get_unit("s"))
                return
        # getting here means there is an error with the parameters to convolve
        code, message = Messages.get_convolve_needs_buffer_parameter()
        Logger.log_message(code=code, message=message, error_position=node.get_source_position(),
                           log_level=LoggingLevel.ERROR)
        node.type = ErrorTypeSymbol()
        return
    if isinstance(method_symbol.get_return_type(), VoidTypeSymbol):
        # todo: the error message is not used here, fix this
        # error_msg = ErrorStrings.message_void_function_on_rhs(self, function_name, node.get_source_position())
        node.type = ErrorTypeSymbol()
        return
    # if nothing special is handled, just get the expression type from the return type of the function
    node.type = return_type