A ton of error message wibbles

Notably
 * Showing relevant bindings
 * Not suggesting add instance (Num T); see Trac #7222

testsuite/tests/annotations/should_fail/annfail05.stderr

@@ -2,7 +2,5 @@
 annfail05.hs:11:1:
     No instance for (Data.Data.Data NoInstances)
       arising from an annotation
-    Possible fix:
-      add an instance declaration for (Data.Data.Data NoInstances)
     In the expression: NoInstances
     In the annotation: {-# ANN f NoInstances #-}

testsuite/tests/annotations/should_fail/annfail08.stderr

@@ -2,13 +2,10 @@
 annfail08.hs:9:1:
     No instance for (Data.Data.Data (a0 -> a0))
       arising from an annotation
-    Possible fix:
-      add an instance declaration for (Data.Data.Data (a0 -> a0))
     In the expression: (id + 1)
     In the annotation: {-# ANN f (id + 1) #-}
 
 annfail08.hs:9:15:
     No instance for (Num (a0 -> a0)) arising from a use of `+'
-    Possible fix: add an instance declaration for (Num (a0 -> a0))
     In the expression: (id + 1)
     In the annotation: {-# ANN f (id + 1) #-}

testsuite/tests/arrows/should_fail/T5380.stderr

-
-T5380.hs:7:27:
-    Couldn't match expected type `not_bool' with actual type `Bool'
-      `not_bool' is a rigid type variable bound by
-                 the type signature for
-                   testB :: not_bool -> (() -> ()) -> () -> not_unit
-                 at T5380.hs:6:10
-    In the expression: b
-    In the expression: proc () -> if b then f -< () else f -< ()
-    In an equation for `testB':
-        testB b f = proc () -> if b then f -< () else f -< ()
-
-T5380.hs:7:34:
-    Couldn't match type `not_unit' with `()'
-      `not_unit' is a rigid type variable bound by
-                 the type signature for
-                   testB :: not_bool -> (() -> ()) -> () -> not_unit
-                 at T5380.hs:6:10
-    Expected type: () -> not_unit
-      Actual type: () -> ()
-    In the expression: f
-    In the expression: proc () -> if b then f -< () else f -< ()
-    In an equation for `testB':
-        testB b f = proc () -> if b then f -< () else f -< ()
+
+T5380.hs:7:27:
+    Couldn't match expected type `not_bool' with actual type `Bool'
+      `not_bool' is a rigid type variable bound by
+                 the type signature for
+                   testB :: not_bool -> (() -> ()) -> () -> not_unit
+                 at T5380.hs:6:10
+    Relevant bindings include
+      testB :: not_bool -> (() -> ()) -> () -> not_unit
+        (bound at T5380.hs:7:1)
+      b :: not_bool (bound at T5380.hs:7:7)
+    In the expression: b
+    In the expression: proc () -> if b then f -< () else f -< ()
+    In an equation for `testB':
+        testB b f = proc () -> if b then f -< () else f -< ()
+
+T5380.hs:7:34:
+    Couldn't match type `not_unit' with `()'
+      `not_unit' is a rigid type variable bound by
+                 the type signature for
+                   testB :: not_bool -> (() -> ()) -> () -> not_unit
+                 at T5380.hs:6:10
+    Expected type: () -> not_unit
+      Actual type: () -> ()
+    Relevant bindings include
+      testB :: not_bool -> (() -> ()) -> () -> not_unit
+        (bound at T5380.hs:7:1)
+    In the expression: f
+    In the expression: proc () -> if b then f -< () else f -< ()
+    In an equation for `testB':
+        testB b f = proc () -> if b then f -< () else f -< ()

testsuite/tests/deriving/should_fail/T2851.stderr

@@ -3,7 +3,6 @@ T2851.hs:9:15:
     No instance for (Show (F a))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (Show (F a))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Show (D a))

testsuite/tests/deriving/should_fail/T3621.stderr

@@ -3,7 +3,6 @@ T3621.hs:21:21:
     No instance for (MonadState state (State s))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (MonadState state (State s))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (MonadState state (WrappedState s))

testsuite/tests/deriving/should_fail/T5287.stderr

@@ -2,6 +2,8 @@
 T5287.hs:6:29:
     No instance for (A e oops)
       arising from the 'deriving' clause of a data type declaration
+    The type variable `oops' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix:
       use a standalone 'deriving instance' declaration,
         so you can specify the instance context yourself

testsuite/tests/deriving/should_fail/drvfail-foldable-traversable1.stderr

-
-drvfail-foldable-traversable1.hs:9:23:
-    No instance for (Functor Trivial1)
-      arising from the 'deriving' clause of a data type declaration
-    Possible fix:
-      add an instance declaration for (Functor Trivial1)
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
-    When deriving the instance for (Traversable Trivial1)
-
-drvfail-foldable-traversable1.hs:13:22:
-    No instance for (Foldable Trivial2)
-      arising from the 'deriving' clause of a data type declaration
-    Possible fix:
-      add an instance declaration for (Foldable Trivial2)
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
-    When deriving the instance for (Traversable Trivial2)
-
-drvfail-foldable-traversable1.hs:17:22:
-    Can't make a derived instance of `Foldable Infinite':
-      Constructor `Infinite' must not contain function types
-    In the data declaration for `Infinite'
-
-drvfail-foldable-traversable1.hs:21:22:
-    Can't make a derived instance of `Traversable (Cont r)':
-      Constructor `Cont' must not contain function types
-    In the data declaration for `Cont'
+
+drvfail-foldable-traversable1.hs:9:23:
+    No instance for (Functor Trivial1)
+      arising from the 'deriving' clause of a data type declaration
+    Possible fix:
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
+    When deriving the instance for (Traversable Trivial1)
+
+drvfail-foldable-traversable1.hs:13:22:
+    No instance for (Foldable Trivial2)
+      arising from the 'deriving' clause of a data type declaration
+    Possible fix:
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
+    When deriving the instance for (Traversable Trivial2)
+
+drvfail-foldable-traversable1.hs:17:22:
+    Can't make a derived instance of `Foldable Infinite':
+      Constructor `Infinite' must not contain function types
+    In the data declaration for `Infinite'
+
+drvfail-foldable-traversable1.hs:21:22:
+    Can't make a derived instance of `Traversable (Cont r)':
+      Constructor `Cont' must not contain function types
+    In the data declaration for `Cont'

testsuite/tests/deriving/should_fail/drvfail-functor2.stderr

-
-drvfail-functor2.hs:1:29: Warning:
-    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
-
-drvfail-functor2.hs:7:14:
-    Can't make a derived instance of `Functor InFunctionArgument':
-      Constructor `InFunctionArgument' must not use the type variable in a function argument
-    In the newtype declaration for `InFunctionArgument'
-
-drvfail-functor2.hs:10:14:
-    Can't make a derived instance of `Functor OnSecondArg':
-      Constructor `OnSecondArg' must use the type variable only as the last argument of a data type
-    In the newtype declaration for `OnSecondArg'
-
-drvfail-functor2.hs:15:14:
-    Cannot derive well-kinded instance of form `Functor (NoArguments ...)'
-      Class `Functor' expects an argument of kind `* -> *'
-    In the newtype declaration for `NoArguments'
-
-drvfail-functor2.hs:20:14:
-    Can't make a derived instance of `Functor StupidConstraint':
-      Data type `StupidConstraint' must not have a class context (Eq a)
-    In the data declaration for `StupidConstraint'
-
-drvfail-functor2.hs:26:14:
-    No instance for (Functor NoFunctor)
-      arising from the 'deriving' clause of a data type declaration
-    Possible fix:
-      add an instance declaration for (Functor NoFunctor)
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
-    When deriving the instance for (Functor UseNoFunctor)
+
+drvfail-functor2.hs:1:29: Warning:
+    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
+
+drvfail-functor2.hs:7:14:
+    Can't make a derived instance of `Functor InFunctionArgument':
+      Constructor `InFunctionArgument' must not use the type variable in a function argument
+    In the newtype declaration for `InFunctionArgument'
+
+drvfail-functor2.hs:10:14:
+    Can't make a derived instance of `Functor OnSecondArg':
+      Constructor `OnSecondArg' must use the type variable only as the last argument of a data type
+    In the newtype declaration for `OnSecondArg'
+
+drvfail-functor2.hs:15:14:
+    Cannot derive well-kinded instance of form `Functor (NoArguments ...)'
+      Class `Functor' expects an argument of kind `* -> *'
+    In the newtype declaration for `NoArguments'
+
+drvfail-functor2.hs:20:14:
+    Can't make a derived instance of `Functor StupidConstraint':
+      Data type `StupidConstraint' must not have a class context (Eq a)
+    In the data declaration for `StupidConstraint'
+
+drvfail-functor2.hs:26:14:
+    No instance for (Functor NoFunctor)
+      arising from the 'deriving' clause of a data type declaration
+    Possible fix:
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
+    When deriving the instance for (Functor UseNoFunctor)

testsuite/tests/deriving/should_fail/drvfail001.stderr

@@ -3,7 +3,6 @@ drvfail001.hs:16:33:
     No instance for (Show (f (f a)))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (Show (f (f a)))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Show (SM f a))

testsuite/tests/deriving/should_fail/drvfail002.stderr

@@ -2,8 +2,9 @@
 drvfail002.hs:19:23:
     No instance for (X T c)
       arising from the 'deriving' clause of a data type declaration
+    The type variable `c' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix:
-      add an instance declaration for (X T c)
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Show S)

testsuite/tests/deriving/should_fail/drvfail003.stderr

@@ -3,7 +3,6 @@ drvfail003.hs:16:56:
     No instance for (Show (v (v a)))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (Show (v (v a)))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Show (Square_ v w a))

testsuite/tests/deriving/should_fail/drvfail004.stderr

@@ -3,7 +3,6 @@ drvfail004.hs:8:12:
     No instance for (Eq (Foo a b))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (Eq (Foo a b))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Ord (Foo a b))

testsuite/tests/deriving/should_fail/drvfail007.stderr

@@ -3,7 +3,6 @@ drvfail007.hs:4:38:
     No instance for (Eq (Int -> Int))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (Eq (Int -> Int))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Eq Foo)

testsuite/tests/deriving/should_fail/drvfail012.stderr

@@ -3,7 +3,6 @@ drvfail012.hs:5:33:
     No instance for (Eq (Ego a))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (Eq (Ego a))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Ord (Ego a))

testsuite/tests/deriving/should_fail/drvfail013.stderr

@@ -3,16 +3,14 @@ drvfail013.hs:4:70:
     No instance for (Eq (m (Maybe a)))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (Eq (m (Maybe a)))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Eq (MaybeT m a))
 
 drvfail013.hs:6:70:
     No instance for (Eq (m (Maybe a)))
       arising from the 'deriving' clause of a data type declaration
     Possible fix:
-      add an instance declaration for (Eq (m (Maybe a)))
-      or use a standalone 'deriving instance' declaration,
-           so you can specify the instance context yourself
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
     When deriving the instance for (Eq (MaybeT' m a))

testsuite/tests/driver/T5147/T5147.stderr

 
 A.hs:6:15:
     No instance for (Show (Fields v)) arising from a use of `show'
-    Possible fix: add an instance declaration for (Show (Fields v))
     In the expression: show a
     In an equation for `showField': showField a = show a

testsuite/tests/gadt/T3169.stderr

@@ -5,6 +5,12 @@ T3169.hs:13:22:
       bound by the instance declaration at T3169.hs:10:10-36
     Expected type: Map a (Map b elt)
       Actual type: Map (a, b) elt
+    Relevant bindings include
+      lookup :: (a, b) -> Map (a, b) elt -> Maybe elt
+        (bound at T3169.hs:12:3)
+      a :: a (bound at T3169.hs:12:11)
+      b :: b (bound at T3169.hs:12:13)
+      m :: Map (a, b) elt (bound at T3169.hs:12:17)
     In the second argument of `lookup', namely `m'
     In the expression: lookup a m :: Maybe (Map b elt)
     In the expression:
@@ -21,6 +27,11 @@ T3169.hs:13:22:
             at T3169.hs:12:3
     Expected type: Map a (Map b elt)
       Actual type: Map (a, b) elt
+    Relevant bindings include
+      lookup :: (a, b) -> Map (a, b) elt -> Maybe elt
+        (bound at T3169.hs:12:3)
+      b :: b (bound at T3169.hs:12:13)
+      m :: Map (a, b) elt (bound at T3169.hs:12:17)
     In the second argument of `lookup', namely `m'
     In the expression: lookup a m :: Maybe (Map b elt)
     In the expression:

testsuite/tests/gadt/rw.stderr

-
-rw.hs:14:47:
-    Couldn't match expected type `a' with actual type `Int'
-      `a' is a rigid type variable bound by
-          the type signature for writeInt :: T a -> IORef a -> IO ()
-          at rw.hs:12:12
-    In the second argument of `writeIORef', namely `(1 :: Int)'
-    In the expression: writeIORef ref (1 :: Int)
-    In a case alternative: ~(Li x) -> writeIORef ref (1 :: Int)
-
-rw.hs:19:51:
-    Couldn't match type `a' with `Bool'
-      `a' is a rigid type variable bound by
-          the type signature for readBool :: T a -> IORef a -> IO ()
-          at rw.hs:16:12
-    Expected type: a -> Bool
-      Actual type: Bool -> Bool
-    In the second argument of `(.)', namely `not'
-    In the second argument of `(>>=)', namely `(print . not)'
-    In the expression: readIORef ref >>= (print . not)
+
+rw.hs:14:47:
+    Couldn't match expected type `a' with actual type `Int'
+      `a' is a rigid type variable bound by
+          the type signature for writeInt :: T a -> IORef a -> IO ()
+          at rw.hs:12:12
+    Relevant bindings include
+      writeInt :: T a -> IORef a -> IO () (bound at rw.hs:13:1)
+      v :: T a (bound at rw.hs:13:10)
+      ref :: IORef a (bound at rw.hs:13:12)
+    In the second argument of `writeIORef', namely `(1 :: Int)'
+    In the expression: writeIORef ref (1 :: Int)
+    In a case alternative: ~(Li x) -> writeIORef ref (1 :: Int)
+
+rw.hs:19:51:
+    Couldn't match type `a' with `Bool'
+      `a' is a rigid type variable bound by
+          the type signature for readBool :: T a -> IORef a -> IO ()
+          at rw.hs:16:12
+    Expected type: a -> Bool
+      Actual type: Bool -> Bool
+    Relevant bindings include
+      readBool :: T a -> IORef a -> IO () (bound at rw.hs:17:1)
+      v :: T a (bound at rw.hs:17:10)
+      ref :: IORef a (bound at rw.hs:17:12)
+    In the second argument of `(.)', namely `not'
+    In the second argument of `(>>=)', namely `(print . not)'
+    In the expression: readIORef ref >>= (print . not)

testsuite/tests/ghci.debugger/scripts/break003.stderr

 
 <interactive>:5:1:
     No instance for (Show (t -> a)) arising from a use of `print'
-    Possible fix: add an instance declaration for (Show (t -> a))
     In a stmt of an interactive GHCi command: print it

testsuite/tests/ghci.debugger/scripts/break006.stderr

@@ -3,6 +3,7 @@
     No instance for (Show a) arising from a use of `print'
     Cannot resolve unknown runtime type `a'
     Use :print or :force to determine these types
+    Relevant bindings include it :: a (bound at <interactive>:6:1)
     Note: there are several potential instances:
       instance Show Double -- Defined in `GHC.Float'
       instance Show Float -- Defined in `GHC.Float'
@@ -15,6 +16,7 @@
     No instance for (Show a) arising from a use of `print'
     Cannot resolve unknown runtime type `a'
     Use :print or :force to determine these types
+    Relevant bindings include it :: a (bound at <interactive>:8:1)
     Note: there are several potential instances:
       instance Show Double -- Defined in `GHC.Float'
       instance Show Float -- Defined in `GHC.Float'

testsuite/tests/ghci.debugger/scripts/print019.stderr

@@ -3,6 +3,7 @@
     No instance for (Show a1) arising from a use of `print'
     Cannot resolve unknown runtime type `a1'
     Use :print or :force to determine these types
+    Relevant bindings include it :: a1 (bound at <interactive>:11:1)
     Note: there are several potential instances:
       instance Show a => Show (List1 a) -- Defined at ../Test.hs:11:12
       instance Show MyInt -- Defined at ../Test.hs:14:16

testsuite/tests/ghci/scripts/ghci050.stderr

-
-<interactive>:6:49:
-    Couldn't match expected type `a'
-                with actual type `ListableElem (a, a)'
-      `a' is a rigid type variable bound by
-          the instance declaration at <interactive>:6:10
-    In the expression: a
-    In the expression: [a, b]
-    In an equation for `asList': asList (a, b) = [a, b]
+
+<interactive>:6:49:
+    Couldn't match expected type `a'
+                with actual type `ListableElem (a, a)'
+      `a' is a rigid type variable bound by
+          the instance declaration at <interactive>:6:10
+    Relevant bindings include
+      asList :: (a, a) -> [ListableElem (a, a)]
+        (bound at <interactive>:6:33)
+      a :: a (bound at <interactive>:6:41)
+      b :: a (bound at <interactive>:6:43)
+    In the expression: a
+    In the expression: [a, b]
+    In an equation for `asList': asList (a, b) = [a, b]

testsuite/tests/indexed-types/should_compile/Simple14.stderr

 
-Simple14.hs:17:12:
+Simple14.hs:17:19:
     Couldn't match type `z0' with `n'
       `z0' is untouchable
-           inside the constraints (Maybe m ~ Maybe n)
-           bound at a type expected by the context:
-                      Maybe m ~ Maybe n => EQ_ z0 z0
+        inside the constraints (Maybe m ~ Maybe n)
+        bound by a type expected by the context:
+                   Maybe m ~ Maybe n => EQ_ z0 z0
+        at Simple14.hs:17:12-33
       `n' is a rigid type variable bound by
           the type signature for foo :: EQ_ (Maybe m) (Maybe n)
           at Simple14.hs:16:17
     Expected type: EQ_ z0 z0
       Actual type: EQ_ m n
+    Relevant bindings include
+      foo :: EQ_ (Maybe m) (Maybe n) (bound at Simple14.hs:17:1)
     In the second argument of `eqE', namely `(eqI :: EQ_ m n)'
     In the first argument of `ntI', namely `(`eqE` (eqI :: EQ_ m n))'
     In the expression: ntI (`eqE` (eqI :: EQ_ m n))

testsuite/tests/indexed-types/should_compile/T3208b.stderr

@@ -10,17 +10,8 @@ T3208b.hs:15:10:
     Possible fix: add a type signature that fixes these type variable(s)
     Expected type: STerm o0
       Actual type: OTerm o0
-    In the expression: fce (apply f)
-    In an equation for fce': fce' f = fce (apply f)
-
-T3208b.hs:15:15:
-    Could not deduce (STerm a ~ OTerm o0)
-    from the context (OTerm a ~ STerm a, OBJECT a, SUBST a)
-      bound by the type signature for
-                 fce' :: (OTerm a ~ STerm a, OBJECT a, SUBST a) => a -> c
-      at T3208b.hs:14:9-56
-    The type variable `o0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    In the first argument of `fce', namely `(apply f)'
+    Relevant bindings include
+      fce' :: a -> c (bound at T3208b.hs:15:1)
+      f :: a (bound at T3208b.hs:15:6)
     In the expression: fce (apply f)
     In an equation for fce': fce' f = fce (apply f)

testsuite/tests/indexed-types/should_fail/ExtraTcsUntch.stderr

@@ -5,7 +5,6 @@ ExtraTcsUntch.hs:24:53:
       bound by the inferred type of
                f :: F Int ~ [[t]] => [t] -> ((), ((), ()))
       at ExtraTcsUntch.hs:(21,1)-(25,29)
-    Possible fix: add an instance declaration for (C [t] [a])
     In the expression: op x [y]
     In the expression: (h [[undefined]], op x [y])
     In a case alternative: TEx y -> (h [[undefined]], op x [y])

testsuite/tests/indexed-types/should_fail/GADTwrong1.stderr

@@ -13,6 +13,9 @@ GADTwrong1.hs:12:19:
              T :: forall a. a -> T (Const a),
            in a case alternative
            at GADTwrong1.hs:12:12
+    Relevant bindings include
+      coerce :: a -> b (bound at GADTwrong1.hs:11:1)
+      y :: a1 (bound at GADTwrong1.hs:12:14)
     In the expression: y
     In a case alternative: T y -> y
     In the expression: case T x :: T (Const b) of { T y -> y }

testsuite/tests/indexed-types/should_fail/NoMatchErr.stderr

 
 NoMatchErr.hs:20:5:
-    Could not deduce (Memo d ~ Memo d0)
+    Could not deduce (Memo d0 ~ Memo d)
     from the context (Fun d)
       bound by the type signature for f :: Fun d => Memo d a -> Memo d a
       at NoMatchErr.hs:19:7-37
     NB: `Memo' is a type function, and may not be injective
     The type variable `d0' is ambiguous
     Possible fix: add a type signature that fixes these type variable(s)
-    Expected type: Memo d a -> Memo d a
-      Actual type: Memo d0 a -> Memo d0 a
+    Expected type: (d0 -> a) -> Memo d a
+      Actual type: (d0 -> a) -> Memo d0 a
+    Relevant bindings include
+      f :: Memo d a -> Memo d a (bound at NoMatchErr.hs:20:1)
+    In the first argument of `(.)', namely `abst'
     In the expression: abst . appl
     In an equation for `f': f = abst . appl

testsuite/tests/indexed-types/should_fail/SimpleFail16.stderr

@@ -2,10 +2,11 @@
 SimpleFail16.hs:10:12:
     Couldn't match expected type `F ()' with actual type `p0 a0'
     The type variables `p0', `a0' are ambiguous
-    Possible cause: the monomorphism restriction applied to the following:
-      bar :: p0 a0 (bound at SimpleFail16.hs:10:1)
+    Possible cause: the monomorphism restriction applied to: `bar'
     Probable fix: give these definition(s) an explicit type signature
                   or use -XNoMonomorphismRestriction
+    Relevant bindings include
+      bar :: p0 a0 (bound at SimpleFail16.hs:10:1)
     In the first argument of `foo', namely `(undefined :: F ())'
     In the expression: foo (undefined :: F ())
     In an equation for `bar': bar = foo (undefined :: F ())

testsuite/tests/indexed-types/should_fail/SimpleFail5a.stderr

-
-SimpleFail5a.hs:31:11:
-    Couldn't match type `a' with `Int'
-      `a' is a rigid type variable bound by
-          the type signature for bar3wrong :: S3 a -> a
-          at SimpleFail5a.hs:30:14
-    Expected type: S3 a
-      Actual type: S3 Int
-    In the pattern: D3Int
-    In an equation for `bar3wrong': bar3wrong D3Int = 1
+
+SimpleFail5a.hs:31:11:
+    Couldn't match type `a' with `Int'
+      `a' is a rigid type variable bound by
+          the type signature for bar3wrong :: S3 a -> a
+          at SimpleFail5a.hs:30:14
+    Expected type: S3 a
+      Actual type: S3 Int
+    Relevant bindings include
+      bar3wrong :: S3 a -> a (bound at SimpleFail5a.hs:31:1)
+    In the pattern: D3Int
+    In an equation for `bar3wrong': bar3wrong D3Int = 1

testsuite/tests/indexed-types/should_fail/T1897b.stderr

-
-T1897b.hs:16:1:
-    Could not deduce (Depend a ~ Depend a0)
-    from the context (Bug a)
-      bound by the inferred type for `isValid':
-                 Bug a => [Depend a] -> Bool
-      at T1897b.hs:16:1-41
-    NB: `Depend' is a type function, and may not be injective
-    The type variable `a0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Expected type: [Depend a] -> Bool
-      Actual type: [Depend a0] -> Bool
-    When checking that `isValid'
-      has the inferred type `forall a. Bug a => [Depend a] -> Bool'
-    Probable cause: the inferred type is ambiguous
+
+T1897b.hs:16:1:
+    Could not deduce (Depend a0 ~ Depend a)
+    from the context (Bug a)
+      bound by the inferred type for `isValid':
+                 Bug a => [Depend a] -> Bool
+      at T1897b.hs:16:1-41
+    NB: `Depend' is a type function, and may not be injective
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    Expected type: [Depend a] -> Bool
+      Actual type: [Depend a0] -> Bool
+    When checking that `isValid'
+      has the inferred type `forall a. Bug a => [Depend a] -> Bool'
+    Probable cause: the inferred type is ambiguous

testsuite/tests/indexed-types/should_fail/T1900.stderr

 
 T1900.hs:11:12:
     No instance for (Num ()) arising from a use of `+'
-    Possible fix: add an instance declaration for (Num ())
     In the expression: (+ 1)
     In an equation for `trans': trans = (+ 1)
     In the instance declaration for `Bug Int'
@@ -14,6 +13,9 @@ T1900.hs:14:16:
     NB: `Depend' is a type function, and may not be injective
     The type variable `s0' is ambiguous
     Possible fix: add a type signature that fixes these type variable(s)
+    Relevant bindings include
+      check :: Depend s -> Bool (bound at T1900.hs:14:1)
+      d :: Depend s (bound at T1900.hs:14:7)
     In the return type of a call of `trans'
     In the second argument of `(==)', namely `trans d'
     In the expression: d == trans d

testsuite/tests/indexed-types/should_fail/T2239.stderr

@@ -17,7 +17,7 @@ T2239.hs:47:13:
 
 T2239.hs:50:13:
     Couldn't match type `forall b1. b1 ~ Bool => b1 -> b1'
-                  with `b -> b'
+                  with `Bool -> Bool'
     Expected type: (forall b. b ~ Bool => b -> b) -> b -> b
       Actual type: (forall b. b ~ Bool => b -> b)
                    -> forall b. b ~ Bool => b -> b

testsuite/tests/indexed-types/should_fail/T2544.stderr

 
-T2544.hs:15:12:
-    Could not deduce (IxMap r ~ IxMap i1)
+T2544.hs:15:18:
+    Could not deduce (IxMap i0 ~ IxMap l)
+    from the context (Ix l, Ix r)
+      bound by the instance declaration at T2544.hs:13:10-37
+    NB: `IxMap' is a type function, and may not be injective
+    The type variable `i0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    Expected type: IxMap l [Int]
+      Actual type: IxMap i0 [Int]
+    Relevant bindings include
+      empty :: IxMap (l :|: r) [Int] (bound at T2544.hs:15:4)
+    In the first argument of `BiApp', namely `empty'
+    In the expression: BiApp empty empty
+    In an equation for `empty': empty = BiApp empty empty
+
+T2544.hs:15:24:
+    Could not deduce (IxMap i1 ~ IxMap r)
     from the context (Ix l, Ix r)
       bound by the instance declaration at T2544.hs:13:10-37
     NB: `IxMap' is a type function, and may not be injective
     The type variable `i1' is ambiguous
     Possible fix: add a type signature that fixes these type variable(s)
-    Expected type: IxMap (l :|: r) [Int]
-      Actual type: BiApp (IxMap i0) (IxMap i1) [Int]
-    In the return type of a call of `BiApp'
+    Expected type: IxMap r [Int]
+      Actual type: IxMap i1 [Int]