Review and Refactor

Looking back at Lesson 5's complete handler: both loops call datesOverlap(...) and then, if true, call addError() with a message — the exact same shape, just with a different pair of records and a different message each time. This is worth naming explicitly, even if extracting it fully would add a parameter for the message.

private void blockIfOverlapping(Leave_Request__c reqA, Leave_Request__c reqB, String errorMessage) {
    Boolean sameEmployee = reqA.Employee_Name__c == reqB.Employee_Name__c;
    Boolean overlaps = datesOverlap(reqA.Start_Date__c, reqA.End_Date__c, reqB.Start_Date__c, reqB.End_Date__c);

    if (sameEmployee && overlaps) {
        reqB.Start_Date__c.addError(errorMessage);
    }
}

public void beforeInsert(List<Leave_Request__c> newRequests) {
    // ... build employeeNames, query existingRequests exactly as before ...

    for (Leave_Request__c newReq : newRequests) {
        for (Leave_Request__c existing : existingRequests) {
            blockIfOverlapping(newReq, existing, 'This leave request overlaps with an existing request.');
        }
    }

    for (Integer i = 0; i < newRequests.size(); i++) {
        for (Integer j = i + 1; j < newRequests.size(); j++) {
            blockIfOverlapping(newRequests[i], newRequests[j], 'This request overlaps with another request in the same submission.');
        }
    }
}

1. private void blockIfOverlapping(Leave_Request__c reqA, Leave_Request__c reqB, String errorMessage) { — blockIfOverlapping now holds the one piece of logic that was duplicated across both loops.
2. Boolean sameEmployee = reqA.Employee_Name__c == reqB.Employee_Name__c; — the comparability check, extracted once.
3. Boolean overlaps = datesOverlap(reqA.Start_Date__c, reqA.End_Date__c, reqB.Start_Date__c, reqB.End_Date__c); — the overlap check, extracted once.
4. (blank line)
5. if (sameEmployee && overlaps) { — the shared condition.
6. reqB.Start_Date__c.addError(errorMessage); — a parameterized message, since each caller needs a different one.
7. } — closes the if.
8. } — closes the helper.
9. (blank line)
10. public void beforeInsert(List<Leave_Request__c> newRequests) { — the method.
11. // ... build employeeNames, query existingRequests exactly as before ... — unchanged setup.
12. (blank line)
13. for (Leave_Request__c newReq : newRequests) { — the outer loop, unchanged.
14. for (Leave_Request__c existing : existingRequests) { — the inner loop, unchanged.
15. blockIfOverlapping(newReq, existing, 'This leave request overlaps with an existing request.'); — each loop is left doing only what makes it genuinely different: which two Lists it's comparing, and which message to pass.
16. } — closes the inner loop.
17. } — closes the outer loop.
18. (blank line)
19. for (Integer i = 0; i < newRequests.size(); i++) { — the new-vs-new outer loop, unchanged.
20. for (Integer j = i + 1; j < newRequests.size(); j++) { — the inner loop, unchanged.
21. blockIfOverlapping(newRequests[i], newRequests[j], 'This request overlaps with another request in the same submission.'); — the same shared helper, a different message.
22. } — closes the inner loop.
23. } — closes the outer loop.
24. } — closes the method.

Exactly the same refactoring instinct that closed out every previous project module in this course.

Re-running Lesson 6's @isTest methods against this refactored version should produce identical results — the same two DmlExceptions blocked, the same success case allowed through. This is the whole point of refactoring, one final time: behavior unchanged, structure clearer.