The audit trail that stopped being written

import java.util.*;

/**
 * Solution: the audit trail that stopped being written.
 *
 * The rule is "the class always wins". When a class inherits a concrete
 * method from a superclass AND a default method of the same signature from
 * an interface, the superclass method is used — silently, with no warning.
 *
 * That is not an oversight. It is the compatibility guarantee that made
 * default methods possible at all: adding a default to an interface can
 * never change how an existing class behaves. Without it, the JDK could not
 * have added Collection.stream() or Iterable.forEach to interfaces that
 * thousands of classes already implemented.
 *
 * So Invoice and CreditNote kept BaseDocument.auditLabel(), which predates
 * correlation ids. Receipt and Refund extend nothing, so nothing outranked
 * the default.
 *
 * THE FIX
 *   Override auditLabel() in the types that need it and delegate explicitly
 *   with Auditable.super.auditLabel(). That is the only way to reach a
 *   default method that something else is outranking, and writing it down is
 *   the point — the decision becomes visible instead of accidental.
 *
 *   BaseDocument.auditLabel() stays, because other code still calls it.
 *
 * THE DESIGN QUESTION
 *   Should javac have warned? A warning on every class that inherits both
 *   would fire constantly and correctly in code where the class method is
 *   exactly what was wanted, so it would be noise. The real defence is that
 *   adding an interface to an existing class is not the one-line change it
 *   looks like: if the interface carries defaults, check each one against
 *   what the class already inherits.
 */
public class Solution {

    /** The compliance requirement, as a default method. */
    interface Auditable {
        String documentId();

        String correlationId();

        default String auditLabel() {
            return "[" + correlationId() + "] " + documentId();
        }
    }

    /**
     * The pre-existing base class. It has had auditLabel() since long before
     * anyone had heard of correlation ids.
     */
    abstract static class BaseDocument {
        protected final String id;

        protected BaseDocument(String id) {
            this.id = id;
        }

        public String auditLabel() {
            return id;
        }
    }

    /* ── two types that extend the base class, and one line was added ── */

    static final class Invoice extends BaseDocument implements Auditable {
        Invoice(String id) {
            super(id);
        }

        @Override public String documentId() { return id; }

        @Override public String correlationId() { return "CID-INV-9"; }

        /** FIX: reach past the inherited class method to the interface default. */
        @Override public String auditLabel() {
            return Auditable.super.auditLabel();
        }
    }

    static final class CreditNote extends BaseDocument implements Auditable {
        CreditNote(String id) {
            super(id);
        }

        @Override public String documentId() { return id; }

        @Override public String correlationId() { return "CID-CN-4"; }

        /** FIX: same, and it has to be written on every affected subclass. */
        @Override public String auditLabel() {
            return Auditable.super.auditLabel();
        }
    }

    /* ── two types that extend nothing ── */

    /** Not Auditable, and not required to be. It still needs a label. */
    static final class Memo extends BaseDocument {
        Memo(String id) {
            super(id);
        }
    }

    record Receipt(String documentId, String correlationId) implements Auditable {}

    record Refund(String documentId, String correlationId) implements Auditable {}

    public static void main(String[] args) {
        List<Auditable> documents = List.of(
                new Invoice("INV-1001"),
                new CreditNote("CN-77"),
                new Receipt("RCP-5", "CID-RCP-1"),
                new Refund("RF-2", "CID-RF-3"));

        System.out.println("── audit log ──");
        List<String> labels = new ArrayList<>();
        for (Auditable document : documents) {
            String label = document.auditLabel();
            labels.add(label);
            System.out.printf("  %-12s %s%n", document.getClass().getSimpleName(), label);
        }

        long compliant = labels.stream().filter(l -> l.startsWith("[CID-")).count();

        // BaseDocument.auditLabel() was not deleted, and document types that
        // are not Auditable still get the plain id from it.
        //
        // Note what you CANNOT do: casting an Invoice to BaseDocument does not
        // get you the base version. auditLabel() is an instance method, so it
        // is overridden, and overriding dispatches on the object rather than
        // on the reference. Auditable.super is the only way back to a
        // superclass or interface implementation, and only from inside the
        // subclass itself.
        BaseDocument plain = new Memo("MEMO-3");
        System.out.println();
        System.out.println("  a non-Auditable document still uses the base : "
                + plain.auditLabel());

        System.out.println();
        System.out.println("documents audited            : " + labels.size());
        System.out.println("labels carrying a correlation: " + compliant);
        System.out.println();
        System.out.println("every document is compliant  : " + (compliant == labels.size()));
        System.out.println(compliant == labels.size() ? "PASS" : "FAIL");
    }
}