Incorrect result for nested constructors

[Aster89]

In a case as simple as this

{-# LANGUAGE EmptyCase #-}
{-# OPTIONS_GHC -Wall -fmax-uncovered-patterns=99 #-}
module T where

foo :: Int
foo = case (_ :: Bool, _ :: Bool) of

where the diagnostic has good suggestions,

 ╔══════════════════════════════════════════════════╗
 ║ Pattern match(es) are non-exhaustive             ║
 ║ In a case alternative:                           ║
 ║     Patterns of type ‘(Bool, Bool)’ not matched: ║
 ║         (False, False)                           ║
 ║         (False, True)                            ║
 ║         (True, False)                            ║
 ║         (True, True) [GHC-62161]                 ║
 ╚══════════════════════════════════════════════════╝

the completion is erroneous:

bar = case (_ :: Bool, _ :: Bool) of
  (,) _ _ -> _
  (,) _ _ -> _
  (,) _ _ -> _
  (,) _ _ -> _

[Aster89]

The above should not be confused with a very similar but crucially different scenario:

foo :: Int
foo = case _ :: ([Int], Bool) of

is completed like this:

foo = case _ :: ([Int], Bool) of
  (,) _ _ -> _

which appears like the bug described above, but is different in that GHC doesn't even give us good alternatives, the diagnostic being:

╔══════════════════════════════════════════════════════════════════════╗
║ Pattern match(es) are non-exhaustive                                 ║
║ In a case alternative:                                               ║
║     Patterns of type ‘([Int], Bool)’ not matched: (_, _) [GHC-62161] ║
╚══════════════════════════════════════════════════════════════════════╝

In other words, even if I fix the bug described above, this case still behaves the same.