## FlexibleContexts checking should happen also on inferred signature

I assume that if a program typechecks, adding any missing top-level signature inferred by GHC should be a meaning-preserving transformation and yield a new program which typechecks. (Please correct me if I'm wrong). But I've found a violation: namely, given enough other extensions (I think !TypeFamilies is the relevant one), GHC will infer signatures which would require !FlexibleContexts! Arguably, either those signatures should be rejected in the first place with a special error message (since GHC is not supposed to show code the user didn't write in error messages), or !TypeFamilies should imply !FlexibleContexts (or a restricted form which is sufficient for what !TypeFamilies produces - namely, constraints can contain type families in place of raw type variables).

Here's an example - without !FlexibleContexts it does not typecheck , unless you comment out the signature of fold and unfold. Those signatures where produced by GHCi (with :browse) in the first-place.

```
{-# LANGUAGE TypeFamilies, DeriveFunctor, NoMonomorphismRestriction #-}
-- , FlexibleContexts
data Fix f = In { out :: f (Fix f) }
data Expr = Const Int | Add Expr Expr
data PFExpr r = ConstF Int | AddF r r deriving Functor
type Expr' = Fix PFExpr
class Regular0 a where
deepFrom0 :: a -> Fix (PF a)
deepTo0 :: Fix (PF a) -> a
type family PF a :: * -> *
type instance PF Expr = PFExpr
instance Regular0 Expr where
deepFrom0 = In . (\expr ->
case expr of
Const n -> ConstF n
Add a b -> AddF (deepFrom0 a) (deepFrom0 b))
deepTo0 =
(\expr' ->
case expr' of
ConstF n -> Const n
AddF a b -> Add (deepTo0 a) (deepTo0 b)) . out
class Regular a where
from :: a -> PF a a
to :: PF a a -> a
instance Regular Expr where
from expr =
case expr of
Const n -> ConstF n
Add a b -> AddF a b
to expr' =
case expr' of
ConstF n -> Const n
AddF a b -> Add a b
-- But in fact, the construction is just an instance of fold.
fold :: (Functor (PF a), Regular a) => (PF a b -> b) -> a -> b
unfold :: (Functor (PF b), Regular b) => (a -> PF b a) -> a -> b
fold f = f . fmap (fold f) . from
unfold f = to . fmap (unfold f) . f
```