public static List<?> parseMethod(String bytecodeSignature,
    ClassLoader loader) 
{
        return parseMethod(bytecodeSignature, 0, bytecodeSignature.length(), loader);
}

 static List<?> parseMethod(String bytecodeSignature,
    int start,
    int end,
    ClassLoader loader) 
{
        if (loader == null)
            loader = ClassLoader.getSystemClassLoader();
        String str = bytecodeSignature;
        int[] i = {start};
        ArrayList< Class< ? > > ptypes = new ArrayList< Class< ? > >();
        if (i[0] <  end && str.charAt(i[0]) == '(') {
            ++i[0];  // skip '('
            while (i[0] <  end && str.charAt(i[0]) != ')') {
                Class< ? > pt = parseSig(str, i, end, loader);
                if (pt == null || pt == void.class)
                    parseError(str, "bad argument type");
                ptypes.add(pt);
            }
            ++i[0];  // skip ')'
        } else {
            parseError(str, "not a method type");
        }
        Class< ? > rtype = parseSig(str, i, end, loader);
        if (rtype == null || i[0] != end)
            parseError(str, "bad return type");
        ptypes.add(rtype);
        return ptypes;
}

 public static String unparse(Class<?> type) 
{
        StringBuilder sb = new StringBuilder();
        unparseSig(type, sb);
        return sb.toString();
}

 public static String unparse(MethodType type) 
{
        return unparseMethod(type.returnType(), type.parameterList());
}

 public static String unparse(Object type) 
{
        if (type instanceof Class< ? >)
            return unparse((Class< ? >) type);
        if (type instanceof MethodType)
            return unparse((MethodType) type);
        return (String) type;
}

 public static String unparseMethod(Class<?> rtype,
    List<?> ptypes) 
{
        StringBuilder sb = new StringBuilder();
        sb.append('(');
        for (Class< ? > pt : ptypes)
            unparseSig(pt, sb);
        sb.append(')');
        unparseSig(rtype, sb);
        return sb.toString();
}