[GHC] #16322: "deriving newtype instance" generates an infinite loop

[GHC]

#16322: "deriving newtype instance" generates an infinite loop
-------------------------------------+-------------------------------------
        Reporter:  paf31             |                Owner:  (none)
            Type:  bug               |               Status:  infoneeded
        Priority:  normal            |            Milestone:
       Component:  Compiler          |              Version:  8.6.3
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by RyanGlScott):

 Step 2 isn't quite accurate. In general, saying "GHC reduces to looking
 for an instance of ..." is a decent intuition for how
 `GeneralizedNewtypeDeriving` works, but it breaks down in the particular
 case of `C`. Given the standalone `deriving` declaration you've written,
 GHC will first generate this code:

 {{{#!hs
 instance C a b => C (X String a) (X String b) where
   c :: Proxy (X String a) -> Int
   c = coerce @(Proxy (X String a) -> Int) @(Proxy (X String a) -> Int) c
 }}}

 At this point, GHC will typecheck this code. GHC has no issues with this
 code—the only class constraint that needs to be satisfies in order to
 typecheck is `C (X String a) (X String b)`, but since that's exactly the
 instance we're defining, this works. Moreover, that's why `c` loops at
 runtime, since we're recursively invoking `c` from the same instance
 without end. (Note that the `C a b =>` constraint is never really used at
 runtime—the only purpose it serves is to satisfy the functional dependency
 coverage condition.)

 All of this weirdness is ultimately due to the fact that the type of `c`
 never mentions `b` anywhere. If `c`'s type were `Proxy b -> Int`, then the
 generated code would instead be:

 {{{#!hs
 instance C a b => C (X String a) (X String b) where
   c :: Proxy (X String b) -> Int
   c = coerce @(Proxy b -> Int) @(Proxy (X String b) -> Int) c
 }}}

 In order to typecheck this, GHC would need actually need to satisfy a `C a
 b` constraint. In that scenario, it would be fair to summarize the whole
 thing as "reducing to looking for an instance of `C a b`". But in the
 program you've presented, you have an atypical corner case where the
 method's type does not mention the last type parameter of the class, so
 the usual intuition doesn't apply.

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