def METHOD_NAME(self, eqn, y, x, evaluation: Evaluation):
    "DSolve[eqn_, y_, x_]"
    if eqn.has_form("List", None):
        # TODO: Try and solve BVPs using Solve or something analagous OR
        # add this functonality to sympy.
        evaluation.message("DSolve", "symsys")
        return
    if eqn.get_head_name() != "System`Equal":
        evaluation.message("DSolve", "deqn", eqn)
        return
    if isinstance(x, Symbol):
        syms = [x]
    elif x.has_form("List", 1, None):
        syms = sorted(x.elements)
    else:
        evaluation.message("DSolve", "dsvar", x)
        return
    # Fixes pathalogical DSolve[y''[x] == y[x], y, x]
    try:
        y.elements
        function_form = None
        func = y
    except AttributeError:
        func = Expression(y, *syms)
        function_form = ListExpression(*syms)
    if isinstance(func, Atom):
        evaluation.message("DSolve", "dsfun", y)
        return
    if set(func.elements) != set(syms):
        evaluation.message("DSolve", "deqx")
        return
    f_name = func.get_head_name()
    conversion_args = {"converted_functions": set([f_name])}
    sym_func = func.to_sympy(**conversion_args)
    sym_eq = eqn.to_sympy(**conversion_args)
    # XXX when sympy adds support for higher-order PDE we will have to
    # change this to a tuple of solvefuns
    kwargs = {"solvefun": sympy.Function(str("C1"))}
    try:
        if len(syms) > 1:
            sym_result = sympy.pdsolve(sym_eq, sym_func, **kwargs)
        else:
            sym_result = sympy.dsolve(sym_eq, sym_func)
    except ValueError:
        evaluation.message("DSolve", "symimp")
        return
    except NotImplementedError:
        evaluation.message("DSolve", "symimp")
        return
    except TypeError:
        # Sympy bug #9446
        evaluation.message("DSolve", "litarg", eqn)
        return
    except AttributeError:
        evaluation.message("DSolve", "litarg", eqn)
        return
    except KeyError:
        evaluation.message("DSolve", "litarg", eqn)
        return
    else:
        if not isinstance(sym_result, list):
            sym_result = [sym_result]
    if function_form is None:
        return ListExpression(
            *[
                ListExpression(Expression(SymbolRule, *from_sympy(soln).elements))
                for soln in sym_result
            ]
        )
    else:
        return ListExpression(
            *[
                ListExpression(
                    Expression(
                        SymbolRule,
                        y,
                        Expression(
                            SymbolFunction,
                            function_form,
                            *from_sympy(soln).elements[1:]
                        ),
                    ),
                )
                for soln in sym_result
            ]
        )