GHC panic when creating a monomorphised pattern synonym for GADT

I have an expression

{-# LANGUAGE GADTs           #-}
{-# LANGUAGE PatternSynonyms #-}

data Exp a where
  Fun :: (a -> b) -> (Exp a -> Exp b)

and I want to create a pattern synonym for Int-expressions:

-- This works:
--   pattern IntFun :: (a -> b) -> (Exp a -> Exp b)
--   pattern IntFun f x = Fun f x

pattern IntFun :: (Int -> Int) -> (Exp Int -> Exp Int)
pattern IntFun f x = Fun f x

which results in

% ghci -ignore-dot-ghci Panic.hs 
GHCi, version 7.10.0.20150316: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( Panic.hs, interpreted )

Panic.hs:8:28:
    Couldn't match type ‘a’ with ‘Int’
      ‘a’ is a rigid type variable bound by
          a pattern with constructor
            Fun :: forall b a. (a -> b) -> Exp a -> Exp b,
          in a pattern synonym declaration
          at Panic.hs:8:22
    Expected type: Int -> Int
      Actual type: a -> Int
    Relevant bindings include
      b :: Exp a (bound at Panic.hs:8:28)
      a :: a -> Int (bound at Panic.hs:8:26)
Failed, modules loaded: none.

So I try to be sneaky:

pattern IntFun :: (a ~ Int) => (a -> b) -> (Exp a -> Exp b)
pattern IntFun f x = Fun f x

-- % ghci -ignore-dot-ghci Panic.hs 
-- …
--     Couldn't match type ‘a’ with ‘Int’
--       ‘a’ is a rigid type variable bound by
--           the type signature for IntFun :: (a1 -> b) -> Exp a1 -> Exp b
--           at Panic.hs:8:22

and if I constrain both type variables it panics

pattern IntFun :: (a ~ Int, b ~ Int) => (a -> b) -> (Exp a -> Exp b)
pattern IntFun f x = Fun f x

--     Couldn't match type ‘b’ with ‘Int’
--       ‘b’ is untouchable
--         inside the constraints ()
--         bound by the type signature for
--                    IntFun :: (a1 -> b) -> Exp a1 -> Exp b
--         at Panic.hs:8:9-14ghc: panic! (the 'impossible' happened)
--   (GHC version 7.10.0.20150316 for i386-unknown-linux):
--         No skolem info: b_alF[sk]
-- 
-- Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug

The final version should look like:

type Name = String
data Exp a where
  Fun :: Name -> (a -> b) -> (Exp a -> Exp b)
  ...

pattern Suc :: Exp Int -> Exp Int
pattern Suc n <- Fun _     _     n where
        Suc n =  Fun "suc" (+ 1) n

Shouldn't this work?