Accept error message changes

testsuite/tests/ghc-regress/annotations/should_fail/annfail08.stderr

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

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

@@ -2,6 +2,8 @@
 NoMatchErr.hs:20:5:
     Could not deduce (Memo d ~ Memo d1) from the context (Fun d1)
     NB: `Memo' is a type function, and may not be injective
+    Expected type: Memo d1 a
+      Actual type: Memo d a
     In the first argument of `(.)', namely `abst'
     In the expression: abst . appl
     In an equation for `f': f = abst . appl

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

 
-T1900.hs:11:13:
+T1900.hs:11:12:
     No instance for (Num ())
-      arising from the literal `1'
+      arising from a use of `+'
     Possible fix: add an instance declaration for (Num ())
-    In the second argument of `(+)', namely `1'
     In the expression: (+ 1)
     In an equation for `trans': trans = (+ 1)
+    In the instance declaration for `Bug Int'
 
 T1900.hs:14:16:
     Could not deduce (Depend s ~ Depend s1) from the context (Bug s1)

testsuite/tests/ghc-regress/indexed-types/should_fail/T2693.stderr

 
 T2693.hs:10:15:
     Couldn't match type `TFn a' with `(a1, b)'
+    Expected type: (a1, b1)
+      Actual type: TFn a
     In the first argument of `fst', namely `x'
     In the first argument of `(+)', namely `fst x'
     In the expression: fst x + fst x

testsuite/tests/ghc-regress/indexed-types/should_fail/T3330c.stderr

@@ -37,15 +37,15 @@ T3330c.hs:22:45:
       Actual type: R f1
     In the first argument of `plug', namely `rf'
     In the first argument of `Inl', namely `(plug rf df x)'
+    In the expression: Inl (plug rf df x)
 
 T3330c.hs:22:45:
-    Couldn't match type `f' with `f1 x'
-      `f' is a rigid type variable bound by
-          a pattern with constructor
-          RSum :: forall (f :: * -> *) (g :: * -> *).
-                  R f -> R g -> R (f :+: g)
-            at T3330c.hs:22:10
-    Expected type: Der ((->) x) (f1 x)
-      Actual type: R f
+    Couldn't match type `f1' with `f x'
+      `f1' is a rigid type variable bound by
+           a pattern with constructor
+           RSum :: forall (f :: * -> *) (g :: * -> *).
+                   R f -> R g -> R (f :+: g)
+             at T3330c.hs:22:10
     In the first argument of `plug', namely `rf'
     In the first argument of `Inl', namely `(plug rf df x)'
+    In the expression: Inl (plug rf df x)

testsuite/tests/ghc-regress/indexed-types/should_fail/T4093b.stderr

-
-T4093b.hs:25:21:
-    Could not deduce (EitherCO
-                        x (EitherCO e (A C C n) (A O C n)) (A C O n)
-                        ~
-                      (MaybeC e (n C O), MaybeC x (n O C)))
-      from the context (EitherCO e (A C O n) (A O O n) ~ A e O n,
-                        EitherCO x (A C C n) (A C O n) ~ A C x n)
-    In the expression: foldBlockNodesF (f, l) b z
-    In an equation for `blockToNodeList':
-        blockToNodeList b
-          = foldBlockNodesF (f, l) b z
-          where
-              z ::
-                EitherCO e (EitherCO e (A C O n) (A O O n)) (EitherCO e (A C O n) (A O O n))
-              z = undefined
-              f ::
-                n C O
-                -> EitherCO e (A C O n) (A O O n) -> EitherCO e (A C O n) (A O O n)
-              f n _ = (JustC n, NothingC)
-              ....
-
-T4093b.hs:31:13:
-    Couldn't match type `e' with `C'
-      `e' is a rigid type variable bound by
-          the type signature for `blockToNodeList' at T4093b.hs:20:12
-    In the expression: (JustC n, NothingC)
-    In an equation for `f': f n _ = (JustC n, NothingC)
-    In an equation for `blockToNodeList':
-        blockToNodeList b
-          = foldBlockNodesF (f, l) b z
-          where
-              z ::
-                EitherCO e (EitherCO e (A C O n) (A O O n)) (EitherCO e (A C O n) (A O O n))
-              z = undefined
-              f ::
-                n C O
-                -> EitherCO e (A C O n) (A O O n) -> EitherCO e (A C O n) (A O O n)
-              f n _ = (JustC n, NothingC)
-              ....
+
+T4093b.hs:25:21:
+    Could not deduce (EitherCO
+                        x (EitherCO e (A C C n) (A O C n)) (A C O n)
+                        ~
+                      (MaybeC e (n C O), MaybeC x (n O C)))
+      from the context (EitherCO e (A C O n) (A O O n) ~ A e O n,
+                        EitherCO x (A C C n) (A C O n) ~ A C x n)
+    Expected type: (MaybeC e (n C O), MaybeC x (n O C))
+      Actual type: EitherCO
+                     x (EitherCO e (A C C n) (A O C n)) (EitherCO e (A C O n) (A O O n))
+    In the expression: foldBlockNodesF (f, l) b z
+    In an equation for `blockToNodeList':
+        blockToNodeList b
+          = foldBlockNodesF (f, l) b z
+          where
+              z ::
+                EitherCO e (EitherCO e (A C O n) (A O O n)) (EitherCO e (A C O n) (A O O n))
+              z = undefined
+              f ::
+                n C O
+                -> EitherCO e (A C O n) (A O O n) -> EitherCO e (A C O n) (A O O n)
+              f n _ = (JustC n, NothingC)
+              ....
+
+T4093b.hs:31:13:
+    Couldn't match type `e' with `C'
+      `e' is a rigid type variable bound by
+          the type signature for `blockToNodeList' at T4093b.hs:20:12
+    In the expression: (JustC n, NothingC)
+    In an equation for `f': f n _ = (JustC n, NothingC)
+    In an equation for `blockToNodeList':
+        blockToNodeList b
+          = foldBlockNodesF (f, l) b z
+          where
+              z ::
+                EitherCO e (EitherCO e (A C O n) (A O O n)) (EitherCO e (A C O n) (A O O n))
+              z = undefined
+              f ::
+                n C O
+                -> EitherCO e (A C O n) (A O O n) -> EitherCO e (A C O n) (A O O n)
+              f n _ = (JustC n, NothingC)
+              ....

testsuite/tests/ghc-regress/indexed-types/should_fail/T4272.hs

@@ -14,7 +14,8 @@ prune :: TermLike a => TermFamily a a -> TermFamily a a -> b
 prune = undefined  
 
 -- terms :: Family f => f a -> a
--- terms :: TermFamily a a -> a
+--    Instantiate with f = TermFamily a
+-- terms :: Family (TermFamily a) => TermFamily a a -> a
 -- (terms (undefined::TermFamily a a) :: Family (TermFamily a) => a
 -- So the call to prune forces the equality
 --    TermFamily a a ~ a

testsuite/tests/ghc-regress/indexed-types/should_fail/T4272.stderr

@@ -2,8 +2,10 @@
 T4272.hs:11:26:
     Occurs check: cannot construct the infinite type:
       a = TermFamily a a
+      Expected type: TermFamily a (TermFamily a a)
+        Actual type: TermFamily a a
     In the first argument of `terms', namely
-        `(undefined :: TermFamily a a)'
+      `(undefined :: TermFamily a a)'
     In the second argument of `prune', namely
-        `(terms (undefined :: TermFamily a a))'
+      `(terms (undefined :: TermFamily a a))'
     In the expression: prune t (terms (undefined :: TermFamily a a))

testsuite/tests/ghc-regress/indexed-types/should_fail/all.T

@@ -56,7 +56,7 @@ test('T4272', normal, compile_fail, [''])
 test('T4246', normal, compile_fail, [''])
 test('T4093a', normal, compile_fail, [''])
 test('T4093b', normal, compile_fail, [''])
-test('T3330a', normal, compile_fail, [''])
+test('T3330a', reqlib('mtl'), compile_fail, [''])
 test('T3330b', normal, compile_fail, [''])
 test('T3330c', normal, compile_fail, [''])
 

testsuite/tests/ghc-regress/mdo/should_fail/mdofail001.stderr

 
-mdofail001.hs:10:36:
+mdofail001.hs:10:32:
     No instance for (Num Char)
-      arising from the literal `3'
+      arising from the literal `1'
     Possible fix: add an instance declaration for (Num Char)
-    In the expression: 3
+    In the expression: 1
     In the first argument of `l', namely `[1, 2, 3]'
     In the expression: l [1, 2, 3]

testsuite/tests/ghc-regress/typecheck/should_compile/FD3.stderr

 
 FD3.hs:15:15:
-    Occurs check: cannot construct the infinite type: a = (String, a)
+    Occurs check: cannot construct the infinite type:
+      a = (String, a)
+      arising from a use of `mkA'
     In the expression: mkA a
     In an equation for `translate': translate a = mkA a

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail006.stderr

 
-tcfail006.hs:5:20:
+tcfail006.hs:4:24:
     No instance for (Num Bool)
       arising from the literal `1'
     Possible fix: add an instance declaration for (Num Bool)
     In the expression: 1
-    In the expression: (1, True)
-    In a case alternative: False -> (1, True)
+    In the expression: (True, 1)
+    In a case alternative: True -> (True, 1)

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail007.stderr

 
-tcfail007.hs:3:16:
+tcfail007.hs:3:15:
     No instance for (Num Bool)
-      arising from the literal `1'
+      arising from a use of `+'
     Possible fix: add an instance declaration for (Num Bool)
-    In the second argument of `(+)', namely `1'
     In the expression: x + 1
     In an equation for `n':
-        n x | True = x + 1
-            | False = True
+        n x
+          | True = x + 1
+          | False = True

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail010.stderr

 
-tcfail010.hs:3:18:
+tcfail010.hs:3:17:
     No instance for (Num [t])
-      arising from the literal `2'
+      arising from a use of `+'
     Possible fix: add an instance declaration for (Num [t])
-    In the second argument of `(+)', namely `2'
     In the expression: z + 2
     In the expression: \ (y : z) -> z + 2
+    In an equation for `q': q = \ (y : z) -> z + 2

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail015.stderr

 
-tcfail015.hs:9:39:
+tcfail015.hs:7:13:
     No instance for (Num Bool)
-      arising from the literal `4'
+      arising from the literal `2'
     Possible fix: add an instance declaration for (Num Bool)
-    In the expression: 4
-    In an equation for `g':
-        g (ANode b (ANode c d))
-            | b = c + 1
-            | otherwise = 4
+    In the expression: 2
+    In an equation for `g': g (ANull) = 2

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail040.stderr

 
-tcfail040.hs:19:14:
+tcfail040.hs:19:5:
     Ambiguous type variable `a' in the constraint:
       (ORD a) arising from a use of `<<'
     Probable fix: add a type signature that fixes these type variable(s)
-    In the second argument of `(===)', namely `(<<)'
+    In the first argument of `(===)', namely `(<<)'
     In the expression: (<<) === (<<)
     In an equation for `f': f = (<<) === (<<)

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail102.stderr

 
-tcfail102.hs:8:7:
+tcfail102.hs:8:15:
     Could not deduce (Integral (Ratio a)) from the context (Integral a)
-      arising from a record update
+      arising from a use of `p'
     Possible fix:
       add (Integral (Ratio a)) to the context of
         the type signature for `f'
       or add an instance declaration for (Integral (Ratio a))
+    In the `p' field of a record
     In the expression: x {p = p x}
     In an equation for `f': f x = x {p = p x}

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail122.stderr

@@ -3,11 +3,28 @@ tcfail122.hs:8:9:
     Kind incompatibility when matching types:
       c :: (* -> *) -> *
       a :: * -> *
+    Expected type: a b
+      Actual type: c d
     In the expression:
-          undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d
+        undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d
     In the expression:
-        [undefined :: forall a b. a b,
-         undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d]
+      [undefined :: forall a b. a b,
+       undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d]
     In an equation for `foo':
-        foo = [undefined :: forall a b. a b,
-               undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d]
+        foo
+          = [undefined :: forall a b. a b,
+             undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d]
+
+tcfail122.hs:8:9:
+    Kind incompatibility when matching types:
+      d :: * -> *
+      b :: *
+    In the expression:
+        undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d
+    In the expression:
+      [undefined :: forall a b. a b,
+       undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d]
+    In an equation for `foo':
+        foo
+          = [undefined :: forall a b. a b,
+             undefined :: forall c :: ((* -> *) -> *) d :: (* -> *). c d]

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail123.stderr

@@ -6,3 +6,11 @@ tcfail123.hs:11:10:
     In the first argument of `f', namely `3#'
     In the expression: f 3#
     In the expression: (f 3#, f 4.3#, f True)
+
+tcfail123.hs:11:16:
+    Kind incompatibility when matching types:
+      t :: *
+      GHC.Prim.Float# :: #
+    In the first argument of `f', namely `4.3#'
+    In the expression: f 4.3#
+    In the expression: (f 3#, f 4.3#, f True)

testsuite/tests/ghc-regress/typecheck/should_fail/tcfail143.stderr

 
 tcfail143.hs:28:9:
     Couldn't match type `S Z' with `Z'
+    arising from a use of `extend'
     In the expression: n1 `extend` n0
     In an equation for `t2': t2 = n1 `extend` n0