[GHC] #14546: -Woverlapping-patterns warns on wrong patterns for Int

[GHC]

#14546: -Woverlapping-patterns warns on wrong patterns for Int
-------------------------------------+-------------------------------------
        Reporter:  Lemming           |                Owner:  sighingnow
            Type:  bug               |               Status:  patch
        Priority:  normal            |            Milestone:
       Component:  Compiler (Type    |              Version:  8.2.2
  checker)                           |             Keywords:
      Resolution:                    |  PatternMatchWarnings
Operating System:  Unknown/Multiple  |         Architecture:
 Type of failure:  Incorrect         |  Unknown/Multiple
  error/warning at compile-time      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):  Phab:D4571
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by Ben Gamari <ben@…>):

 In [changeset:"1f88f541aad1e36d01f22f9e71dfbc247e6558e2/ghc" 1f88f54/ghc]:
 {{{
 #!CommitTicketReference repository="ghc"
 revision="1f88f541aad1e36d01f22f9e71dfbc247e6558e2"
 Improve exhaustiveness checking for literal values and patterns, fix
 #14546

 Currently, we parse both the **integral literal** value and the patterns
 as `OverLit HsIntegral`.  For example:

 ```
   case 0::Int of
       0 -> putStrLn "A"
       1 -> putStrLn "B"
       _ -> putStrLn "C"
 ```

 When checking the exhaustiveness of pattern matching, we translate the
 `0` in value position as `PmOLit`, but translate the `0` and `1` in
 pattern position as `PmSLit`. The inconsistency leads to the failure of
 `eqPmLit` to detect the equality and report warning of "Pattern match is
 redundant" on pattern `0`, as reported in #14546. In this patch we
 remove the specialization of `OverLit` patterns, and keep the overloaded
 number literal in pattern as it is to maintain the consistency.  Now we
 can capture the exhaustiveness of pattern `0` and the redundancy of
 pattern `1` and `_`.

 For **string literals**, we parse the string literals as `HsString`.
 When  `OverloadedStrings` is enabled, it further be turned as `HsOverLit
 HsIsString`, whether it's type is `String` or not. For example:

 ```
   case "foo" of
       "foo" -> putStrLn "A"
       "bar" -> putStrLn "B"
       "baz" -> putStrLn "C"
 ```

 Previously, the overloaded string values are translated to `PmOLit` and
 the non-overloaded string values are translated to `PmSLit`. However the
 string patterns, both overloaded and non-overloaded, are translated to
 list of characters. The inconsistency leads to wrong warnings about
 redundant and non-exhaustive pattern matching warnings, as reported
 in #14546.

 In order to catch the redundant pattern in following case:

 ```
   case "foo" of
       ('f':_) -> putStrLn "A"
       "bar" -> putStrLn "B"
 ```

 In this patch, we translate non-overloaded string literals, both in
 value position and pattern position, as list of characters. For
 overloaded string literals, we only translate it to list of characters
 only when it's type is `stringTy`, since we know nothing about the
 `toString` methods.  But we know that if two overloaded strings are
 syntax equal, then they are equal. Then if it's type is not `stringTy`,
 we just translate it to `PmOLit`. We can still capture the
 exhaustiveness of pattern `"foo"` and the redundancy of pattern `"bar"`
 and `"baz"` in the following code:

 ```
 {-# LANGUAGE OverloadedStrings #-}
 main = do
   case "foo" of
       "foo" -> putStrLn "A"
       "bar" -> putStrLn "B"
       "baz" -> putStrLn "C"
 ```

 Test Plan: make test TEST="T14546"

 Reviewers: bgamari, simonpj

 Reviewed By: bgamari, simonpj

 Subscribers: simonpj, thomie, carter

 GHC Trac Issues: #14546

 Differential Revision: https://phabricator.haskell.org/D4571
 }}}

-- 
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14546#comment:5>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler