code: static List<Class<?>> methodResolutionOrder(Class<?> c) {
          try {
              List<Class<?>> result = mro(c);
              if (c.getSuperclass() != null) {
                  result.add(Object.class);
              }
              return result;
          } catch (InconsistentHierarchy e) {
              StringBuilder b = new StringBuilder()
                  .append("Unable to compute a consistent ")
                  .append("method resolution order for ")
                  .append(c.getName());
              if (c.equals(e.problematicClass)) {
                  b.append(".");
              } else {
                  b.append(" because ").append(e.problematicClass.getName())
                  .append(" has no consistent method resolution order.");
              }
              throw new EdnException(b.toString());
          }
      }
docs: Return a linearization for the inheritance hierarchy of the
  {@code class} {@code c}. The linearization will includes
  interfaces as well as classes and considers {@link Object} to
  be the ultimate superclass.
  
  @param c represents an actual <em>class</em>, not an
  interface. Never null.
  
  @return The linearization of c: never null and never empty.
  
  @throws EdnException if the inheritance hierarchy of {@code c}
  makes it impossible to compute a consistent hierarchy
  for {@code c}.