Inlining depends on datatype size, even with INLINE pragmas

Consider the following code:

data Logic = T | F
           | Not Logic

instance GEq Logic

testEqLogic = geq (Not T) (Not F)

With a proper definitions of generic equality geq in class GEq, and an instance Generic Logic, we get the following core code with -O1:

Rec {
Bug.$fGEqLogic_$cgeq [Occ=LoopBreaker]
  :: Bug.Logic -> Bug.Logic -> GHC.Types.Bool
[GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SS]
Bug.$fGEqLogic_$cgeq =
  \ (x_ap1 :: Bug.Logic) (y_ap2 :: Bug.Logic) ->
    case x_ap1 of _ {
      Bug.T ->
        case y_ap2 of _ {
          Bug.T -> GHC.Types.True;
          Bug.F -> GHC.Types.False;
          Bug.Not g1_aBc_ayJ -> GHC.Types.False
        };
      Bug.F ->
        case y_ap2 of _ {
          Bug.T -> GHC.Types.False;
          Bug.F -> GHC.Types.True;
          Bug.Not g1_aBc_ayJ -> GHC.Types.False
        };
      Bug.Not g1_aBc_ayJ ->
        case y_ap2 of _ {
          __DEFAULT -> GHC.Types.False;
          Bug.Not g1_aBc1_XAu -> Bug.$fGEqLogic_$cgeq g1_aBc_ayJ g1_aBc1_XAu
        }
    }
end Rec }

Nice and simple, looking just like what we would expect for an equality function for datatype Logic.

Now we add one more constructor to datatype Logic (and adapt the Generic instance accordingly):

data Logic = T | F
           | Not Logic 
           | And Logic Logic

GHC (HEAD) now generates 3000 lines of core code for the Bug.$fGEqLogic_$cgeq function, instead of something only slightly longer than above.

Why is this? The second version of our Logic datatype is as easy to optimise as the first version; only the terms involved will be slightly longer. Attached file Bug2.hs is the input which gives the correct behaviour, while Bug3.hs is the input with one added constructor. (You might wonder if it has to do with the fact that the added constructor has more than one argument, but this is not the source of the problem.) Both files have INLINE pragmas pretty much everywhere (in fact, we're not deriving Generic so that we can put INLINE pragmas on to and from).

Trac metadata

Trac field	Value
Version	7.5
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture