RULE too complicated to desugar when using constraint synonyms

With the following minimal-as-I-could-get-it example,

{-# LANGUAGE ConstraintKinds #-}

class Qux a
class (Num r) => Class1 r
class (Num r) => Class2 r

newtype Foo q z = Foo z
type Qux' q z = (Qux q, Integral z)
instance (Num z) => Num (Foo q z)
instance (Qux' q z, Num z) => Class1 (Foo q z)
instance (Qux' q z, Num z) => Class2 (Foo q z)

newtype Bar r = Bar r

{-# SPECIALIZE bar :: (Qux q) => Bar (Foo q Int) -> Bar (Foo q Int) #-}
bar :: (Class1 r, Class2 r) => Bar r -> Bar r
bar = undefined

I get the warning:

RULE left-hand side too complicated to desugar
      Optimised lhs: let {
                       $dNum_aGE :: Num (Foo q Int)
                       [LclId, Str=DmdType]
                       $dNum_aGE = Main.$fNumFoo @ q @ Int GHC.Num.$fNumInt } in
                     bar
                       @ (Foo q Int)
                       (Main.$fClass1Foo
                          @ q @ Int $dNum_aGE ($dQux_aFH, $dIntegral_aGI) GHC.Num.$fNumInt)
                       (Main.$fClass2Foo
                          @ q @ Int $dNum_aGE ($dQux_aFH, $dIntegral_aGI) GHC.Num.$fNumInt)
      Orig lhs: let {
                  $dIntegral_aGI :: Integral Int
                  [LclId, Str=DmdType]
                  $dIntegral_aGI = GHC.Real.$fIntegralInt } in
                let {
                  tup_aGJ :: Qux' q Int
                  [LclId, Str=DmdType]
                  tup_aGJ = ($dQux_aFH, $dIntegral_aGI) } in
                let {
                  $dNum_aGH :: Num Int
                  [LclId, Str=DmdType]
                  $dNum_aGH = GHC.Num.$fNumInt } in
                let {
                  $dNum_aGG :: Num Int
                  [LclId, Str=DmdType]
                  $dNum_aGG = $dNum_aGH } in
                let {
                  tup_aGF :: Qux' q Int
                  [LclId, Str=DmdType]
                  tup_aGF = ($dQux_aFH, $dIntegral_aGI) } in
                let {
                  $dNum_aGE :: Num (Foo q Int)
                  [LclId, Str=DmdType]
                  $dNum_aGE = Main.$fNumFoo @ q @ Int $dNum_aGH } in
                let {
                  $dClass2_aFK :: Class2 (Foo q Int)
                  [LclId, Str=DmdType]
                  $dClass2_aFK =
                    Main.$fClass2Foo @ q @ Int $dNum_aGE tup_aGJ $dNum_aGH } in
                let {
                  $dClass1_aFJ :: Class1 (Foo q Int)
                  [LclId, Str=DmdType]
                  $dClass1_aFJ =
                    Main.$fClass1Foo @ q @ Int $dNum_aGE tup_aGF $dNum_aGG } in
                bar @ (Foo q Int) $dClass1_aFJ $dClass2_aFK

This is apparently due to my use of a constraint synonym. In this code it would be quite simple to just replace the synonym with the constraints on its RHS, but in my real code my constraint synonym is an associated type, so that is not an option. It would be great o be able to specialize in the presence of constraint synonyms.

Trac metadata

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