def METHOD_NAME(self, node):
    """
    Checks the coco on the current node.
    :param node: AST kernel object
    :type node: ASTKernel
    """
    for var, expr in zip(node.variables, node.expressions):
        # check kernel type
        if (var.get_differential_order() == 0
            and not type(expr.type) in [IntegerTypeSymbol, RealTypeSymbol]) \
            or (var.get_differential_order() > 0
                and not expr.type.is_castable_to(PredefinedTypes.get_type("ms")**-var.get_differential_order())):
            actual_type_str = str(expr.type)
            if 'unit' in dir(expr.type) \
                    and expr.type.unit is not None \
                    and expr.type.unit.unit is not None:
                actual_type_str = str(expr.type.unit.unit)
            code, message = Messages.get_kernel_wrong_type(
                var.get_name(), var.get_differential_order(), actual_type_str)
            Logger.log_message(error_position=node.get_source_position(), log_level=LoggingLevel.ERROR,
                               code=code, message=message)
        # check types of the state variables
        for order in range(var.get_differential_order()):
            iv_name = var.get_name() + order * "'"
            decl = ASTUtils.get_declaration_by_name(self._neuron.get_state_blocks(), iv_name)
            if decl is None:
                code, message = Messages.get_variable_not_defined(iv_name)
                Logger.log_message(node=self._neuron, code=code, message=message, log_level=LoggingLevel.ERROR,
                                   error_position=node.get_source_position())
                continue
            assert len(decl.get_variables()) == 1, "Only single variables are supported as targets of an assignment."
            iv = decl.get_variables()[0]
            type_symbol = iv.get_type_symbol()
            if isinstance(type_symbol, Either) and type_symbol.is_value():
                type_symbol = type_symbol.get_value()
            if not type_symbol.is_castable_to(PredefinedTypes.get_type("ms")**-order):
                actual_type_str = CppTypeSymbolPrinter().print(type_symbol)
                expected_type_str = "s^-" + str(order)
                code, message = Messages.get_kernel_iv_wrong_type(iv_name, actual_type_str, expected_type_str)
                Logger.log_message(error_position=node.get_source_position(),
                                   log_level=LoggingLevel.ERROR, code=code, message=message)