Follow test output changes

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

 
-annfail10.hs:9:11:
+annfail10.hs:9:1:
     Ambiguous type variable `a' in the constraints:
-      (Num a) arising from the literal `1' at annfail10.hs:9:11
       (Data.Data.Data a) arising from an annotation
                          at annfail10.hs:9:1-15
+      (Num a) arising from the literal `1' at annfail10.hs:9:11
     Probable fix: add a type signature that fixes these type variable(s)
     In the expression: 1
     In the annotation: {-# ANN f 1 #-}

testsuite/tests/ghc-regress/indexed-types/should_compile/T3017.stderr

 TYPE SIGNATURES
     emptyL :: forall a. ListColl a
     test2 :: forall c a a1.
-             (Coll c, Elem c ~ (a, a1), Num a, Num a1) =>
+             (Num a1, Num a, Coll c, Elem c ~ (a, a1)) =>
              c -> c
 TYPE CONSTRUCTORS
     data ListColl a

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

 
-T4179.hs:26:16:
-    Could not deduce (DoC (x (A2 (FCon x) -> A3 (FCon x))))
-      from the context (Functor x, DoC (FCon x))
-      arising from a use of `op'
-    Possible fix:
-      add (DoC (x (A2 (FCon x) -> A3 (FCon x)))) to the context of
-        the type signature for `fCon'
-      or add an instance declaration for
-         (DoC (x (A2 (FCon x) -> A3 (FCon x))))
-    In the first argument of `foldDoC', namely `op'
-    In the expression: foldDoC op
-    In an equation for `fCon': fCon = foldDoC op
-
 T4179.hs:26:16:
     Could not deduce (A2 (x (A2 (FCon x) -> A3 (FCon x)))
                         ~
@@ -37,3 +24,17 @@ T4179.hs:26:16:
     In the first argument of `foldDoC', namely `op'
     In the expression: foldDoC op
     In an equation for `fCon': fCon = foldDoC op
+
+T4179.hs:26:16:
+    Could not deduce (DoC (x (A2 (FCon x) -> A3 (FCon x))))
+      from the context (Functor x, DoC (FCon x))
+      arising from a use of `op'
+    Possible fix:
+      add (DoC (x (A2 (FCon x) -> A3 (FCon x)))) to the context of
+        the type signature for `fCon'
+      or add an instance declaration for
+         (DoC (x (A2 (FCon x) -> A3 (FCon x))))
+    In the first argument of `foldDoC', namely `op'
+    In the expression: foldDoC op
+    In an equation for `fCon': fCon = foldDoC op
+

testsuite/tests/ghc-regress/rebindable/rebindable6.stderr

@@ -6,33 +6,33 @@ rebindable6.hs:106:17:
       add an instance declaration for (HasSeq (IO a -> t -> IO b))
     In a stmt of a 'do' expression: f
     In the expression:
-        do { f;
-             Just (b :: b) <- g;
-             return b }
+      do { f;
+           Just (b :: b) <- g;
+           return b }
     In an equation for `test_do':
         test_do f g
-                  = do { f;
-                         Just (b :: b) <- g;
-                         return b }
+          = do { f;
+                 Just (b :: b) <- g;
+                 return b }
 
 rebindable6.hs:107:17:
-    No instances for (HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t),
-                      HasFail ([Prelude.Char] -> t1))
+    No instances for (HasFail ([Prelude.Char] -> t1),
+                      HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t))
       arising from a do statement
     Possible fix:
       add an instance declaration for
-      (HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t),
-       HasFail ([Prelude.Char] -> t1))
+      (HasFail ([Prelude.Char] -> t1),
+       HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t))
     In a stmt of a 'do' expression: Just (b :: b) <- g
     In the expression:
-        do { f;
-             Just (b :: b) <- g;
-             return b }
+      do { f;
+           Just (b :: b) <- g;
+           return b }
     In an equation for `test_do':
         test_do f g
-                  = do { f;
-                         Just (b :: b) <- g;
-                         return b }
+          = do { f;
+                 Just (b :: b) <- g;
+                 return b }
 
 rebindable6.hs:108:17:
     No instance for (HasReturn (b -> t1))
@@ -41,6 +41,6 @@ rebindable6.hs:108:17:
     In the expression: return b
     In a stmt of a 'do' expression: Just (b :: b) <- g
     In the expression:
-        do { f;
-             Just (b :: b) <- g;
-             return b }
+      do { f;
+           Just (b :: b) <- g;
+           return b }

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

 
 tcfail171.hs:9:10:
-    No instances for (PrintfArg a, PrintfType b)
+    No instances for (PrintfType b, PrintfArg a)
       arising from a use of `printf'
     In the expression: printf "0x%x" x
     In an equation for `phex': phex x = printf "0x%x" x