Testsuite: remove Windows CR [skip ci]

37 files changed, 796 insertions, 796 deletions

diff --git a/testsuite/tests/arrows/should_fail/T5380.stderr b/testsuite/tests/arrows/should_fail/T5380.stderr
index 6c7caf789d..8b1c81af99 100644
--- a/testsuite/tests/arrows/should_fail/T5380.stderr
+++ b/testsuite/tests/arrows/should_fail/T5380.stderr
@@ -1,32 +1,32 @@
-

-T5380.hs:7:27: error:

-    • Couldn't match expected type ‘Bool’ with actual type ‘not_bool’

-      ‘not_bool’ is a rigid type variable bound by

-        the type signature for:

-          testB :: forall not_bool not_unit.

-                   not_bool -> (() -> ()) -> () -> not_unit

-        at T5380.hs:6:1-49

-    • 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 -< ()

-    • Relevant bindings include

-        b :: not_bool (bound at T5380.hs:7:7)

-        testB :: not_bool -> (() -> ()) -> () -> not_unit

-          (bound at T5380.hs:7:1)

-

-T5380.hs:7:34: error:

-    • Couldn't match type ‘not_unit’ with ‘()’

-      ‘not_unit’ is a rigid type variable bound by

-        the type signature for:

-          testB :: forall not_bool not_unit.

-                   not_bool -> (() -> ()) -> () -> not_unit

-        at T5380.hs:6:1-49

-      Expected type: () -> not_unit

-        Actual type: () -> ()

-    • In the expression: f

-      In the command: f -< ()

-      In the expression: proc () -> if b then f -< () else f -< ()

-    • Relevant bindings include

-        testB :: not_bool -> (() -> ()) -> () -> not_unit

-          (bound at T5380.hs:7:1)

+
+T5380.hs:7:27: error:
+    • Couldn't match expected type ‘Bool’ with actual type ‘not_bool’
+      ‘not_bool’ is a rigid type variable bound by
+        the type signature for:
+          testB :: forall not_bool not_unit.
+                   not_bool -> (() -> ()) -> () -> not_unit
+        at T5380.hs:6:1-49
+    • 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 -< ()
+    • Relevant bindings include
+        b :: not_bool (bound at T5380.hs:7:7)
+        testB :: not_bool -> (() -> ()) -> () -> not_unit
+          (bound at T5380.hs:7:1)
+
+T5380.hs:7:34: error:
+    • Couldn't match type ‘not_unit’ with ‘()’
+      ‘not_unit’ is a rigid type variable bound by
+        the type signature for:
+          testB :: forall not_bool not_unit.
+                   not_bool -> (() -> ()) -> () -> not_unit
+        at T5380.hs:6:1-49
+      Expected type: () -> not_unit
+        Actual type: () -> ()
+    • In the expression: f
+      In the command: f -< ()
+      In the expression: proc () -> if b then f -< () else f -< ()
+    • Relevant bindings include
+        testB :: not_bool -> (() -> ()) -> () -> not_unit
+          (bound at T5380.hs:7:1)
diff --git a/testsuite/tests/dependent/should_compile/T11241.stderr b/testsuite/tests/dependent/should_compile/T11241.stderr
index fe80b47c3c..97b2a33cf2 100644
--- a/testsuite/tests/dependent/should_compile/T11241.stderr
+++ b/testsuite/tests/dependent/should_compile/T11241.stderr
@@ -1,4 +1,4 @@
-

-T11241.hs:5:21: warning: [-Wpartial-type-signatures (in -Wdefault)]

-    • Found type wildcard ‘_’ standing for ‘*’

-    • In the type signature: foo :: forall (a :: _). a -> a

+
+T11241.hs:5:21: warning: [-Wpartial-type-signatures (in -Wdefault)]
+    • Found type wildcard ‘_’ standing for ‘*’
+    • In the type signature: foo :: forall (a :: _). a -> a
diff --git a/testsuite/tests/deriving/should_fail/T7148.stderr b/testsuite/tests/deriving/should_fail/T7148.stderr
index a9314f9d64..da07d4f49d 100644
--- a/testsuite/tests/deriving/should_fail/T7148.stderr
+++ b/testsuite/tests/deriving/should_fail/T7148.stderr
@@ -1,18 +1,18 @@
-

-T7148.hs:27:40: error:

-    • Couldn't match type ‘b’ with ‘Tagged a b’

-        arising from the coercion of the method ‘iso2’

-          from type ‘forall b. SameType b () -> SameType b b’

-            to type ‘forall b. SameType b () -> SameType b (Tagged a b)’

-      ‘b’ is a rigid type variable bound by

-        the deriving clause for ‘IsoUnit (Tagged a b)’ at T7148.hs:27:40-46

-    • When deriving the instance for (IsoUnit (Tagged a b))

-

-T7148.hs:27:40: error:

-    • Couldn't match type ‘b’ with ‘Tagged a b’

-        arising from the coercion of the method ‘iso1’

-          from type ‘forall b. SameType () b -> SameType b b’

-            to type ‘forall b. SameType () b -> SameType (Tagged a b) b’

-      ‘b’ is a rigid type variable bound by

-        the deriving clause for ‘IsoUnit (Tagged a b)’ at T7148.hs:27:40-46

-    • When deriving the instance for (IsoUnit (Tagged a b))

+
+T7148.hs:27:40: error:
+    • Couldn't match type ‘b’ with ‘Tagged a b’
+        arising from the coercion of the method ‘iso2’
+          from type ‘forall b. SameType b () -> SameType b b’
+            to type ‘forall b. SameType b () -> SameType b (Tagged a b)’
+      ‘b’ is a rigid type variable bound by
+        the deriving clause for ‘IsoUnit (Tagged a b)’ at T7148.hs:27:40-46
+    • When deriving the instance for (IsoUnit (Tagged a b))
+
+T7148.hs:27:40: error:
+    • Couldn't match type ‘b’ with ‘Tagged a b’
+        arising from the coercion of the method ‘iso1’
+          from type ‘forall b. SameType () b -> SameType b b’
+            to type ‘forall b. SameType () b -> SameType (Tagged a b) b’
+      ‘b’ is a rigid type variable bound by
+        the deriving clause for ‘IsoUnit (Tagged a b)’ at T7148.hs:27:40-46
+    • When deriving the instance for (IsoUnit (Tagged a b))
diff --git a/testsuite/tests/deriving/should_fail/T7148a.stderr b/testsuite/tests/deriving/should_fail/T7148a.stderr
index cd1e4db351..b0f5cbfb68 100644
--- a/testsuite/tests/deriving/should_fail/T7148a.stderr
+++ b/testsuite/tests/deriving/should_fail/T7148a.stderr
@@ -1,11 +1,11 @@
-

-T7148a.hs:19:50: error:

-    • Couldn't match representation of type ‘b’

-                               with that of ‘Result a b’

-        arising from the coercion of the method ‘coerce’

-          from type ‘forall b. Proxy b -> a -> Result a b’

-            to type ‘forall b.

-                     Proxy b -> IS_NO_LONGER a -> Result (IS_NO_LONGER a) b’

-      ‘b’ is a rigid type variable bound by

-        the type Proxy b -> a -> Result a b at T7148a.hs:19:50-56

-    • When deriving the instance for (Convert (IS_NO_LONGER a))

+
+T7148a.hs:19:50: error:
+    • Couldn't match representation of type ‘b’
+                               with that of ‘Result a b’
+        arising from the coercion of the method ‘coerce’
+          from type ‘forall b. Proxy b -> a -> Result a b’
+            to type ‘forall b.
+                     Proxy b -> IS_NO_LONGER a -> Result (IS_NO_LONGER a) b’
+      ‘b’ is a rigid type variable bound by
+        the type Proxy b -> a -> Result a b at T7148a.hs:19:50-56
+    • When deriving the instance for (Convert (IS_NO_LONGER a))
diff --git a/testsuite/tests/gadt/T3169.stderr b/testsuite/tests/gadt/T3169.stderr
index 433333f21d..4bc39a731b 100644
--- a/testsuite/tests/gadt/T3169.stderr
+++ b/testsuite/tests/gadt/T3169.stderr
@@ -1,19 +1,19 @@
-

-T3169.hs:13:22: error:

-    • Couldn't match type ‘elt’ with ‘Map b elt’

-      ‘elt’ is a rigid type variable bound by

-        the type signature for:

-          lookup :: forall elt. (a, b) -> Map (a, b) elt -> Maybe elt

-        at T3169.hs:12:3-8

-      Expected type: Map a (Map b elt)

-        Actual type: Map (a, b) elt

-    • In the second argument of ‘lookup’, namely ‘m’

-      In the expression: lookup a m :: Maybe (Map b elt)

-      In the expression:

-        case lookup a m :: Maybe (Map b elt) of {

-          Just (m2 :: Map b elt) -> lookup b m2 :: Maybe elt }

-    • Relevant bindings include

-        m :: Map (a, b) elt (bound at T3169.hs:12:17)

-        b :: b (bound at T3169.hs:12:13)

-        lookup :: (a, b) -> Map (a, b) elt -> Maybe elt

-          (bound at T3169.hs:12:3)

+
+T3169.hs:13:22: error:
+    • Couldn't match type ‘elt’ with ‘Map b elt’
+      ‘elt’ is a rigid type variable bound by
+        the type signature for:
+          lookup :: forall elt. (a, b) -> Map (a, b) elt -> Maybe elt
+        at T3169.hs:12:3-8
+      Expected type: Map a (Map b elt)
+        Actual type: Map (a, b) elt
+    • In the second argument of ‘lookup’, namely ‘m’
+      In the expression: lookup a m :: Maybe (Map b elt)
+      In the expression:
+        case lookup a m :: Maybe (Map b elt) of {
+          Just (m2 :: Map b elt) -> lookup b m2 :: Maybe elt }
+    • Relevant bindings include
+        m :: Map (a, b) elt (bound at T3169.hs:12:17)
+        b :: b (bound at T3169.hs:12:13)
+        lookup :: (a, b) -> Map (a, b) elt -> Maybe elt
+          (bound at T3169.hs:12:3)
diff --git a/testsuite/tests/gadt/T7558.stderr b/testsuite/tests/gadt/T7558.stderr
index 34ade9778e..ff90037ff6 100644
--- a/testsuite/tests/gadt/T7558.stderr
+++ b/testsuite/tests/gadt/T7558.stderr
@@ -1,15 +1,15 @@
-

-T7558.hs:8:4: error:

-    • Couldn't match type ‘a’ with ‘Maybe a’

-      ‘a’ is a rigid type variable bound by

-        the type signature for:

-          f :: forall a. T a a -> Bool

-        at T7558.hs:7:1-18

-      Inaccessible code in

-        a pattern with constructor:

-          MkT :: forall a b. a ~ Maybe b => a -> Maybe b -> T a b,

-        in an equation for ‘f’

-    • In the pattern: MkT x y

-      In an equation for ‘f’: f (MkT x y) = [x, y] `seq` True

-    • Relevant bindings include

-        f :: T a a -> Bool (bound at T7558.hs:8:1)

+
+T7558.hs:8:4: error:
+    • Couldn't match type ‘a’ with ‘Maybe a’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          f :: forall a. T a a -> Bool
+        at T7558.hs:7:1-18
+      Inaccessible code in
+        a pattern with constructor:
+          MkT :: forall a b. a ~ Maybe b => a -> Maybe b -> T a b,
+        in an equation for ‘f’
+    • In the pattern: MkT x y
+      In an equation for ‘f’: f (MkT x y) = [x, y] `seq` True
+    • Relevant bindings include
+        f :: T a a -> Bool (bound at T7558.hs:8:1)
diff --git a/testsuite/tests/gadt/gadt-escape1.stderr b/testsuite/tests/gadt/gadt-escape1.stderr
index ccd428f106..056d451a09 100644
--- a/testsuite/tests/gadt/gadt-escape1.stderr
+++ b/testsuite/tests/gadt/gadt-escape1.stderr
@@ -1,19 +1,19 @@
-

-gadt-escape1.hs:19:58: error:

-    • Couldn't match type ‘t’ with ‘ExpGADT Int’

-        ‘t’ is untouchable

-          inside the constraints: t1 ~ Int

-          bound by a pattern with constructor: ExpInt :: Int -> ExpGADT Int,

-                   in a case alternative

-          at gadt-escape1.hs:19:43-50

-      ‘t’ is a rigid type variable bound by

-        the inferred type of weird1 :: t at gadt-escape1.hs:19:1-58

-      Possible fix: add a type signature for ‘weird1’

-      Expected type: t

-        Actual type: ExpGADT t1

-    • In the expression: a

-      In a case alternative: Hidden (ExpInt _) a -> a

-      In the expression:

-        case (hval :: Hidden) of { Hidden (ExpInt _) a -> a }

-    • Relevant bindings include

-        weird1 :: t (bound at gadt-escape1.hs:19:1)

+
+gadt-escape1.hs:19:58: error:
+    • Couldn't match type ‘t’ with ‘ExpGADT Int’
+        ‘t’ is untouchable
+          inside the constraints: t1 ~ Int
+          bound by a pattern with constructor: ExpInt :: Int -> ExpGADT Int,
+                   in a case alternative
+          at gadt-escape1.hs:19:43-50
+      ‘t’ is a rigid type variable bound by
+        the inferred type of weird1 :: t at gadt-escape1.hs:19:1-58
+      Possible fix: add a type signature for ‘weird1’
+      Expected type: t
+        Actual type: ExpGADT t1
+    • In the expression: a
+      In a case alternative: Hidden (ExpInt _) a -> a
+      In the expression:
+        case (hval :: Hidden) of { Hidden (ExpInt _) a -> a }
+    • Relevant bindings include
+        weird1 :: t (bound at gadt-escape1.hs:19:1)
diff --git a/testsuite/tests/gadt/rw.stderr b/testsuite/tests/gadt/rw.stderr
index 4c53ff2aa1..067595f2d7 100644
--- a/testsuite/tests/gadt/rw.stderr
+++ b/testsuite/tests/gadt/rw.stderr
@@ -1,30 +1,30 @@
-

-rw.hs:14:47: error:

-    • Couldn't match expected type ‘a’ with actual type ‘Int’

-      ‘a’ is a rigid type variable bound by

-        the type signature for:

-          writeInt :: forall a. T a -> IORef a -> IO ()

-        at rw.hs:12:1-34

-    • 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)

-    • Relevant bindings include

-        ref :: IORef a (bound at rw.hs:13:12)

-        v :: T a (bound at rw.hs:13:10)

-        writeInt :: T a -> IORef a -> IO () (bound at rw.hs:13:1)

-

-rw.hs:19:43: error:

-    • Couldn't match type ‘a’ with ‘Bool’

-      ‘a’ is a rigid type variable bound by

-        the type signature for:

-          readBool :: forall a. T a -> IORef a -> IO ()

-        at rw.hs:16:1-34

-      Expected type: a -> IO ()

-        Actual type: Bool -> IO ()

-    • In the second argument of ‘(>>=)’, namely ‘(print . not)’

-      In the expression: readIORef ref >>= (print . not)

-      In a case alternative: ~(Lb x) -> readIORef ref >>= (print . not)

-    • Relevant bindings include

-        ref :: IORef a (bound at rw.hs:17:12)

-        v :: T a (bound at rw.hs:17:10)

-        readBool :: T a -> IORef a -> IO () (bound at rw.hs:17:1)

+
+rw.hs:14:47: error:
+    • Couldn't match expected type ‘a’ with actual type ‘Int’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          writeInt :: forall a. T a -> IORef a -> IO ()
+        at rw.hs:12:1-34
+    • 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)
+    • Relevant bindings include
+        ref :: IORef a (bound at rw.hs:13:12)
+        v :: T a (bound at rw.hs:13:10)
+        writeInt :: T a -> IORef a -> IO () (bound at rw.hs:13:1)
+
+rw.hs:19:43: error:
+    • Couldn't match type ‘a’ with ‘Bool’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          readBool :: forall a. T a -> IORef a -> IO ()
+        at rw.hs:16:1-34
+      Expected type: a -> IO ()
+        Actual type: Bool -> IO ()
+    • In the second argument of ‘(>>=)’, namely ‘(print . not)’
+      In the expression: readIORef ref >>= (print . not)
+      In a case alternative: ~(Lb x) -> readIORef ref >>= (print . not)
+    • Relevant bindings include
+        ref :: IORef a (bound at rw.hs:17:12)
+        v :: T a (bound at rw.hs:17:10)
+        readBool :: T a -> IORef a -> IO () (bound at rw.hs:17:1)
diff --git a/testsuite/tests/ghc-api/landmines/landmines.stdout b/testsuite/tests/ghc-api/landmines/landmines.stdout
index 39d6acc353..61ddb374a7 100644
--- a/testsuite/tests/ghc-api/landmines/landmines.stdout
+++ b/testsuite/tests/ghc-api/landmines/landmines.stdout
@@ -1,4 +1,4 @@
-(12,12,8)

-(93,63,0)

-(15,13,8)

-(10,10,8)

+(12,12,8)
+(93,63,0)
+(15,13,8)
+(10,10,8)
diff --git a/testsuite/tests/ghci/linking/dyn/T11072gcc.stdout b/testsuite/tests/ghci/linking/dyn/T11072gcc.stdout
index 78c6baefdd..0cfbf08886 100644
--- a/testsuite/tests/ghci/linking/dyn/T11072gcc.stdout
+++ b/testsuite/tests/ghci/linking/dyn/T11072gcc.stdout
@@ -1 +1 @@
-2

+2
diff --git a/testsuite/tests/ghci/linking/dyn/T11072msvc.stdout b/testsuite/tests/ghci/linking/dyn/T11072msvc.stdout
index 78c6baefdd..0cfbf08886 100644
--- a/testsuite/tests/ghci/linking/dyn/T11072msvc.stdout
+++ b/testsuite/tests/ghci/linking/dyn/T11072msvc.stdout
@@ -1 +1 @@
-2

+2
diff --git a/testsuite/tests/ghci/scripts/Defer02.stderr b/testsuite/tests/ghci/scripts/Defer02.stderr
index f845b63fd2..f4830894b5 100644
--- a/testsuite/tests/ghci/scripts/Defer02.stderr
+++ b/testsuite/tests/ghci/scripts/Defer02.stderr
@@ -1,197 +1,197 @@
-

-Defer01.hs:11:40: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Couldn't match type ‘Char’ with ‘[Char]’

-      Expected type: String

-        Actual type: Char

-    • In the first argument of ‘putStr’, namely ‘','’

-      In the second argument of ‘(>>)’, namely ‘putStr ','’

-      In the expression: putStr "Hello World" >> putStr ','

-

-Defer01.hs:14:5: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Couldn't match expected type ‘Int’ with actual type ‘Char’

-    • In the expression: 'p'

-      In an equation for ‘a’: a = 'p'

-

-Defer01.hs:18:7: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • No instance for (Eq B) arising from a use of ‘==’

-    • In the expression: x == x

-      In an equation for ‘b’: b x = x == x

-

-Defer01.hs:25:1: warning: [-Woverlapping-patterns (in -Wdefault)]

-    Pattern match has inaccessible right hand side

-    In an equation for ‘c’: c (C2 x) = ...

-

-Defer01.hs:25:4: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Couldn't match type ‘Int’ with ‘Bool’

-      Inaccessible code in

-        a pattern with constructor: C2 :: Bool -> C Bool,

-        in an equation for ‘c’

-    • In the pattern: C2 x

-      In an equation for ‘c’: c (C2 x) = True

-

-Defer01.hs:28:5: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • No instance for (Num (a -> a)) arising from the literal ‘1’

-        (maybe you haven't applied a function to enough arguments?)

-    • In the expression: 1

-      In an equation for ‘d’: d = 1

-

-Defer01.hs:31:5: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Couldn't match expected type ‘Char -> t’ with actual type ‘Char’

-    • The function ‘e’ is applied to one argument,

-      but its type ‘Char’ has none

-      In the expression: e 'q'

-      In an equation for ‘f’: f = e 'q'

-    • Relevant bindings include

-        f :: t (bound at Defer01.hs:31:1)

-

-Defer01.hs:34:8: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Couldn't match expected type ‘Char’ with actual type ‘a’

-      ‘a’ is a rigid type variable bound by

-        the type signature for:

-          h :: forall a. a -> (Char, Char)

-        at Defer01.hs:33:1-21

-    • In the expression: x

-      In the expression: (x, 'c')

-      In an equation for ‘h’: h x = (x, 'c')

-    • Relevant bindings include

-        x :: a (bound at Defer01.hs:34:3)

-        h :: a -> (Char, Char)

-          (bound at Defer01.hs:34:1)

-

-Defer01.hs:39:17: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Couldn't match expected type ‘Bool’ with actual type ‘T a’

-    • In the first argument of ‘not’, namely ‘(K a)’

-      In the expression: (not (K a))

-      In the expression: seq (not (K a)) ()

-    • Relevant bindings include

-        a :: a (bound at Defer01.hs:39:3)

-        i :: a -> () (bound at Defer01.hs:39:1)

-

-Defer01.hs:43:5: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • No instance for (MyClass a1) arising from a use of ‘myOp’

-    • In the expression: myOp 23

-      In an equation for ‘j’: j = myOp 23

-

-Defer01.hs:43:10: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Ambiguous type variable ‘a1’ arising from the literal ‘23’

-      prevents the constraint ‘(Num a1)’ from being solved.

-      Probable fix: use a type annotation to specify what ‘a1’ should be.

-      These potential instances exist:

-        instance Num Integer -- Defined in ‘GHC.Num’

-        instance Num Double -- Defined in ‘GHC.Float’

-        instance Num Float -- Defined in ‘GHC.Float’

-        ...plus two others

-        (use -fprint-potential-instances to see them all)

-    • In the first argument of ‘myOp’, namely ‘23’

-      In the expression: myOp 23

-      In an equation for ‘j’: j = myOp 23

-

-Defer01.hs:45:1: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    Couldn't match type ‘Int’ with ‘Bool’

-    Inaccessible code in

-      the type signature for:

-        k :: Int ~ Bool => Int -> Bool

-

-Defer01.hs:45:6: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Couldn't match type ‘Int’ with ‘Bool’

-      Inaccessible code in

-        the type signature for:

-          k :: Int ~ Bool => Int -> Bool

-    • In the ambiguity check for ‘k’

-      To defer the ambiguity check to use sites, enable AllowAmbiguousTypes

-      In the type signature: k :: (Int ~ Bool) => Int -> Bool

-

-Defer01.hs:46:1: warning: [-Woverlapping-patterns (in -Wdefault)]

-    Pattern match is redundant

-    In an equation for ‘k’: k x = ...

-

-Defer01.hs:49:5: warning: [-Wdeferred-type-errors (in -Wdefault)]

-    • Couldn't match expected type ‘IO a0’

-                  with actual type ‘Char -> IO ()’

-    • Probable cause: ‘putChar’ is applied to too few arguments

-      In the first argument of ‘(>>)’, namely ‘putChar’

-      In the expression: putChar >> putChar 'p'

-      In an equation for ‘l’: l = putChar >> putChar 'p'

-*** Exception: Defer01.hs:11:40: error:

-    • Couldn't match type ‘Char’ with ‘[Char]’

-      Expected type: String

-        Actual type: Char

-    • In the first argument of ‘putStr’, namely ‘','’

-      In the second argument of ‘(>>)’, namely ‘putStr ','’

-      In the expression: putStr "Hello World" >> putStr ','

-(deferred type error)

-*** Exception: Defer01.hs:14:5: error:

-    • Couldn't match expected type ‘Int’ with actual type ‘Char’

-    • In the expression: 'p'

-      In an equation for ‘a’: a = 'p'

-(deferred type error)

-*** Exception: Defer01.hs:18:7: error:

-    • No instance for (Eq B) arising from a use of ‘==’

-    • In the expression: x == x

-      In an equation for ‘b’: b x = x == x

-(deferred type error)

-

-<interactive>:7:11: error:

-    • Couldn't match type ‘Bool’ with ‘Int’

-      Expected type: C Int

-        Actual type: C Bool

-    • In the first argument of ‘c’, namely ‘(C2 True)’

-      In the first argument of ‘print’, namely ‘(c (C2 True))’

-      In the expression: print (c (C2 True))

-*** Exception: Defer01.hs:28:5: error:

-    • No instance for (Num (a -> a)) arising from the literal ‘1’

-        (maybe you haven't applied a function to enough arguments?)

-    • In the expression: 1

-      In an equation for ‘d’: d = 1

-(deferred type error)

-*** Exception: Defer01.hs:31:5: error:

-    • Couldn't match expected type ‘Char -> t’ with actual type ‘Char’

-    • The function ‘e’ is applied to one argument,

-      but its type ‘Char’ has none

-      In the expression: e 'q'

-      In an equation for ‘f’: f = e 'q'

-    • Relevant bindings include

-        f :: t (bound at Defer01.hs:31:1)

-(deferred type error)

-*** Exception: Defer01.hs:34:8: error:

-    • Couldn't match expected type ‘Char’ with actual type ‘a’

-      ‘a’ is a rigid type variable bound by

-        the type signature for:

-          h :: forall a. a -> (Char, Char)

-        at Defer01.hs:33:1-21

-    • In the expression: x

-      In the expression: (x, 'c')

-      In an equation for ‘h’: h x = (x, 'c')

-    • Relevant bindings include

-        x :: a (bound at Defer01.hs:34:3)

-        h :: a -> (Char, Char)

-          (bound at Defer01.hs:34:1)

-(deferred type error)

-*** Exception: Defer01.hs:39:17: error:

-    • Couldn't match expected type ‘Bool’ with actual type ‘T a’

-    • In the first argument of ‘not’, namely ‘(K a)’

-      In the expression: (not (K a))

-      In the expression: seq (not (K a)) ()

-    • Relevant bindings include

-        a :: a (bound at Defer01.hs:39:3)

-        i :: a -> () (bound at Defer01.hs:39:1)

-(deferred type error)

-*** Exception: Defer01.hs:43:5: error:

-    • No instance for (MyClass a1) arising from a use of ‘myOp’

-    • In the expression: myOp 23

-      In an equation for ‘j’: j = myOp 23

-(deferred type error)

-

-<interactive>:13:8: error:

-    • Couldn't match type ‘Int’ with ‘Bool’ arising from a use of ‘k’

-    • In the first argument of ‘print’, namely ‘(k 2)’

-      In the expression: print (k 2)

-      In an equation for ‘it’: it = print (k 2)

-*** Exception: Defer01.hs:49:5: error:

-    • Couldn't match expected type ‘IO a0’

-                  with actual type ‘Char -> IO ()’

-    • Probable cause: ‘putChar’ is applied to too few arguments

-      In the first argument of ‘(>>)’, namely ‘putChar’

-      In the expression: putChar >> putChar 'p'

-      In an equation for ‘l’: l = putChar >> putChar 'p'

-(deferred type error)

+
+Defer01.hs:11:40: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match type ‘Char’ with ‘[Char]’
+      Expected type: String
+        Actual type: Char
+    • In the first argument of ‘putStr’, namely ‘','’
+      In the second argument of ‘(>>)’, namely ‘putStr ','’
+      In the expression: putStr "Hello World" >> putStr ','
+
+Defer01.hs:14:5: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match expected type ‘Int’ with actual type ‘Char’
+    • In the expression: 'p'
+      In an equation for ‘a’: a = 'p'
+
+Defer01.hs:18:7: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • No instance for (Eq B) arising from a use of ‘==’
+    • In the expression: x == x
+      In an equation for ‘b’: b x = x == x
+
+Defer01.hs:25:1: warning: [-Woverlapping-patterns (in -Wdefault)]
+    Pattern match has inaccessible right hand side
+    In an equation for ‘c’: c (C2 x) = ...
+
+Defer01.hs:25:4: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match type ‘Int’ with ‘Bool’
+      Inaccessible code in
+        a pattern with constructor: C2 :: Bool -> C Bool,
+        in an equation for ‘c’
+    • In the pattern: C2 x
+      In an equation for ‘c’: c (C2 x) = True
+
+Defer01.hs:28:5: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • No instance for (Num (a -> a)) arising from the literal ‘1’
+        (maybe you haven't applied a function to enough arguments?)
+    • In the expression: 1
+      In an equation for ‘d’: d = 1
+
+Defer01.hs:31:5: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match expected type ‘Char -> t’ with actual type ‘Char’
+    • The function ‘e’ is applied to one argument,
+      but its type ‘Char’ has none
+      In the expression: e 'q'
+      In an equation for ‘f’: f = e 'q'
+    • Relevant bindings include
+        f :: t (bound at Defer01.hs:31:1)
+
+Defer01.hs:34:8: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match expected type ‘Char’ with actual type ‘a’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          h :: forall a. a -> (Char, Char)
+        at Defer01.hs:33:1-21
+    • In the expression: x
+      In the expression: (x, 'c')
+      In an equation for ‘h’: h x = (x, 'c')
+    • Relevant bindings include
+        x :: a (bound at Defer01.hs:34:3)
+        h :: a -> (Char, Char)
+          (bound at Defer01.hs:34:1)
+
+Defer01.hs:39:17: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match expected type ‘Bool’ with actual type ‘T a’
+    • In the first argument of ‘not’, namely ‘(K a)’
+      In the expression: (not (K a))
+      In the expression: seq (not (K a)) ()
+    • Relevant bindings include
+        a :: a (bound at Defer01.hs:39:3)
+        i :: a -> () (bound at Defer01.hs:39:1)
+
+Defer01.hs:43:5: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • No instance for (MyClass a1) arising from a use of ‘myOp’
+    • In the expression: myOp 23
+      In an equation for ‘j’: j = myOp 23
+
+Defer01.hs:43:10: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Ambiguous type variable ‘a1’ arising from the literal ‘23’
+      prevents the constraint ‘(Num a1)’ from being solved.
+      Probable fix: use a type annotation to specify what ‘a1’ should be.
+      These potential instances exist:
+        instance Num Integer -- Defined in ‘GHC.Num’
+        instance Num Double -- Defined in ‘GHC.Float’
+        instance Num Float -- Defined in ‘GHC.Float’
+        ...plus two others
+        (use -fprint-potential-instances to see them all)
+    • In the first argument of ‘myOp’, namely ‘23’
+      In the expression: myOp 23
+      In an equation for ‘j’: j = myOp 23
+
+Defer01.hs:45:1: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    Couldn't match type ‘Int’ with ‘Bool’
+    Inaccessible code in
+      the type signature for:
+        k :: Int ~ Bool => Int -> Bool
+
+Defer01.hs:45:6: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match type ‘Int’ with ‘Bool’
+      Inaccessible code in
+        the type signature for:
+          k :: Int ~ Bool => Int -> Bool
+    • In the ambiguity check for ‘k’
+      To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+      In the type signature: k :: (Int ~ Bool) => Int -> Bool
+
+Defer01.hs:46:1: warning: [-Woverlapping-patterns (in -Wdefault)]
+    Pattern match is redundant
+    In an equation for ‘k’: k x = ...
+
+Defer01.hs:49:5: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match expected type ‘IO a0’
+                  with actual type ‘Char -> IO ()’
+    • Probable cause: ‘putChar’ is applied to too few arguments
+      In the first argument of ‘(>>)’, namely ‘putChar’
+      In the expression: putChar >> putChar 'p'
+      In an equation for ‘l’: l = putChar >> putChar 'p'
+*** Exception: Defer01.hs:11:40: error:
+    • Couldn't match type ‘Char’ with ‘[Char]’
+      Expected type: String
+        Actual type: Char
+    • In the first argument of ‘putStr’, namely ‘','’
+      In the second argument of ‘(>>)’, namely ‘putStr ','’
+      In the expression: putStr "Hello World" >> putStr ','
+(deferred type error)
+*** Exception: Defer01.hs:14:5: error:
+    • Couldn't match expected type ‘Int’ with actual type ‘Char’
+    • In the expression: 'p'
+      In an equation for ‘a’: a = 'p'
+(deferred type error)
+*** Exception: Defer01.hs:18:7: error:
+    • No instance for (Eq B) arising from a use of ‘==’
+    • In the expression: x == x
+      In an equation for ‘b’: b x = x == x
+(deferred type error)
+
+<interactive>:7:11: error:
+    • Couldn't match type ‘Bool’ with ‘Int’
+      Expected type: C Int
+        Actual type: C Bool
+    • In the first argument of ‘c’, namely ‘(C2 True)’
+      In the first argument of ‘print’, namely ‘(c (C2 True))’
+      In the expression: print (c (C2 True))
+*** Exception: Defer01.hs:28:5: error:
+    • No instance for (Num (a -> a)) arising from the literal ‘1’
+        (maybe you haven't applied a function to enough arguments?)
+    • In the expression: 1
+      In an equation for ‘d’: d = 1
+(deferred type error)
+*** Exception: Defer01.hs:31:5: error:
+    • Couldn't match expected type ‘Char -> t’ with actual type ‘Char’
+    • The function ‘e’ is applied to one argument,
+      but its type ‘Char’ has none
+      In the expression: e 'q'
+      In an equation for ‘f’: f = e 'q'
+    • Relevant bindings include
+        f :: t (bound at Defer01.hs:31:1)
+(deferred type error)
+*** Exception: Defer01.hs:34:8: error:
+    • Couldn't match expected type ‘Char’ with actual type ‘a’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          h :: forall a. a -> (Char, Char)
+        at Defer01.hs:33:1-21
+    • In the expression: x
+      In the expression: (x, 'c')
+      In an equation for ‘h’: h x = (x, 'c')
+    • Relevant bindings include
+        x :: a (bound at Defer01.hs:34:3)
+        h :: a -> (Char, Char)
+          (bound at Defer01.hs:34:1)
+(deferred type error)
+*** Exception: Defer01.hs:39:17: error:
+    • Couldn't match expected type ‘Bool’ with actual type ‘T a’
+    • In the first argument of ‘not’, namely ‘(K a)’
+      In the expression: (not (K a))
+      In the expression: seq (not (K a)) ()
+    • Relevant bindings include
+        a :: a (bound at Defer01.hs:39:3)
+        i :: a -> () (bound at Defer01.hs:39:1)
+(deferred type error)
+*** Exception: Defer01.hs:43:5: error:
+    • No instance for (MyClass a1) arising from a use of ‘myOp’
+    • In the expression: myOp 23
+      In an equation for ‘j’: j = myOp 23
+(deferred type error)
+
+<interactive>:13:8: error:
+    • Couldn't match type ‘Int’ with ‘Bool’ arising from a use of ‘k’
+    • In the first argument of ‘print’, namely ‘(k 2)’
+      In the expression: print (k 2)
+      In an equation for ‘it’: it = print (k 2)
+*** Exception: Defer01.hs:49:5: error:
+    • Couldn't match expected type ‘IO a0’
+                  with actual type ‘Char -> IO ()’
+    • Probable cause: ‘putChar’ is applied to too few arguments
+      In the first argument of ‘(>>)’, namely ‘putChar’
+      In the expression: putChar >> putChar 'p'
+      In an equation for ‘l’: l = putChar >> putChar 'p'
+(deferred type error)
diff --git a/testsuite/tests/ghci/scripts/T10248.stderr b/testsuite/tests/ghci/scripts/T10248.stderr
index 7172d4aa50..9de7323928 100644
--- a/testsuite/tests/ghci/scripts/T10248.stderr
+++ b/testsuite/tests/ghci/scripts/T10248.stderr
@@ -1,14 +1,14 @@
-

-<interactive>:2:10: error:

-    • Found hole: _ :: f a

-      Where: ‘f’ is a rigid type variable bound by

-               the inferred type of it :: Functor f => f (Maybe a)

-               at <interactive>:2:1-10

-             ‘a’ is a rigid type variable bound by

-               the inferred type of it :: Functor f => f (Maybe a)

-               at <interactive>:2:1-10

-    • In the second argument of ‘(<$>)’, namely ‘_’

-      In the expression: Just <$> _

-      In an equation for ‘it’: it = Just <$> _

-    • Relevant bindings include

-        it :: f (Maybe a) (bound at <interactive>:2:1)

+
+<interactive>:2:10: error:
+    • Found hole: _ :: f a
+      Where: ‘f’ is a rigid type variable bound by
+               the inferred type of it :: Functor f => f (Maybe a)
+               at <interactive>:2:1-10
+             ‘a’ is a rigid type variable bound by
+               the inferred type of it :: Functor f => f (Maybe a)
+               at <interactive>:2:1-10
+    • In the second argument of ‘(<$>)’, namely ‘_’
+      In the expression: Just <$> _
+      In an equation for ‘it’: it = Just <$> _
+    • Relevant bindings include
+        it :: f (Maybe a) (bound at <interactive>:2:1)
diff --git a/testsuite/tests/ghci/scripts/ghci050.stderr b/testsuite/tests/ghci/scripts/ghci050.stderr
index 0ea252e23d..a488269f73 100644
--- a/testsuite/tests/ghci/scripts/ghci050.stderr
+++ b/testsuite/tests/ghci/scripts/ghci050.stderr
@@ -1,14 +1,14 @@
-

-<interactive>:5:49: error:

-    • Couldn't match expected type ‘ListableElem (a, a)’

-                  with actual type ‘a’

-      ‘a’ is a rigid type variable bound by

-        the instance declaration at <interactive>:5:10-23

-    • In the expression: a

-      In the expression: [a, b]

-      In an equation for ‘asList’: asList (a, b) = [a, b]

-    • Relevant bindings include

-        b :: a (bound at <interactive>:5:43)

-        a :: a (bound at <interactive>:5:41)

-        asList :: (a, a) -> [ListableElem (a, a)]

-          (bound at <interactive>:5:33)

+
+<interactive>:5:49: error:
+    • Couldn't match expected type ‘ListableElem (a, a)’
+                  with actual type ‘a’
+      ‘a’ is a rigid type variable bound by
+        the instance declaration at <interactive>:5:10-23
+    • In the expression: a
+      In the expression: [a, b]
+      In an equation for ‘asList’: asList (a, b) = [a, b]
+    • Relevant bindings include
+        b :: a (bound at <interactive>:5:43)
+        a :: a (bound at <interactive>:5:41)
+        asList :: (a, a) -> [ListableElem (a, a)]
+          (bound at <interactive>:5:33)
diff --git a/testsuite/tests/indexed-types/should_compile/Simple14.stderr b/testsuite/tests/indexed-types/should_compile/Simple14.stderr
index eadcfc6953..7e08b2f11f 100644
--- a/testsuite/tests/indexed-types/should_compile/Simple14.stderr
+++ b/testsuite/tests/indexed-types/should_compile/Simple14.stderr
@@ -1,17 +1,17 @@
-

-Simple14.hs:8:8: error:

-    • Couldn't match type ‘z0’ with ‘z’

-        ‘z0’ is untouchable

-          inside the constraints: x ~ y

-          bound by the type signature for:

-                     eqE :: x ~ y => EQ_ z0 z0

-          at Simple14.hs:8:8-39

-      ‘z’ is a rigid type variable bound by

-        the type signature for:

-          eqE :: forall x y z p. EQ_ x y -> (x ~ y => EQ_ z z) -> p

-        at Simple14.hs:8:8-39

-      Expected type: EQ_ z0 z0

-        Actual type: EQ_ z z

-    • In the ambiguity check for ‘eqE’

-      To defer the ambiguity check to use sites, enable AllowAmbiguousTypes

-      In the type signature: eqE :: EQ_ x y -> (x ~ y => EQ_ z z) -> p

+
+Simple14.hs:8:8: error:
+    • Couldn't match type ‘z0’ with ‘z’
+        ‘z0’ is untouchable
+          inside the constraints: x ~ y
+          bound by the type signature for:
+                     eqE :: x ~ y => EQ_ z0 z0
+          at Simple14.hs:8:8-39
+      ‘z’ is a rigid type variable bound by
+        the type signature for:
+          eqE :: forall x y z p. EQ_ x y -> (x ~ y => EQ_ z z) -> p
+        at Simple14.hs:8:8-39
+      Expected type: EQ_ z0 z0
+        Actual type: EQ_ z z
+    • In the ambiguity check for ‘eqE’
+      To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+      In the type signature: eqE :: EQ_ x y -> (x ~ y => EQ_ z z) -> p
diff --git a/testsuite/tests/indexed-types/should_fail/GADTwrong1.stderr b/testsuite/tests/indexed-types/should_fail/GADTwrong1.stderr
index f8689f9b8d..44dc9475c0 100644
--- a/testsuite/tests/indexed-types/should_fail/GADTwrong1.stderr
+++ b/testsuite/tests/indexed-types/should_fail/GADTwrong1.stderr
@@ -1,17 +1,17 @@
-

-GADTwrong1.hs:12:21: error:

-    • Couldn't match expected type ‘b’ with actual type ‘c’

-      ‘c’ is a rigid type variable bound by

-        a pattern with constructor: T :: forall c. c -> T (Const c),

-        in a case alternative

-        at GADTwrong1.hs:12:14-16

-      ‘b’ is a rigid type variable bound by

-        the type signature for:

-          coerce :: forall a b. a -> b

-        at GADTwrong1.hs:10:1-29

-    • In the expression: y

-      In a case alternative: T y -> y

-      In the expression: case T x :: T (Const b) of { T y -> y }

-    • Relevant bindings include

-        y :: c (bound at GADTwrong1.hs:12:16)

-        coerce :: a -> b (bound at GADTwrong1.hs:11:1)

+
+GADTwrong1.hs:12:21: error:
+    • Couldn't match expected type ‘b’ with actual type ‘c’
+      ‘c’ is a rigid type variable bound by
+        a pattern with constructor: T :: forall c. c -> T (Const c),
+        in a case alternative
+        at GADTwrong1.hs:12:14-16
+      ‘b’ is a rigid type variable bound by
+        the type signature for:
+          coerce :: forall a b. a -> b
+        at GADTwrong1.hs:10:1-29
+    • In the expression: y
+      In a case alternative: T y -> y
+      In the expression: case T x :: T (Const b) of { T y -> y }
+    • Relevant bindings include
+        y :: c (bound at GADTwrong1.hs:12:16)
+        coerce :: a -> b (bound at GADTwrong1.hs:11:1)
diff --git a/testsuite/tests/indexed-types/should_fail/Overlap6.stderr b/testsuite/tests/indexed-types/should_fail/Overlap6.stderr
index 406ac9d3b6..c0b1d64889 100644
--- a/testsuite/tests/indexed-types/should_fail/Overlap6.stderr
+++ b/testsuite/tests/indexed-types/should_fail/Overlap6.stderr
@@ -1,14 +1,14 @@
-

-Overlap6.hs:15:7: error:

-    • Couldn't match type ‘x’ with ‘And x 'True’

-      ‘x’ is a rigid type variable bound by

-        the type signature for:

-          g :: forall (x :: Bool). Proxy x -> Proxy (And x 'True)

-        at Overlap6.hs:14:1-34

-      Expected type: Proxy (And x 'True)

-        Actual type: Proxy x

-    • In the expression: x

-      In an equation for ‘g’: g x = x

-    • Relevant bindings include

-        x :: Proxy x (bound at Overlap6.hs:15:3)

-        g :: Proxy x -> Proxy (And x 'True) (bound at Overlap6.hs:15:1)

+
+Overlap6.hs:15:7: error:
+    • Couldn't match type ‘x’ with ‘And x 'True’
+      ‘x’ is a rigid type variable bound by
+        the type signature for:
+          g :: forall (x :: Bool). Proxy x -> Proxy (And x 'True)
+        at Overlap6.hs:14:1-34
+      Expected type: Proxy (And x 'True)
+        Actual type: Proxy x
+    • In the expression: x
+      In an equation for ‘g’: g x = x
+    • Relevant bindings include
+        x :: Proxy x (bound at Overlap6.hs:15:3)
+        g :: Proxy x -> Proxy (And x 'True) (bound at Overlap6.hs:15:1)
diff --git a/testsuite/tests/indexed-types/should_fail/SimpleFail5a.stderr b/testsuite/tests/indexed-types/should_fail/SimpleFail5a.stderr
index 539628c6eb..69a7170504 100644
--- a/testsuite/tests/indexed-types/should_fail/SimpleFail5a.stderr
+++ b/testsuite/tests/indexed-types/should_fail/SimpleFail5a.stderr
@@ -1,13 +1,13 @@
-

-SimpleFail5a.hs:31:11: error:

-    • Couldn't match type ‘a’ with ‘Int’

-      ‘a’ is a rigid type variable bound by

-        the type signature for:

-          bar3wrong :: forall a. S3 a -> a

-        at SimpleFail5a.hs:30:1-22

-      Expected type: S3 a

-        Actual type: S3 Int

-    • In the pattern: D3Int

-      In an equation for ‘bar3wrong’: bar3wrong D3Int = 1

-    • Relevant bindings include

-        bar3wrong :: S3 a -> a (bound at SimpleFail5a.hs:31:1)

+
+SimpleFail5a.hs:31:11: error:
+    • Couldn't match type ‘a’ with ‘Int’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          bar3wrong :: forall a. S3 a -> a
+        at SimpleFail5a.hs:30:1-22
+      Expected type: S3 a
+        Actual type: S3 Int
+    • In the pattern: D3Int
+      In an equation for ‘bar3wrong’: bar3wrong D3Int = 1
+    • Relevant bindings include
+        bar3wrong :: S3 a -> a (bound at SimpleFail5a.hs:31:1)
diff --git a/testsuite/tests/indexed-types/should_fail/T2664.stderr b/testsuite/tests/indexed-types/should_fail/T2664.stderr
index 1409f1f44c..9c20e0438c 100644
--- a/testsuite/tests/indexed-types/should_fail/T2664.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T2664.stderr
@@ -1,19 +1,19 @@
-

-T2664.hs:31:52: error:

-    • Could not deduce: b ~ a arising from a use of ‘newPChan’

-      from the context: ((a :*: b) ~ Dual c, c ~ Dual (a :*: b))

-        bound by the type signature for:

-                   newPChan :: ((a :*: b) ~ Dual c, c ~ Dual (a :*: b)) =>

-                               IO (PChan (a :*: b), PChan c)

-        at T2664.hs:23:5-12

-      ‘b’ is a rigid type variable bound by

-        the instance declaration at T2664.hs:22:10-52

-      ‘a’ is a rigid type variable bound by

-        the instance declaration at T2664.hs:22:10-52

-    • In the third argument of ‘pchoose’, namely ‘newPChan’

-      In the first argument of ‘E’, namely ‘(pchoose Right v newPChan)’

-      In the expression:

-        E (pchoose Right v newPChan) (pchoose Left v newPChan)

-    • Relevant bindings include

-        v :: MVar (Either (PChan a) (PChan b)) (bound at T2664.hs:24:9)

-        newPChan :: IO (PChan (a :*: b), PChan c) (bound at T2664.hs:23:5)

+
+T2664.hs:31:52: error:
+    • Could not deduce: b ~ a arising from a use of ‘newPChan’
+      from the context: ((a :*: b) ~ Dual c, c ~ Dual (a :*: b))
+        bound by the type signature for:
+                   newPChan :: ((a :*: b) ~ Dual c, c ~ Dual (a :*: b)) =>
+                               IO (PChan (a :*: b), PChan c)
+        at T2664.hs:23:5-12
+      ‘b’ is a rigid type variable bound by
+        the instance declaration at T2664.hs:22:10-52
+      ‘a’ is a rigid type variable bound by
+        the instance declaration at T2664.hs:22:10-52
+    • In the third argument of ‘pchoose’, namely ‘newPChan’
+      In the first argument of ‘E’, namely ‘(pchoose Right v newPChan)’
+      In the expression:
+        E (pchoose Right v newPChan) (pchoose Left v newPChan)
+    • Relevant bindings include
+        v :: MVar (Either (PChan a) (PChan b)) (bound at T2664.hs:24:9)
+        newPChan :: IO (PChan (a :*: b), PChan c) (bound at T2664.hs:23:5)
diff --git a/testsuite/tests/indexed-types/should_fail/T3330a.stderr b/testsuite/tests/indexed-types/should_fail/T3330a.stderr
index ffda424227..dfc2e4223d 100644
--- a/testsuite/tests/indexed-types/should_fail/T3330a.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T3330a.stderr
@@ -1,37 +1,37 @@
-

-T3330a.hs:19:34: error:

-    • Couldn't match type ‘ix’

-                     with ‘r ix1 -> Writer [AnyF s] (r'0 ix1)’

-      ‘ix’ is a rigid type variable bound by

-        the type signature for:

-          children :: forall (s :: * -> *) ix (r :: * -> *).

-                      s ix -> PF s r ix -> [AnyF s]

-        at T3330a.hs:18:1-43

-      Expected type: (s0 ix0 -> ix1)

-                     -> r ix1 -> Writer [AnyF s] (r'0 ix1)

-        Actual type: s ix

-    • In the first argument of ‘hmapM’, namely ‘p’

-      In the first argument of ‘execWriter’, namely ‘(hmapM p collect x)’

-      In the expression: execWriter (hmapM p collect x)

-    • Relevant bindings include

-        x :: PF s r ix (bound at T3330a.hs:19:12)

-        p :: s ix (bound at T3330a.hs:19:10)

-        children :: s ix -> PF s r ix -> [AnyF s] (bound at T3330a.hs:19:1)

-

-T3330a.hs:19:44: error:

-    • Couldn't match type ‘ix’

-                     with ‘r0 ix0 -> Writer [AnyF s0] (r0 ix0)’

-      ‘ix’ is a rigid type variable bound by

-        the type signature for:

-          children :: forall (s :: * -> *) ix (r :: * -> *).

-                      s ix -> PF s r ix -> [AnyF s]

-        at T3330a.hs:18:1-43

-      Expected type: PF s r (r0 ix0 -> Writer [AnyF s0] (r0 ix0))

-        Actual type: PF s r ix

-    • In the third argument of ‘hmapM’, namely ‘x’

-      In the first argument of ‘execWriter’, namely ‘(hmapM p collect x)’

-      In the expression: execWriter (hmapM p collect x)

-    • Relevant bindings include

-        x :: PF s r ix (bound at T3330a.hs:19:12)

-        p :: s ix (bound at T3330a.hs:19:10)

-        children :: s ix -> PF s r ix -> [AnyF s] (bound at T3330a.hs:19:1)

+
+T3330a.hs:19:34: error:
+    • Couldn't match type ‘ix’
+                     with ‘r ix1 -> Writer [AnyF s] (r'0 ix1)’
+      ‘ix’ is a rigid type variable bound by
+        the type signature for:
+          children :: forall (s :: * -> *) ix (r :: * -> *).
+                      s ix -> PF s r ix -> [AnyF s]
+        at T3330a.hs:18:1-43
+      Expected type: (s0 ix0 -> ix1)
+                     -> r ix1 -> Writer [AnyF s] (r'0 ix1)
+        Actual type: s ix
+    • In the first argument of ‘hmapM’, namely ‘p’
+      In the first argument of ‘execWriter’, namely ‘(hmapM p collect x)’
+      In the expression: execWriter (hmapM p collect x)
+    • Relevant bindings include
+        x :: PF s r ix (bound at T3330a.hs:19:12)
+        p :: s ix (bound at T3330a.hs:19:10)
+        children :: s ix -> PF s r ix -> [AnyF s] (bound at T3330a.hs:19:1)
+
+T3330a.hs:19:44: error:
+    • Couldn't match type ‘ix’
+                     with ‘r0 ix0 -> Writer [AnyF s0] (r0 ix0)’
+      ‘ix’ is a rigid type variable bound by
+        the type signature for:
+          children :: forall (s :: * -> *) ix (r :: * -> *).
+                      s ix -> PF s r ix -> [AnyF s]
+        at T3330a.hs:18:1-43
+      Expected type: PF s r (r0 ix0 -> Writer [AnyF s0] (r0 ix0))
+        Actual type: PF s r ix
+    • In the third argument of ‘hmapM’, namely ‘x’
+      In the first argument of ‘execWriter’, namely ‘(hmapM p collect x)’
+      In the expression: execWriter (hmapM p collect x)
+    • Relevant bindings include
+        x :: PF s r ix (bound at T3330a.hs:19:12)
+        p :: s ix (bound at T3330a.hs:19:10)
+        children :: s ix -> PF s r ix -> [AnyF s] (bound at T3330a.hs:19:1)
diff --git a/testsuite/tests/indexed-types/should_fail/T3440.stderr b/testsuite/tests/indexed-types/should_fail/T3440.stderr
index 84eb475b23..af8f27b761 100644
--- a/testsuite/tests/indexed-types/should_fail/T3440.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T3440.stderr
@@ -1,24 +1,24 @@
-

-T3440.hs:11:22: error:

-    • Could not deduce: a1 ~ a

-      from the context: Fam a ~ Fam a1

-        bound by a pattern with constructor:

-                   GADT :: forall a. a -> Fam a -> GADT (Fam a),

-                 in an equation for ‘unwrap’

-        at T3440.hs:11:9-16

-      ‘a1’ is a rigid type variable bound by

-        a pattern with constructor:

-          GADT :: forall a. a -> Fam a -> GADT (Fam a),

-        in an equation for ‘unwrap’

-        at T3440.hs:11:9-16

-      ‘a’ is a rigid type variable bound by

-        the type signature for:

-          unwrap :: forall a. GADT (Fam a) -> (a, Fam a)

-        at T3440.hs:10:1-36

-    • In the expression: x

-      In the expression: (x, y)

-      In an equation for ‘unwrap’: unwrap (GADT x y) = (x, y)

-    • Relevant bindings include

-        y :: Fam a1 (bound at T3440.hs:11:16)

-        x :: a1 (bound at T3440.hs:11:14)

-        unwrap :: GADT (Fam a) -> (a, Fam a) (bound at T3440.hs:11:1)

+
+T3440.hs:11:22: error:
+    • Could not deduce: a1 ~ a
+      from the context: Fam a ~ Fam a1
+        bound by a pattern with constructor:
+                   GADT :: forall a. a -> Fam a -> GADT (Fam a),
+                 in an equation for ‘unwrap’
+        at T3440.hs:11:9-16
+      ‘a1’ is a rigid type variable bound by
+        a pattern with constructor:
+          GADT :: forall a. a -> Fam a -> GADT (Fam a),
+        in an equation for ‘unwrap’
+        at T3440.hs:11:9-16
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          unwrap :: forall a. GADT (Fam a) -> (a, Fam a)
+        at T3440.hs:10:1-36
+    • In the expression: x
+      In the expression: (x, y)
+      In an equation for ‘unwrap’: unwrap (GADT x y) = (x, y)
+    • Relevant bindings include
+        y :: Fam a1 (bound at T3440.hs:11:16)
+        x :: a1 (bound at T3440.hs:11:14)
+        unwrap :: GADT (Fam a) -> (a, Fam a) (bound at T3440.hs:11:1)
diff --git a/testsuite/tests/indexed-types/should_fail/T4093a.stderr b/testsuite/tests/indexed-types/should_fail/T4093a.stderr
index 3ce9158bdc..64589234d6 100644
--- a/testsuite/tests/indexed-types/should_fail/T4093a.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T4093a.stderr
@@ -1,16 +1,16 @@
-

-T4093a.hs:8:8: error:

-    • Could not deduce: e ~ ()

-      from the context: Foo e ~ Maybe e

-        bound by the type signature for:

-                   hang :: Foo e ~ Maybe e => Foo e

-        at T4093a.hs:7:1-34

-      ‘e’ is a rigid type variable bound by

-        the type signature for:

-          hang :: forall e. Foo e ~ Maybe e => Foo e

-        at T4093a.hs:7:1-34

-      Expected type: Foo e

-        Actual type: Maybe ()

-    • In the expression: Just ()

-      In an equation for ‘hang’: hang = Just ()

-    • Relevant bindings include hang :: Foo e (bound at T4093a.hs:8:1)

+
+T4093a.hs:8:8: error:
+    • Could not deduce: e ~ ()
+      from the context: Foo e ~ Maybe e
+        bound by the type signature for:
+                   hang :: Foo e ~ Maybe e => Foo e
+        at T4093a.hs:7:1-34
+      ‘e’ is a rigid type variable bound by
+        the type signature for:
+          hang :: forall e. Foo e ~ Maybe e => Foo e
+        at T4093a.hs:7:1-34
+      Expected type: Foo e
+        Actual type: Maybe ()
+    • In the expression: Just ()
+      In an equation for ‘hang’: hang = Just ()
+    • Relevant bindings include hang :: Foo e (bound at T4093a.hs:8:1)
diff --git a/testsuite/tests/indexed-types/should_fail/T4093b.stderr b/testsuite/tests/indexed-types/should_fail/T4093b.stderr
index 92530d58bf..1796ed1c52 100644
--- a/testsuite/tests/indexed-types/should_fail/T4093b.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T4093b.stderr
@@ -1,42 +1,42 @@
-

-T4093b.hs:31:13: error:

-    • Could not deduce: e ~ 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)

-        bound by the type signature for:

-                   blockToNodeList :: (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) =>

-                                      Block n e x -> A e x n

-        at T4093b.hs:(19,1)-(22,26)

-      ‘e’ is a rigid type variable bound by

-        the type signature for:

-          blockToNodeList :: forall (n :: * -> * -> *) e x.

-                             (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) =>

-                             Block n e x -> A e x n

-        at T4093b.hs:(19,1)-(22,26)

-      Expected type: EitherCO e (A C O n) (A O O n)

-        Actual type: (MaybeC C (n C O), MaybeC O (n O C))

-    • 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)

-                ....

-    • Relevant bindings include

-        f :: n C O

-             -> EitherCO e (A C O n) (A O O n) -> EitherCO e (A C O n) (A O O n)

-          (bound at T4093b.hs:31:5)

-        l :: n O C

-             -> EitherCO e (A C O n) (A O O n) -> EitherCO e (A C C n) (A O C n)

-          (bound at T4093b.hs:34:5)

-        b :: Block n e x (bound at T4093b.hs:25:17)

-        blockToNodeList :: Block n e x -> A e x n (bound at T4093b.hs:25:1)

+
+T4093b.hs:31:13: error:
+    • Could not deduce: e ~ 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)
+        bound by the type signature for:
+                   blockToNodeList :: (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) =>
+                                      Block n e x -> A e x n
+        at T4093b.hs:(19,1)-(22,26)
+      ‘e’ is a rigid type variable bound by
+        the type signature for:
+          blockToNodeList :: forall (n :: * -> * -> *) e x.
+                             (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) =>
+                             Block n e x -> A e x n
+        at T4093b.hs:(19,1)-(22,26)
+      Expected type: EitherCO e (A C O n) (A O O n)
+        Actual type: (MaybeC C (n C O), MaybeC O (n O C))
+    • 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)
+                ....
+    • Relevant bindings include
+        f :: n C O
+             -> EitherCO e (A C O n) (A O O n) -> EitherCO e (A C O n) (A O O n)
+          (bound at T4093b.hs:31:5)
+        l :: n O C
+             -> EitherCO e (A C O n) (A O O n) -> EitherCO e (A C C n) (A O C n)
+          (bound at T4093b.hs:34:5)
+        b :: Block n e x (bound at T4093b.hs:25:17)
+        blockToNodeList :: Block n e x -> A e x n (bound at T4093b.hs:25:1)
diff --git a/testsuite/tests/indexed-types/should_fail/T4174.stderr b/testsuite/tests/indexed-types/should_fail/T4174.stderr
index 7fe8c704b9..db5008dd1e 100644
--- a/testsuite/tests/indexed-types/should_fail/T4174.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T4174.stderr
@@ -1,16 +1,16 @@
-

-T4174.hs:42:12: error:

-    • Couldn't match type ‘b’ with ‘RtsSpinLock’

-      ‘b’ is a rigid type variable bound by

-        the type signature for:

-          testcase :: forall (m :: * -> *) minor n t p a b.

-                      Monad m =>

-                      m (Field (Way (GHC6'8 minor) n t p) a b)

-        at T4174.hs:41:1-63

-      Expected type: m (Field (Way (GHC6'8 minor) n t p) a b)

-        Actual type: m (Field (WayOf m) SmStep RtsSpinLock)

-    • In the expression: sync_large_objects

-      In an equation for ‘testcase’: testcase = sync_large_objects

-    • Relevant bindings include

-        testcase :: m (Field (Way (GHC6'8 minor) n t p) a b)

-          (bound at T4174.hs:42:1)

+
+T4174.hs:42:12: error:
+    • Couldn't match type ‘b’ with ‘RtsSpinLock’
+      ‘b’ is a rigid type variable bound by
+        the type signature for:
+          testcase :: forall (m :: * -> *) minor n t p a b.
+                      Monad m =>
+                      m (Field (Way (GHC6'8 minor) n t p) a b)
+        at T4174.hs:41:1-63
+      Expected type: m (Field (Way (GHC6'8 minor) n t p) a b)
+        Actual type: m (Field (WayOf m) SmStep RtsSpinLock)
+    • In the expression: sync_large_objects
+      In an equation for ‘testcase’: testcase = sync_large_objects
+    • Relevant bindings include
+        testcase :: m (Field (Way (GHC6'8 minor) n t p) a b)
+          (bound at T4174.hs:42:1)
diff --git a/testsuite/tests/indexed-types/should_fail/T4272.stderr b/testsuite/tests/indexed-types/should_fail/T4272.stderr
index 49a6e9f6c9..f60711a758 100644
--- a/testsuite/tests/indexed-types/should_fail/T4272.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T4272.stderr
@@ -1,17 +1,17 @@
-

-T4272.hs:15:26: error:

-    • Couldn't match type ‘a’ with ‘TermFamily a a’

-      ‘a’ is a rigid type variable bound by

-        the type signature for:

-          laws :: forall a b. TermLike a => TermFamily a a -> b

-        at T4272.hs:14:1-53

-      Expected type: TermFamily a (TermFamily a a)

-        Actual type: TermFamily a a

-    • In the first argument of ‘terms’, namely

-        ‘(undefined :: TermFamily a a)’

-      In the second argument of ‘prune’, namely

-        ‘(terms (undefined :: TermFamily a a))’

-      In the expression: prune t (terms (undefined :: TermFamily a a))

-    • Relevant bindings include

-        t :: TermFamily a a (bound at T4272.hs:15:6)

-        laws :: TermFamily a a -> b (bound at T4272.hs:15:1)

+
+T4272.hs:15:26: error:
+    • Couldn't match type ‘a’ with ‘TermFamily a a’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          laws :: forall a b. TermLike a => TermFamily a a -> b
+        at T4272.hs:14:1-53
+      Expected type: TermFamily a (TermFamily a a)
+        Actual type: TermFamily a a
+    • In the first argument of ‘terms’, namely
+        ‘(undefined :: TermFamily a a)’
+      In the second argument of ‘prune’, namely
+        ‘(terms (undefined :: TermFamily a a))’
+      In the expression: prune t (terms (undefined :: TermFamily a a))
+    • Relevant bindings include
+        t :: TermFamily a a (bound at T4272.hs:15:6)
+        laws :: TermFamily a a -> b (bound at T4272.hs:15:1)
diff --git a/testsuite/tests/indexed-types/should_fail/T7786.stderr b/testsuite/tests/indexed-types/should_fail/T7786.stderr
index 79230e1555..ca3e9ecbda 100644
--- a/testsuite/tests/indexed-types/should_fail/T7786.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T7786.stderr
@@ -1,50 +1,50 @@
-

-T7786.hs:86:49: error:

-    • Couldn't match type ‘xxx’

-                     with ‘Intersect (BuriedUnder sub k 'Empty) inv’

-      Expected type: Sing xxx

-        Actual type: Sing (Intersect (BuriedUnder sub k 'Empty) inv)

-    • In the first argument of ‘return’, namely

-        ‘(buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db)’

-      In a stmt of a 'do' block:

-        Nil :: Sing xxx <- return

-                             (buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db)

-      In the expression:

-        do { Nil :: Sing xxx <- return

-                                  (buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db);

-             return $ Sub db k sub }

-    • Relevant bindings include

-        sub :: Database sub (bound at T7786.hs:86:13)

-        k :: Sing k (bound at T7786.hs:86:11)

-        db :: Database inv (bound at T7786.hs:86:8)

-        addSub :: Database inv

-                  -> Sing k

-                  -> Database sub

-                  -> Maybe (Database (BuriedUnder sub k inv))

-          (bound at T7786.hs:86:1)

-

-T7786.hs:90:31: error:

-    • Could not deduce: Intersect (BuriedUnder sub k 'Empty) inv

-                        ~

-                        'Empty

-        arising from a use of ‘Sub’

-      from the context: xxx ~ 'Empty

-        bound by a pattern with constructor: Nil :: forall a. Sing 'Empty,

-                 in a pattern binding in

-                      'do' block

-        at T7786.hs:86:22-24

-    • In the second argument of ‘($)’, namely ‘Sub db k sub’

-      In a stmt of a 'do' block: return $ Sub db k sub

-      In the expression:

-        do { Nil :: Sing xxx <- return

-                                  (buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db);

-             return $ Sub db k sub }

-    • Relevant bindings include

-        sub :: Database sub (bound at T7786.hs:86:13)

-        k :: Sing k (bound at T7786.hs:86:11)

-        db :: Database inv (bound at T7786.hs:86:8)

-        addSub :: Database inv

-                  -> Sing k

-                  -> Database sub

-                  -> Maybe (Database (BuriedUnder sub k inv))

-          (bound at T7786.hs:86:1)

+
+T7786.hs:86:49: error:
+    • Couldn't match type ‘xxx’
+                     with ‘Intersect (BuriedUnder sub k 'Empty) inv’
+      Expected type: Sing xxx
+        Actual type: Sing (Intersect (BuriedUnder sub k 'Empty) inv)
+    • In the first argument of ‘return’, namely
+        ‘(buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db)’
+      In a stmt of a 'do' block:
+        Nil :: Sing xxx <- return
+                             (buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db)
+      In the expression:
+        do { Nil :: Sing xxx <- return
+                                  (buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db);
+             return $ Sub db k sub }
+    • Relevant bindings include
+        sub :: Database sub (bound at T7786.hs:86:13)
+        k :: Sing k (bound at T7786.hs:86:11)
+        db :: Database inv (bound at T7786.hs:86:8)
+        addSub :: Database inv
+                  -> Sing k
+                  -> Database sub
+                  -> Maybe (Database (BuriedUnder sub k inv))
+          (bound at T7786.hs:86:1)
+
+T7786.hs:90:31: error:
+    • Could not deduce: Intersect (BuriedUnder sub k 'Empty) inv
+                        ~
+                        'Empty
+        arising from a use of ‘Sub’
+      from the context: xxx ~ 'Empty
+        bound by a pattern with constructor: Nil :: forall a. Sing 'Empty,
+                 in a pattern binding in
+                      'do' block
+        at T7786.hs:86:22-24
+    • In the second argument of ‘($)’, namely ‘Sub db k sub’
+      In a stmt of a 'do' block: return $ Sub db k sub
+      In the expression:
+        do { Nil :: Sing xxx <- return
+                                  (buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db);
+             return $ Sub db k sub }
+    • Relevant bindings include
+        sub :: Database sub (bound at T7786.hs:86:13)
+        k :: Sing k (bound at T7786.hs:86:11)
+        db :: Database inv (bound at T7786.hs:86:8)
+        addSub :: Database inv
+                  -> Sing k
+                  -> Database sub
+                  -> Maybe (Database (BuriedUnder sub k inv))
+          (bound at T7786.hs:86:1)
diff --git a/testsuite/tests/indexed-types/should_fail/T9662.stderr b/testsuite/tests/indexed-types/should_fail/T9662.stderr
index 403f769dfd..c44156f474 100644
--- a/testsuite/tests/indexed-types/should_fail/T9662.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T9662.stderr
@@ -1,35 +1,35 @@
-

-T9662.hs:47:8: error:

-    • Couldn't match type ‘n’ with ‘Int’

-      ‘n’ is a rigid type variable bound by

-        the type signature for:

-          test :: forall sh k m n.

-                  Shape (((sh :. k) :. m) :. n) -> Shape (((sh :. m) :. n) :. k)

-        at T9662.hs:44:1-50

-      Expected type: Exp (((sh :. m) :. n) :. k)

-                     -> Exp (((sh :. m) :. n) :. k)

-        Actual type: Exp

-                       (Tuple (((Atom a0 :. Atom Int) :. Atom Int) :. Atom Int))

-                     -> Exp

-                          (Plain (((Unlifted (Atom a0) :. Exp Int) :. Exp Int) :. Exp Int))

-    • In the first argument of ‘backpermute’, namely

-        ‘(modify

-            (atom :. atom :. atom :. atom)

-            (\ (sh :. k :. m :. n) -> (sh :. m :. n :. k)))’

-      In the expression:

-        backpermute

-          (modify

-             (atom :. atom :. atom :. atom)

-             (\ (sh :. k :. m :. n) -> (sh :. m :. n :. k)))

-          id

-      In an equation for ‘test’:

-          test

-            = backpermute

-                (modify

-                   (atom :. atom :. atom :. atom)

-                   (\ (sh :. k :. m :. n) -> (sh :. m :. n :. k)))

-                id

-    • Relevant bindings include

-        test :: Shape (((sh :. k) :. m) :. n)

-                -> Shape (((sh :. m) :. n) :. k)

-          (bound at T9662.hs:45:1)

+
+T9662.hs:47:8: error:
+    • Couldn't match type ‘n’ with ‘Int’
+      ‘n’ is a rigid type variable bound by
+        the type signature for:
+          test :: forall sh k m n.
+                  Shape (((sh :. k) :. m) :. n) -> Shape (((sh :. m) :. n) :. k)
+        at T9662.hs:44:1-50
+      Expected type: Exp (((sh :. m) :. n) :. k)
+                     -> Exp (((sh :. m) :. n) :. k)
+        Actual type: Exp
+                       (Tuple (((Atom a0 :. Atom Int) :. Atom Int) :. Atom Int))
+                     -> Exp
+                          (Plain (((Unlifted (Atom a0) :. Exp Int) :. Exp Int) :. Exp Int))
+    • In the first argument of ‘backpermute’, namely
+        ‘(modify
+            (atom :. atom :. atom :. atom)
+            (\ (sh :. k :. m :. n) -> (sh :. m :. n :. k)))’
+      In the expression:
+        backpermute
+          (modify
+             (atom :. atom :. atom :. atom)
+             (\ (sh :. k :. m :. n) -> (sh :. m :. n :. k)))
+          id
+      In an equation for ‘test’:
+          test
+            = backpermute
+                (modify
+                   (atom :. atom :. atom :. atom)
+                   (\ (sh :. k :. m :. n) -> (sh :. m :. n :. k)))
+                id
+    • Relevant bindings include
+        test :: Shape (((sh :. k) :. m) :. n)
+                -> Shape (((sh :. m) :. n) :. k)
+          (bound at T9662.hs:45:1)
diff --git a/testsuite/tests/module/mod71.stderr b/testsuite/tests/module/mod71.stderr
index f0f43d8df6..7c95534256 100644
--- a/testsuite/tests/module/mod71.stderr
+++ b/testsuite/tests/module/mod71.stderr
@@ -1,12 +1,12 @@
-

-mod71.hs:4:9: error:

-    • Found hole: _ :: t1

-      Where: ‘t1’ is a rigid type variable bound by

-               the inferred type of f :: Num t => (t1 -> t -> t2) -> t2

-               at mod71.hs:4:1-11

-    • In the first argument of ‘x’, namely ‘_’

-      In the expression: x _ 1

-      In an equation for ‘f’: f x = x _ 1

-    • Relevant bindings include

-        x :: t1 -> t -> t2 (bound at mod71.hs:4:3)

-        f :: (t1 -> t -> t2) -> t2 (bound at mod71.hs:4:1)

+
+mod71.hs:4:9: error:
+    • Found hole: _ :: t1
+      Where: ‘t1’ is a rigid type variable bound by
+               the inferred type of f :: Num t => (t1 -> t -> t2) -> t2
+               at mod71.hs:4:1-11
+    • In the first argument of ‘x’, namely ‘_’
+      In the expression: x _ 1
+      In an equation for ‘f’: f x = x _ 1
+    • Relevant bindings include
+        x :: t1 -> t -> t2 (bound at mod71.hs:4:3)
+        f :: (t1 -> t -> t2) -> t2 (bound at mod71.hs:4:1)
diff --git a/testsuite/tests/rename/should_fail/rnfail026.stderr b/testsuite/tests/rename/should_fail/rnfail026.stderr
index 6c032b0487..c44f655ccb 100644
--- a/testsuite/tests/rename/should_fail/rnfail026.stderr
+++ b/testsuite/tests/rename/should_fail/rnfail026.stderr
@@ -1,11 +1,11 @@
-

-rnfail026.hs:16:27: error:

-    • Expecting one fewer arguments to ‘Set a’

-      Expected kind ‘* -> *’, but ‘Set a’ has kind ‘*’

-    • In the first argument of ‘Monad’, namely

-        ‘forall a. Eq a => Set a’

-      In the instance declaration for ‘Monad (forall a. Eq a => Set a)’

-

-rnfail026.hs:19:10: error:

-    • Illegal polymorphic type: forall a. [a]

-    • In the instance declaration for ‘Eq (forall a. [a])’

+
+rnfail026.hs:16:27: error:
+    • Expecting one fewer arguments to ‘Set a’
+      Expected kind ‘* -> *’, but ‘Set a’ has kind ‘*’
+    • In the first argument of ‘Monad’, namely
+        ‘forall a. Eq a => Set a’
+      In the instance declaration for ‘Monad (forall a. Eq a => Set a)’
+
+rnfail026.hs:19:10: error:
+    • Illegal polymorphic type: forall a. [a]
+    • In the instance declaration for ‘Eq (forall a. [a])’
diff --git a/testsuite/tests/rts/T11223/T11223_link_order_a_b_2_fail.stderr-mingw32 b/testsuite/tests/rts/T11223/T11223_link_order_a_b_2_fail.stderr-mingw32
index 51d4db5dc0..bf1685e810 100644
--- a/testsuite/tests/rts/T11223/T11223_link_order_a_b_2_fail.stderr-mingw32
+++ b/testsuite/tests/rts/T11223/T11223_link_order_a_b_2_fail.stderr-mingw32
@@ -1,25 +1,25 @@
-GHC runtime linker: fatal error: I found a duplicate definition for symbol

-   a

-whilst processing object file

-   E:/msys64/home/Tamar/ghc2/testsuite/tests/rts/T11223\libfoo_link_lib_3.a

-The symbol was previously defined in

-   E:/msys64/home/Tamar/ghc2/testsuite/tests/rts/T11223\libbar_link_lib_3.a(bar_link_lib_3.o)

-This could be caused by:

-   * Loading two different object files which export the same symbol

-   * Specifying the same object file twice on the GHCi command line

-   * An incorrect `package.conf' entry, causing some object to be

-     loaded twice.

-

-ByteCodeLink: can't find label

-During interactive linking, GHCi couldn't find the following symbol:

-  c

-This may be due to you not asking GHCi to load extra object files,

-archives or DLLs needed by your current session.  Restart GHCi, specifying

-the missing library using the -L/path/to/object/dir and -lmissinglibname

-flags, or simply by naming the relevant files on the GHCi command line.

-Alternatively, this link failure might indicate a bug in GHCi.

-If you suspect the latter, please send a bug report to:

-  glasgow-haskell-bugs@haskell.org

-

-ghc-stage2.exe: Could not on-demand load symbol 'c'

-

+GHC runtime linker: fatal error: I found a duplicate definition for symbol
+   a
+whilst processing object file
+   E:/msys64/home/Tamar/ghc2/testsuite/tests/rts/T11223\libfoo_link_lib_3.a
+The symbol was previously defined in
+   E:/msys64/home/Tamar/ghc2/testsuite/tests/rts/T11223\libbar_link_lib_3.a(bar_link_lib_3.o)
+This could be caused by:
+   * Loading two different object files which export the same symbol
+   * Specifying the same object file twice on the GHCi command line
+   * An incorrect `package.conf' entry, causing some object to be
+     loaded twice.
+
+ByteCodeLink: can't find label
+During interactive linking, GHCi couldn't find the following symbol:
+  c
+This may be due to you not asking GHCi to load extra object files,
+archives or DLLs needed by your current session.  Restart GHCi, specifying
+the missing library using the -L/path/to/object/dir and -lmissinglibname
+flags, or simply by naming the relevant files on the GHCi command line.
+Alternatively, this link failure might indicate a bug in GHCi.
+If you suspect the latter, please send a bug report to:
+  glasgow-haskell-bugs@haskell.org
+
+ghc-stage2.exe: Could not on-demand load symbol 'c'
+
diff --git a/testsuite/tests/rts/T11223/T11223_link_order_a_b_succeed.stdout b/testsuite/tests/rts/T11223/T11223_link_order_a_b_succeed.stdout
index 78c6baefdd..0cfbf08886 100644
--- a/testsuite/tests/rts/T11223/T11223_link_order_a_b_succeed.stdout
+++ b/testsuite/tests/rts/T11223/T11223_link_order_a_b_succeed.stdout
@@ -1 +1 @@
-2

+2
diff --git a/testsuite/tests/rts/T11223/T11223_link_order_b_a_2_succeed.stdout b/testsuite/tests/rts/T11223/T11223_link_order_b_a_2_succeed.stdout
index 110fbf1042..9183bf03fc 100644
--- a/testsuite/tests/rts/T11223/T11223_link_order_b_a_2_succeed.stdout
+++ b/testsuite/tests/rts/T11223/T11223_link_order_b_a_2_succeed.stdout
@@ -1 +1 @@
-256

+256
diff --git a/testsuite/tests/rts/T11223/T11223_link_order_b_a_succeed.stdout b/testsuite/tests/rts/T11223/T11223_link_order_b_a_succeed.stdout
index e0e1028e60..b8626c4cff 100644
--- a/testsuite/tests/rts/T11223/T11223_link_order_b_a_succeed.stdout
+++ b/testsuite/tests/rts/T11223/T11223_link_order_b_a_succeed.stdout
@@ -1 +1 @@
-4

+4
diff --git a/testsuite/tests/rts/T11223/T11223_simple_link.stdout b/testsuite/tests/rts/T11223/T11223_simple_link.stdout
index 78c5a0adb2..900731ffd5 100644
--- a/testsuite/tests/rts/T11223/T11223_simple_link.stdout
+++ b/testsuite/tests/rts/T11223/T11223_simple_link.stdout
@@ -1 +1 @@
-64

+64
diff --git a/testsuite/tests/rts/T11223/T11223_simple_link_lib.stdout b/testsuite/tests/rts/T11223/T11223_simple_link_lib.stdout
index 78c5a0adb2..900731ffd5 100644
--- a/testsuite/tests/rts/T11223/T11223_simple_link_lib.stdout
+++ b/testsuite/tests/rts/T11223/T11223_simple_link_lib.stdout
@@ -1 +1 @@
-64

+64
diff --git a/testsuite/tests/rts/T11223/T11223_simple_unused_duplicate_lib.stdout b/testsuite/tests/rts/T11223/T11223_simple_unused_duplicate_lib.stdout
index 78c5a0adb2..900731ffd5 100644
--- a/testsuite/tests/rts/T11223/T11223_simple_unused_duplicate_lib.stdout
+++ b/testsuite/tests/rts/T11223/T11223_simple_unused_duplicate_lib.stdout
@@ -1 +1 @@
-64

+64
diff --git a/testsuite/tests/th/T10267.stderr b/testsuite/tests/th/T10267.stderr
index 171c9e8f3a..e255178839 100644
--- a/testsuite/tests/th/T10267.stderr
+++ b/testsuite/tests/th/T10267.stderr
@@ -1,46 +1,46 @@
-

-T10267.hs:8:1: error:

-    • Found hole: _ :: a

-      Where: ‘a’ is a rigid type variable bound by

-               the type signature for:

-                 j :: forall a. a -> a

-               at T10267.hs:(8,1)-(12,14)

-    • In the expression: _

-      In an equation for ‘j’: j x = _

-    • Relevant bindings include

-        x :: a (bound at T10267.hs:8:1)

-        j :: a -> a (bound at T10267.hs:8:1)

-

-T10267.hs:8:1: error:

-    • Found hole: _foo :: a -> a

-      Where: ‘a’ is a rigid type variable bound by

-               the type signature for:

-                 i :: forall a. a -> a

-               at T10267.hs:(8,1)-(12,14)

-      Or perhaps ‘_foo’ is mis-spelled, or not in scope

-    • In the expression: _foo

-      In an equation for ‘i’: i = _foo

-    • Relevant bindings include i :: a -> a (bound at T10267.hs:8:1)

-

-T10267.hs:14:3: error:

-    • Found hole: _foo :: a -> a

-      Where: ‘a’ is a rigid type variable bound by

-               the type signature for:

-                 k :: forall a. a -> a

-               at T10267.hs:(14,3)-(21,2)

-      Or perhaps ‘_foo’ is mis-spelled, or not in scope

-    • In the expression: _foo

-      In an equation for ‘k’: k = _foo

-    • Relevant bindings include k :: a -> a (bound at T10267.hs:14:3)

-

-T10267.hs:23:3: error:

-    • Found hole: _ :: a

-      Where: ‘a’ is a rigid type variable bound by

-               the type signature for:

-                 l :: forall a. a -> a

-               at T10267.hs:(23,3)-(30,2)

-    • In the expression: _

-      In an equation for ‘l’: l x = _

-    • Relevant bindings include

-        x :: a (bound at T10267.hs:23:3)

-        l :: a -> a (bound at T10267.hs:23:3)

+
+T10267.hs:8:1: error:
+    • Found hole: _ :: a
+      Where: ‘a’ is a rigid type variable bound by
+               the type signature for:
+                 j :: forall a. a -> a
+               at T10267.hs:(8,1)-(12,14)
+    • In the expression: _
+      In an equation for ‘j’: j x = _
+    • Relevant bindings include
+        x :: a (bound at T10267.hs:8:1)
+        j :: a -> a (bound at T10267.hs:8:1)
+
+T10267.hs:8:1: error:
+    • Found hole: _foo :: a -> a
+      Where: ‘a’ is a rigid type variable bound by
+               the type signature for:
+                 i :: forall a. a -> a
+               at T10267.hs:(8,1)-(12,14)
+      Or perhaps ‘_foo’ is mis-spelled, or not in scope
+    • In the expression: _foo
+      In an equation for ‘i’: i = _foo
+    • Relevant bindings include i :: a -> a (bound at T10267.hs:8:1)
+
+T10267.hs:14:3: error:
+    • Found hole: _foo :: a -> a
+      Where: ‘a’ is a rigid type variable bound by
+               the type signature for:
+                 k :: forall a. a -> a
+               at T10267.hs:(14,3)-(21,2)
+      Or perhaps ‘_foo’ is mis-spelled, or not in scope
+    • In the expression: _foo
+      In an equation for ‘k’: k = _foo
+    • Relevant bindings include k :: a -> a (bound at T10267.hs:14:3)
+
+T10267.hs:23:3: error:
+    • Found hole: _ :: a
+      Where: ‘a’ is a rigid type variable bound by
+               the type signature for:
+                 l :: forall a. a -> a
+               at T10267.hs:(23,3)-(30,2)
+    • In the expression: _
+      In an equation for ‘l’: l x = _
+    • Relevant bindings include
+        x :: a (bound at T10267.hs:23:3)
+        l :: a -> a (bound at T10267.hs:23:3)