[GHC] #15554: COMPLETE pragmas make overlapping-patterns warnings behave oddly

21 Aug 2018

      #15554: COMPLETE pragmas make overlapping-patterns warnings behave oddly
-------------------------------------+-------------------------------------
           Reporter:  staffehn       |             Owner:  (none)
               Type:  bug            |            Status:  new
           Priority:  normal         |         Milestone:  8.6.1
          Component:  Compiler       |           Version:  8.4.3
           Keywords:                 |  Operating System:  Unknown/Multiple
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 I can’t really quantify what’s wrong and what’s intended here, here’s a
 test file comparing different contrasting examples of similar functions
 which generate no or strange warnings in the cases that use a datatype
 with COMPLETE pragmas on pattern synonyms.

 {{{#!hs
 {-   1 -}  {-# LANGUAGE PatternSynonyms, ViewPatterns #-}
 {-   2 -}
 {-   3 -}  module M where
 {-   4 -}
 {-   5 -}  data T = A | B | C
 {-   6 -}
 {-   7 -}  isBC :: T -> Bool
 {-   8 -}  isBC A = False
 {-   9 -}  isBC B = True
 {-  10 -}  isBC C = True
 {-  11 -}
 {-  12 -}  pattern BC :: T
 {-  13 -}  pattern BC <- (isBC -> True)
 {-  14 -}  {-# COMPLETE A, BC #-}
 {-  15 -}
 {-  16 -}  g1 :: T -> Int
 {-  17 -}  g1 A = 1
 {-  18 -}  g1 BC = 2
 {-  19 -}  g1 _ = 3
 {-  20 -}
 {-  21 -}  --  M.hs:18:1: warning: [-Woverlapping-patterns]
 {-  22 -}  --      Pattern match is redundant
 {-  23 -}  --      In an equation for `g1': g1 BC = ...
 {-  24 -}  --     |
 {-  25 -}  --  18 | {-  18 -}  g1 BC = 2
 {-  26 -}  --     |            ^^^^^^^^^
 {-  27 -}
 {-  28 -}  g2 :: T -> Int
 {-  29 -}  g2 BC = 2
 {-  30 -}  g2 A = 1
 {-  31 -}  g2 _ = 3
 {-  32 -}
 {-  33 -}  -- g2: no warnings
 {-  34 -}
 {-  35 -}  g3 :: T -> Int
 {-  36 -}  g3 BC = 2
 {-  37 -}  g3 _ = 1
 {-  38 -}  g3 A = 3
 {-  39 -}  g3 A = 4
 {-  40 -}  g3 B = 4
 {-  41 -}  g3 B = 4
 {-  42 -}  g3 C = 4
 {-  43 -}  g3 C = 4
 {-  44 -}  g3 _ = 4
 {-  45 -}  g3 _ = 4
 {-  46 -}
 {-  47 -}  -- g3: no warnings
 {-  48 -}
 {-  49 -}  data T' = A' | B' | C'
 {-  50 -}
 {-  51 -}  isBC' :: T' -> Bool
 {-  52 -}  isBC' A' = False
 {-  53 -}  isBC' B' = True
 {-  54 -}  isBC' C' = True
 {-  55 -}
 {-  56 -}  pattern BC' :: T'
 {-  57 -}  pattern BC' <- (isBC' -> True)
 {-  58 -}  -- no COMPLETE pragma
 {-  59 -}
 {-  60 -}  g3' :: T' -> Int
 {-  61 -}  g3' BC' = 2
 {-  62 -}  g3' _ = 1
 {-  63 -}  g3' A' = 3
 {-  64 -}  g3' A' = 4
 {-  65 -}  g3' B' = 4
 {-  66 -}  g3' B' = 4
 {-  67 -}  g3' C' = 4
 {-  68 -}  g3' C' = 4
 {-  69 -}  g3' _ = 4
 {-  70 -}  g3' _ = 4
 {-  71 -}
 {-  72 -}  --  M.hs:63:1: warning: [-Woverlapping-patterns]
 {-  73 -}  --      Pattern match is redundant
 {-  74 -}  --      In an equation for g3': g3' A' = ...
 {-  75 -}  --     |
 {-  76 -}  --  63 | {-  63 -}  g3' A' = 3
 {-  77 -}  --     |            ^^^^^^^^^^
 {-  78 -}  --
 {-  79 -}  --  M.hs:64:1: warning: [-Woverlapping-patterns]
 {-  80 -}  --      Pattern match is redundant
 {-  81 -}  --      In an equation for g3': g3' A' = ...
 {-  82 -}  --     |
 {-  83 -}  --  64 | {-  64 -}  g3' A' = 4
 {-  84 -}  --     |            ^^^^^^^^^^
 {-  85 -}  --
 {-  86 -}  --  M.hs:65:1: warning: [-Woverlapping-patterns]
 {-  87 -}  --      Pattern match is redundant
 {-  88 -}  --      In an equation for g3': g3' B' = ...
 {-  89 -}  --     |
 {-  90 -}  --  65 | {-  65 -}  g3' B' = 4
 {-  91 -}  --     |            ^^^^^^^^^^
 {-  92 -}  --
 {-  93 -}  --  M.hs:66:1: warning: [-Woverlapping-patterns]
 {-  94 -}  --      Pattern match is redundant
 {-  95 -}  --      In an equation for g3': g3' B' = ...
 {-  96 -}  --     |
 {-  97 -}  --  66 | {-  66 -}  g3' B' = 4
 {-  98 -}  --     |            ^^^^^^^^^^
 {-  99 -}  --
 {- 100 -}  --  M.hs:67:1: warning: [-Woverlapping-patterns]
 {- 101 -}  --      Pattern match is redundant
 {- 102 -}  --      In an equation for g3': g3' C' = ...
 {- 103 -}  --     |
 {- 104 -}  --  67 | {-  67 -}  g3' C' = 4
 {- 105 -}  --     |            ^^^^^^^^^^
 {- 106 -}  --
 {- 107 -}  --  M.hs:68:1: warning: [-Woverlapping-patterns]
 {- 108 -}  --      Pattern match is redundant
 {- 109 -}  --      In an equation for g3': g3' C' = ...
 {- 110 -}  --     |
 {- 111 -}  --  68 | {-  68 -}  g3' C' = 4
 {- 112 -}  --     |            ^^^^^^^^^^
 {- 113 -}  --
 {- 114 -}  --  M.hs:69:1: warning: [-Woverlapping-patterns]
 {- 115 -}  --      Pattern match is redundant
 {- 116 -}  --      In an equation for g3': g3' _ = ...
 {- 117 -}  --     |
 {- 118 -}  --  69 | {-  69 -}  g3' _ = 4
 {- 119 -}  --     |            ^^^^^^^^^
 {- 120 -}  --
 {- 121 -}  --  M.hs:70:1: warning: [-Woverlapping-patterns]
 {- 122 -}  --      Pattern match is redundant
 {- 123 -}  --      In an equation for g3': g3' _ = ...
 {- 124 -}  --     |
 {- 125 -}  --  70 | {-  70 -}  g3' _ = 4
 {- 126 -}  --     |            ^^^^^^^^^
 {- 127 -}
 {- 128 -}
 {- 129 -}  data S = X
 {- 130 -}
 {- 131 -}  pattern Y :: S
 {- 132 -}  pattern Y = X
 {- 133 -}  {-# COMPLETE Y #-}
 {- 134 -}
 {- 135 -}  f1 :: S -> Int
 {- 136 -}  f1 Y = 1
 {- 137 -}  f1 _ = 2
 {- 138 -}
 {- 139 -}  -- f1: no warnings
 {- 140 -}
 {- 141 -}  f2 :: S -> Int
 {- 142 -}  f2 X = 1
 {- 143 -}  f2 _ = 2
 {- 144 -}
 {- 145 -}  --  M.hs:143:1: warning: [-Woverlapping-patterns]
 {- 146 -}  --      Pattern match is redundant
 {- 147 -}  --      In an equation for `f2': f2 _ = ...
 {- 148 -}  --      |
 {- 149 -}  --  143 | {- 143 -}  f2 _ = 2
 {- 150 -}  --      |            ^^^^^^^^
 {- 151 -}
 {- 152 -}  f3 :: S -> Int
 {- 153 -}  f3 Y = 0
 {- 154 -}  f3 X = 1
 {- 155 -}  f3 _ = 2
 {- 156 -}
 {- 157 -}  -- f3: no warnings
 {- 158 -}
 {- 159 -}  data S' = X'
 {- 160 -}
 {- 161 -}  pattern Y' :: S'
 {- 162 -}  pattern Y' = X'
 {- 163 -}  -- no COMPLETE pragma
 {- 164 -}
 {- 165 -}  f3' :: S' -> Int
 {- 166 -}  f3' Y' = 1
 {- 167 -}  f3' X' = 0
 {- 168 -}  f3' _ = 2
 {- 169 -}
 {- 170 -}  --  M.hs:168:1: warning: [-Woverlapping-patterns]
 {- 171 -}  --      Pattern match is redundant
 {- 172 -}  --      In an equation for f3': f3' _ = ...
 {- 173 -}  --      |
 {- 174 -}  --  168 | {- 168 -}  f3' _ = 2
 {- 175 -}  --      |            ^^^^^^^^^
 }}}

 In particular: the warning for line 18 should probably be a warning for
 line 19, and there should be a similar warning for line 31. `g3` extends
 `g2` in a ridiculous way still without generating any warnings. `g3'`
 demonstrates the warnings one should expect.

 The `f` functions are perhaps a bit redundant, but I wanted to include a
 smaller datatype.

 I’m not sure if this is easily fixable, since I’m having doubts, that
 COMPLETE pragmas give enough information for generating good overlapping-
 patterns warnings. I didn’t think this matter through in detail, but,
 well, maybe it’s not that important to have this all that sophisticated
 anyways, since for example guards won’t give overlapping-patterns warnings
 either. But at least (IMO) it’d be nice to keep the warnings about the
 normal constructor’s patterns even when they’re mixed with pattern
 synonyms that have a COMPLETE pragma.

 Even further, I would always expect overlapping-patterns warnings when a
 pattern is simply duplicated and probably always if any additional pattern
 follows a complete listing of everything in a COMPLETE group. And there’s
 probably lots of cases one could consider naturally suggesting a warning;
 maybe someone can find a good principle/algorithm to use here. Going
 further, to prevent COMPLETE pragma setting that always give an
 overlapping-patterns or incomplete-patterns warnings, one could even
 consider warning directly at a COMPLETE pragma when it’s a strict subset
 of an existing COMPLETE group.

 By the way, my actual goal while finding this bug was to describe another
 (maybe) bug, which is that the incomplete-patterns warnings can suggest
 missing pattern synonyms that are not even in scope, which seems not very
 neat in some cases. In case someone really wants to rework all these
 warnings, I can make a separate ticket or give details on such a non-neat
 case that here.

-- 
Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/15554
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler