[GHC] #14167: GHC often depicts H98 datatypes as GADTs when it shouldn't

[GHC]

#14167: GHC often depicts H98 datatypes as GADTs when it shouldn't
-------------------------------------+-------------------------------------
           Reporter:  RyanGlScott    |             Owner:  (none)
               Type:  bug            |            Status:  new
           Priority:  normal         |         Milestone:
          Component:  Compiler       |           Version:  8.2.1
           Keywords:  GADTs,         |  Operating System:  Unknown/Multiple
  TemplateHaskell                    |
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 (Spun off from Phab:D3880.)

 There are at least a couple of points in the GHC codebase where poor
 decisions are made regarding whether to depict a datatype using H98 syntax
 or GADT syntax. In particular:

 1. When reifying a datatype in Template Haskell, some complicated
 heuristics are used to determine whether a datatype is reified with
 `(Rec)GadtC` or not (see `Note [Reifying GADT data constructors]` in
 `TcSplice` for the horrifying details). But these heuristics are far from
 perfect, as they will cause some vanilla datatypes to be reified as GADTs
 (e.g., `data T a = (a ~ Int) => MkT`).
 2. When pretty-printing a datatype (for instance, via the `:info` command
 in GHCi), GHC also chooses to sometimes depict vanilla datatypes as GADTs.
 For instance:

 {{{
 λ> :set -XExistentialQuantification
 λ> data Foo a = Show a => Foo
 λ> :i Foo
 type role Foo nominal
 data Foo a where
   Foo :: Show a => Foo a
 }}}

    `Foo` is depicted as a GADT, despite the fact that we didn't use GADT
 syntax.

 There might be other places in the code that exhibit these symptoms too—we
 should take a closer look.

 I use the phrase "poor decisions" above since GHC really does have the
 right info it needs to make the correct decisions. That info is in the
 form of the `isGadtSyntaxTyCon`, which conveniently recalls whether a
 datatype was declared with GADT syntax or not. With this, we should be
 able to eliminate the flawed heuristics that GHC is currently using and
 accurately depict datatypes the way users wrote them.

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