Fix isExhaustive pattern checking

Kudos to ChatGPT, which explains:

The bug is in the “record” branch of `isExhaustive`. Right now,
when the first column contains (only) records (i.e. `numSeen == 0` and
`extractRecordPatterns` succeeds), the code does this:

1. Collect all field names seen anywhere in the matrix (`baseRecord`).
2. For **each field name independently**, check exhaustiveness of that one
field (`specializeRowByRecordField fieldName`), then wrap the resulting
missing patterns back into a single-field record.

That is logically wrong for records: it’s checking **each field in
isolation** (like an OR), but exhaustiveness requires the **cartesian
product of fields** (like an AND across fields). So your first example
slips through because:

- for field `a`, both `True` and `False` appear somewhere
- for field `b`, both `True` and `False` appear somewhere

…but not all **combinations** appear.

This is already handled correctly by `simplify`: `Can.PVar _` becomes
`Anything`. So destructured names like `{ key = lKey }` do *not* introduce
additional constraints. That’s why the `Just { first = { key = lKey,
value = lValue }, rest }` pattern should not force enumeration of all
`key/value/rest` combinations—those are `Anything` patterns. The fix
below preserves that behavior.

---

Instead of iterating fields one-by-one with `specializeRowByRecordField`,
we must treat a record pattern as a product of its fields: build a
consistent “base” field set and specialize the matrix into a vector
of field-patterns (one per field) and recurse on that vector.

You already have the machinery for this in `isUseful`:
- it uses `collectRecordFieldsWithAnyPattern` to get a base map `{fieldName -> Anything}`
- then uses `specializeRowByRecord baseMap` to expand a record into `Map.elems specializedMap`

`isExhaustive` should do the same.

No other code changes are required.

---

Patterns:

- `{ a = False, b = True }`
- `{ a = True, b = False }`

After specialization by the base record `{a = _, b = _}`, the algorithm
checks exhaustiveness on the **2-column** matrix `[aPattern, bPattern]`
and will find missing rows such as:

- `{ a = False, b = False }`
- `{ a = True,  b = True }`

So it correctly reports `Incomplete`.

Inside `Just { first = { key = lKey, value = lValue }, rest }` all
those `lKey/lValue/rest` are `PVar`, so `simplify` turns them into
`Anything`. That makes the record subpatterns maximally general, so
`Ctor Just [...]` covers all `Just _` cases. Together with `Nothing`,
the `Maybe` match is exhaustive, and the record-product recursion won’t
introduce spurious missing combinations.

Author: gilramir

compiler/src/Nitpick/PatternMatches.hs

@@ -253,21 +253,22 @@ isExhaustive matrix n =
                           (:) Anything
                             <$> isExhaustive (Maybe.mapMaybe specializeRowByAnything matrix) (n - 1)
                         Just baseRecord ->
-                          let fieldNames = Map.keys baseRecord
-
-                              isAltExhaustive fieldName =
-                                map (asRecordPattern fieldName) $
-                                  isExhaustive
-                                    (Maybe.mapMaybe (specializeRowByRecordField fieldName) matrix)
-                                    n
-
-                              asRecordPattern fieldName ptn =
-                                case ptn of
-                                  firstValue : _ ->
-                                    [Record $ Map.singleton fieldName firstValue]
-                                  _ ->
-                                    ptn
-                           in concatMap isAltExhaustive fieldNames
+                          -- Treat records as a product of fields (cartesian combination),
+                          -- not each field independently.
+                          let fieldCount = Map.size baseRecord
+                              baseFieldsInOrder = Map.keys baseRecord
+
+                              -- Rebuild a record from the first `fieldCount` patterns in a counterexample row
+                              recoverRecord :: [Pattern] -> [Pattern]
+                              recoverRecord patterns =
+                                let (fieldPats, rest) = splitAt fieldCount patterns
+                                 in Record (Map.fromList (zip baseFieldsInOrder fieldPats)) : rest
+                           in
+                             map recoverRecord $
+                               isExhaustive
+                                 (Maybe.mapMaybe (specializeRowByRecord baseRecord) matrix)
+                                 (fieldCount + n - 1)
+
                 else
                   let alts@(Can.Union _ altList numAlts _) = snd (Map.findMin ctors)
                    in if numSeen < numAlts
@@ -430,29 +431,6 @@ specializeRowByRecord baseMap row =
     [] ->
       error "Compiler error! Empty matrices should not get specialized."
 
--- INVARIANT: (length row == N) ==> (length result == arity + N - 1)
-specializeRowByRecordField :: Name.Name -> [Pattern] -> Maybe [Pattern]
-specializeRowByRecordField fieldName row =
-  case row of
-    Ctor _ _ _ : _ ->
-      Nothing
-    Anything : patterns ->
-      Just (Anything : patterns)
-    Array _ : _ ->
-      Nothing
-    Record namedPatterns : patterns ->
-      case Map.lookup fieldName namedPatterns of
-        Just pattern ->
-          Just (pattern : patterns)
-        Nothing ->
-          Nothing
-    Literal _ : _ ->
-      error $
-        "Compiler bug! After type checking, constructors and literals\
-        \ should never align in pattern match exhaustiveness checks."
-    [] ->
-      error "Compiler error! Empty matrices should not get specialized."
-
 -- INVARIANT: (length row == N) ==> (length result == N-1)
 specializeRowByLiteral :: Literal -> [Pattern] -> Maybe [Pattern]
 specializeRowByLiteral literal row =