[GHC] #8114: GHC panic when building `thyme`

[GHC]

#8114: GHC panic when building `thyme`
---------------------------------------+----------------------------------
        Reporter:  Ptharien's Flame    |            Owner:
            Type:  bug                 |           Status:  new
        Priority:  normal              |        Milestone:
       Component:  Compiler            |          Version:  7.6.3
      Resolution:                      |         Keywords:
Operating System:  MacOS X             |     Architecture:  x86_64 (amd64)
 Type of failure:  Compile-time crash  |       Difficulty:  Unknown
       Test Case:                      |       Blocked By:
        Blocking:                      |  Related Tickets:
---------------------------------------+----------------------------------

Comment (by carter):

 the lint error message (using the minimal example that monoidal provides),
 on ghc 7.6.3 on OS X is the following

 {{{
 carter repoScratcher/testtyme » ghc -dstg-lint Array
 [1 of 1] Compiling Array            ( Array.hs, Array.o )
 stgEqType: unequal
     ghc-prim:GHC.Prim.ByteArray#{(w) tc 3f}
     ghc-prim:GHC.Prim.MutableByteArray#{(w) tc 31p} s{tv h} [tv]
 ghc: panic! (the 'impossible' happened)
   (GHC version 7.6.3 for x86_64-apple-darwin):
             *** Stg Lint ErrMsgs: in Stg2Stg ***
     <no location info>: Warning:
          [RHS of sat_sgA{v} [lid] :: main:Array.Array{tc rfc}]
         In a RHS constructor application, con type doesn't match arg
 types:
         Constructor type:
             ghc-prim:GHC.Prim.ByteArray#{(w) tc 3f} -> main:Array.Array{tc
 rfc}
         Arg types:
             ghc-prim:GHC.Prim.MutableByteArray#{(w) tc 31p} s{tv h} [tv]
     *** Offending Program ***
     main:Array.unsafeFreeze{v rff} [gid]
       :: forall s{tv afh} [tv].
          main:Array.MArray{tc rf9} s{tv afh} [tv]
          -> base:GHC.ST.ST{tc r4k} s{tv afh} [tv] main:Array.Array{tc rfc}
     [GblId, Arity=1, Unf=OtherCon []] =
         [] \r srt:SRT:[(01Z,
                         base:GHC.Base.${v 01Z} [gid])] [ds{v sgf} [lid]]
             case
                 ds{v sgf} [lid] :: Alg main:Array.MArray{tc rf9}
             of
             (wild{v sgD} [lid] [Occ=Dead]
                :: main:Array.MArray{tc rf9} s{tv h} [tv])
             {   -- lvs: [ds{v sgf} [lid]]; rhs lvs: []; srt:SRT:[(01Z,
 base:GHC.Base.${v 01Z} [gid])]
               main:Array.MArray{d rfa} (ds1{v sgn} [lid]
                                           :: ghc-
 prim:GHC.Prim.MutableByteArray#{(w) tc 31p}
                                                s{tv h} [tv]) ->
                   let {
                     sat_sgB{v} [lid]
                       :: base:GHC.ST.STRep{tc r4i} s{tv h} [tv]
 main:Array.Array{tc rfc}
                     [LclId] =
                         [ds1{v sgn} [lid]] \r srt:SRT:[] [s#{v sgm} [lid]]
                             let {
                               sat_sgA{v} [lid] :: main:Array.Array{tc rfc}
                               [LclId] =
                                   NO_CCS main:Array.Array{d rfd}! [ds1{v
 sgn} [lid]];
                             } in
                               ghc-prim:GHC.Prim.(#,#){(w) d 84} [s#{v sgm}
 [lid]
 sat_sgA{v} [lid]]; } in
                   let {
                     sat_sgC{v} [lid]
                       :: base:GHC.ST.STRep{tc r4i} s{tv h} [tv]
 main:Array.Array{tc rfc}
                          -> base:GHC.ST.ST{tc r4k} s{tv h} [tv]
 main:Array.Array{tc rfc}
                     [LclId] =
                         [] \r srt:SRT:[] [tpl{v sgj} [lid]] tpl{v sgj}
 [lid];
                   } in
                     base:GHC.Base.${v 01Z} [gid] sat_sgC{v} [lid]
 sat_sgB{v} [lid];
             };
     main:Array.aBA{v rfe} [gid[[RecSel]]]
       :: main:Array.Array{tc rfc}
          -> ghc-prim:GHC.Prim.ByteArray#{(w) tc 3f}
     [GblId[[RecSel]], Arity=1, Caf=NoCafRefs, Unf=OtherCon []] =
         [] \r srt:SRT:[] [ds{v sgr} [lid]]
             case
                 ds{v sgr} [lid] :: Alg main:Array.Array{tc rfc}
             of
             (wild{v sgE} [lid] [Occ=Dead] :: main:Array.Array{tc rfc})
             {   -- lvs: [ds{v sgr} [lid]]; rhs lvs: []; srt:SRT:[]
               main:Array.Array{d rfd} (ds1{v sgu} [lid]
                                          :: ghc-
 prim:GHC.Prim.ByteArray#{(w) tc 3f}) ->
                   ds1{v sgu} [lid];
             };
     main:Array.maBA{v rfb} [gid[[RecSel]]]
       :: forall s{tv afg} [tv].
          main:Array.MArray{tc rf9} s{tv afg} [tv]
          -> ghc-prim:GHC.Prim.MutableByteArray#{(w) tc 31p} s{tv afg} [tv]
     [GblId[[RecSel]], Arity=1, Caf=NoCafRefs, Unf=OtherCon []] =
         [] \r srt:SRT:[] [ds{v sgw} [lid]]
             case
                 ds{v sgw} [lid] :: Alg main:Array.MArray{tc rf9}
             of
             (wild{v sgF} [lid] [Occ=Dead]
                :: main:Array.MArray{tc rf9} s{tv d} [tv])
             {   -- lvs: [ds{v sgw} [lid]]; rhs lvs: []; srt:SRT:[]
               main:Array.MArray{d rfa} (ds1{v sgz} [lid]
                                           :: ghc-
 prim:GHC.Prim.MutableByteArray#{(w) tc 31p}
                                                s{tv d} [tv]) ->
                   ds1{v sgz} [lid];
             };
     main:Array.MArray{v rfr} [gid[DataCon]]
       :: forall s{tv afg} [tv].
          ghc-prim:GHC.Prim.MutableByteArray#{(w) tc 31p} s{tv afg} [tv]
          -> main:Array.MArray{tc rf9} s{tv afg} [tv]
     [GblId[DataCon],
      Arity=1,
      Caf=NoCafRefs,
      Str=DmdType Tm,
      Unf=OtherCon []] =
         [] \r srt:SRT:[] [eta_B1{v} [lid]]
             main:Array.MArray{d rfa} [eta_B1{v} [lid]];
     main:Array.Array{v rfn} [gid[DataCon]]
       :: ghc-prim:GHC.Prim.ByteArray#{(w) tc 3f}
          -> main:Array.Array{tc rfc}
     [GblId[DataCon],
      Arity=1,
      Caf=NoCafRefs,
      Str=DmdType Tm,
      Unf=OtherCon []] =
         [] \r srt:SRT:[] [eta_B1{v} [lid]]
             main:Array.Array{d rfd} [eta_B1{v} [lid]];
     *** End of Offense ***

 Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug

 }}}

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