Improve error messages for ambiguous type variables

Improved error messages are only printed when the old message would be
"No instance for...", since they're not as helpful for "Could not deduce..."

No special test case as error messages are tested by other tests already.

Signed-off-by: David Kraeutmann <kane@kane.cx>

Reviewed By: austin, goldfire

Differential Revision: https://phabricator.haskell.org/D1182

GHC Trac Issues: #10733

20 files changed, 99 insertions, 77 deletions

diff --git a/testsuite/tests/annotations/should_fail/annfail10.stderr b/testsuite/tests/annotations/should_fail/annfail10.stderr
index a8236709c2..1e77541499 100644
--- a/testsuite/tests/annotations/should_fail/annfail10.stderr
+++ b/testsuite/tests/annotations/should_fail/annfail10.stderr
@@ -1,8 +1,9 @@
 
 annfail10.hs:9:1: error:
-    No instance for (Data a0) arising from an annotation
-    The type variable ‘a0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘a0’ arising from an annotation
+    prevents the constraint ‘(Data a0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘a0’ should be.
+    These potential instances exist:
       instance (Data a, Data b) => Data (Either a b)
         -- Defined in ‘Data.Data’
       instance Data All -- Defined in ‘Data.Data’
@@ -13,9 +14,10 @@ annfail10.hs:9:1: error:
     In the annotation: {-# ANN f 1 #-}
 
 annfail10.hs:9:11: error:
-    No instance for (Num a0) arising from the literal ‘1’
-    The type variable ‘a0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘a0’ arising from the literal ‘1’
+    prevents the constraint ‘(Num a0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘a0’ should be.
+    These potential instances exist:
       instance forall (k :: BOX) (f :: k -> *) (a :: k).
                Num (f a) =>
                Num (Alt f a)
diff --git a/testsuite/tests/ghci.debugger/scripts/break006.stderr b/testsuite/tests/ghci.debugger/scripts/break006.stderr
index bf96e55e9e..b6e3cc9b12 100644
--- a/testsuite/tests/ghci.debugger/scripts/break006.stderr
+++ b/testsuite/tests/ghci.debugger/scripts/break006.stderr
@@ -4,7 +4,7 @@
     Cannot resolve unknown runtime type ‘t1’
     Use :print or :force to determine these types
     Relevant bindings include it :: t1 (bound at <interactive>:5:1)
-    Potential instances:
+    These potential instances exist:
       instance (Show a, Show b) => Show (Either a b)
         -- Defined in ‘Data.Either’
       instance Show All -- Defined in ‘Data.Monoid’
@@ -21,7 +21,7 @@
     Cannot resolve unknown runtime type ‘t1’
     Use :print or :force to determine these types
     Relevant bindings include it :: t1 (bound at <interactive>:7:1)
-    Potential instances:
+    These potential instances exist:
       instance (Show a, Show b) => Show (Either a b)
         -- Defined in ‘Data.Either’
       instance Show All -- Defined in ‘Data.Monoid’
diff --git a/testsuite/tests/ghci.debugger/scripts/print019.stderr b/testsuite/tests/ghci.debugger/scripts/print019.stderr
index 5c1822456e..894c553805 100644
--- a/testsuite/tests/ghci.debugger/scripts/print019.stderr
+++ b/testsuite/tests/ghci.debugger/scripts/print019.stderr
@@ -4,7 +4,7 @@
     Cannot resolve unknown runtime type ‘a1’
     Use :print or :force to determine these types
     Relevant bindings include it :: a1 (bound at <interactive>:10:1)
-    Potential instances:
+    These potential instances exist:
       instance Show TyCon -- Defined in ‘Data.Typeable.Internal’
       instance Show TypeRep -- Defined in ‘Data.Typeable.Internal’
       instance Show Ordering -- Defined in ‘GHC.Show’
diff --git a/testsuite/tests/ghci/scripts/Defer02.stderr b/testsuite/tests/ghci/scripts/Defer02.stderr
index b2a5efefc3..4888e6958c 100644
--- a/testsuite/tests/ghci/scripts/Defer02.stderr
+++ b/testsuite/tests/ghci/scripts/Defer02.stderr
@@ -67,9 +67,10 @@
     In an equation for ‘j’: j = myOp 23
 
 ../../typecheck/should_run/Defer01.hs:43:10: warning:
-    No instance for (Num a1) arising from the literal ‘23’
-    The type variable ‘a1’ is ambiguous
-    Potential instances:
+    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’
diff --git a/testsuite/tests/indexed-types/should_fail/T4485.stderr b/testsuite/tests/indexed-types/should_fail/T4485.stderr
index f05eeace6e..92d8efc3cd 100644
--- a/testsuite/tests/indexed-types/should_fail/T4485.stderr
+++ b/testsuite/tests/indexed-types/should_fail/T4485.stderr
@@ -19,9 +19,10 @@ T4485.hs:50:15: error:
         asChild b = asChild $ (genElement "foo")
 
 T4485.hs:50:26: error:
-    No instance for (XMLGen m0) arising from a use of ‘genElement’
-    The type variable ‘m0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘m0’ arising from a use of ‘genElement’
+    prevents the constraint ‘(XMLGen m0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘m0’ should be.
+    These potential instance exist:
       instance XMLGen (IdentityT m) -- Defined at T4485.hs:37:10
     In the second argument of ‘($)’, namely ‘(genElement "foo")’
     In the expression: asChild $ (genElement "foo")
diff --git a/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr b/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr
index 75abc3b0e6..7faa9207a4 100644
--- a/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr
+++ b/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr
@@ -1,8 +1,9 @@
 
 overloadedlistsfail01.hs:5:8: error:
-    No instance for (Show a0) arising from a use of ‘print’
-    The type variable ‘a0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘a0’ arising from a use of ‘print’
+    prevents the constraint ‘(Show a0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘a0’ should be.
+    These potential instances exist:
       instance [safe] Show Version -- Defined in ‘Data.Version’
       instance Show Ordering -- Defined in ‘GHC.Show’
       instance Show Integer -- Defined in ‘GHC.Show’
@@ -12,9 +13,10 @@ overloadedlistsfail01.hs:5:8: error:
     In an equation for ‘main’: main = print [1]
 
 overloadedlistsfail01.hs:5:14: error:
-    No instance for (IsList a0) arising from an overloaded list
-    The type variable ‘a0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘a0’ arising from an overloaded list
+    prevents the constraint ‘(IsList a0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘a0’ should be.
+    These potential instances exist:
       instance IsList Version -- Defined in ‘GHC.Exts’
       instance IsList [a] -- Defined in ‘GHC.Exts’
     In the first argument of ‘print’, namely ‘[1]’
@@ -22,9 +24,10 @@ overloadedlistsfail01.hs:5:14: error:
     In an equation for ‘main’: main = print [1]
 
 overloadedlistsfail01.hs:5:15: error:
-    No instance for (Num (Item a0)) arising from the literal ‘1’
-    The type variable ‘a0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘a0’ arising from the literal ‘1’
+    prevents the constraint ‘(Num (Item a0))’ from being solved.
+    Probable fix: use a type annotation to specify what ‘a0’ 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’
diff --git a/testsuite/tests/quotes/TH_localname.stderr b/testsuite/tests/quotes/TH_localname.stderr
index c764f576ef..dfb1e41383 100644
--- a/testsuite/tests/quotes/TH_localname.stderr
+++ b/testsuite/tests/quotes/TH_localname.stderr
@@ -1,11 +1,12 @@
 
 TH_localname.hs:3:11: error:
-    No instance for (Lift t0) arising from a use of ‘lift’
-    The type variable ‘t0’ is ambiguous
+    Ambiguous type variable ‘t0’ arising from a use of ‘lift’
+    prevents the constraint ‘(Lift t0)’ from being solved.
     Relevant bindings include
       y :: t0 (bound at TH_localname.hs:3:6)
       x :: t0 -> ExpQ (bound at TH_localname.hs:3:1)
-    Potential instances:
+    Probable fix: use a type annotation to specify what ‘t0’ should be.
+    These potential instances exist:
       instance (Lift a, Lift b) => Lift (Either a b)
         -- Defined in ‘Language.Haskell.TH.Syntax’
       instance Lift Int16 -- Defined in ‘Language.Haskell.TH.Syntax’
diff --git a/testsuite/tests/rebindable/rebindable6.stderr b/testsuite/tests/rebindable/rebindable6.stderr
index b843f33bd7..cf280a961d 100644
--- a/testsuite/tests/rebindable/rebindable6.stderr
+++ b/testsuite/tests/rebindable/rebindable6.stderr
@@ -1,15 +1,16 @@
 
 rebindable6.hs:106:17: error:
-    No instance for (HasSeq (IO a -> t0 -> IO b))
-      arising from a do statement
+    Ambiguous type variable ‘t0’ arising from a do statement
+    prevents the constraint ‘(HasSeq
+                                (IO a -> t0 -> IO b))’ from being solved.
       (maybe you haven't applied a function to enough arguments?)
-    The type variable ‘t0’ is ambiguous
     Relevant bindings include
       g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
       f :: IO a (bound at rebindable6.hs:104:17)
       test_do :: IO a -> IO (Maybe b) -> IO b
         (bound at rebindable6.hs:104:9)
-    Potential instances:
+    Probable fix: use a type annotation to specify what ‘t0’ should be.
+    These potential instance exist:
       instance HasSeq (IO a -> IO b -> IO b)
         -- Defined at rebindable6.hs:52:18
     In a stmt of a 'do' block: f
@@ -24,11 +25,12 @@ rebindable6.hs:106:17: error:
                  return b }
 
 rebindable6.hs:107:17: error:
-    No instance for (HasFail ([Char] -> t1))
-      arising from a do statement
+    Ambiguous type variable ‘t1’ arising from a do statement
+    prevents the constraint ‘(HasFail
+                                ([Char] -> t1))’ from being solved.
       (maybe you haven't applied a function to enough arguments?)
-    The type variable ‘t1’ is ambiguous
-    Potential instances:
+    Probable fix: use a type annotation to specify what ‘t1’ should be.
+    These potential instance exist:
       instance HasFail (String -> IO a)
         -- Defined at rebindable6.hs:57:18
     In a stmt of a 'do' block: Just (b :: b) <- g
@@ -43,16 +45,16 @@ rebindable6.hs:107:17: error:
                  return b }
 
 rebindable6.hs:108:17: error:
-    No instance for (HasReturn (b -> t1))
-      arising from a use of ‘return’
+    Ambiguous type variable ‘t1’ arising from a use of ‘return’
+    prevents the constraint ‘(HasReturn (b -> t1))’ from being solved.
       (maybe you haven't applied a function to enough arguments?)
-    The type variable ‘t1’ is ambiguous
     Relevant bindings include
       b :: b (bound at rebindable6.hs:107:23)
       g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
       test_do :: IO a -> IO (Maybe b) -> IO b
         (bound at rebindable6.hs:104:9)
-    Potential instances:
+    Probable fix: use a type annotation to specify what ‘t1’ should be.
+    These potential instance exist:
       instance HasReturn (a -> IO a) -- Defined at rebindable6.hs:42:18
     In a stmt of a 'do' block: return b
     In the expression:
diff --git a/testsuite/tests/rename/should_fail/mc14.stderr b/testsuite/tests/rename/should_fail/mc14.stderr
index bb02f9bafb..bc7b7df291 100644
--- a/testsuite/tests/rename/should_fail/mc14.stderr
+++ b/testsuite/tests/rename/should_fail/mc14.stderr
@@ -1,7 +1,9 @@
+
 mc14.hs:14:16: error:
-    No instance for (Functor t0) arising from a use of ‘fmap’
-    The type variable ‘t0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘t0’ arising from a use of ‘fmap’
+    prevents the constraint ‘(Functor t0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘t0’ should be.
+    These potential instances exist:
       instance Functor IO -- Defined in ‘GHC.Base’
       instance Functor Maybe -- Defined in ‘GHC.Base’
       instance Functor ((->) r) -- Defined in ‘GHC.Base’
diff --git a/testsuite/tests/typecheck/should_compile/holes2.stderr b/testsuite/tests/typecheck/should_compile/holes2.stderr
index ad5b530fae..ee3d627438 100644
--- a/testsuite/tests/typecheck/should_compile/holes2.stderr
+++ b/testsuite/tests/typecheck/should_compile/holes2.stderr
@@ -1,8 +1,9 @@
 
 holes2.hs:3:5: warning:
-    No instance for (Show a0) arising from a use of ‘show’
-    The type variable ‘a0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘a0’ arising from a use of ‘show’
+    prevents the constraint ‘(Show a0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘a0’ should be.
+    These potential instances exist:
       instance Show Ordering -- Defined in ‘GHC.Show’
       instance Show Integer -- Defined in ‘GHC.Show’
       instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
diff --git a/testsuite/tests/typecheck/should_fail/T4921.stderr b/testsuite/tests/typecheck/should_fail/T4921.stderr
index 091d461328..42d5a8a363 100644
--- a/testsuite/tests/typecheck/should_fail/T4921.stderr
+++ b/testsuite/tests/typecheck/should_fail/T4921.stderr
@@ -1,18 +1,20 @@
 
 T4921.hs:10:9: error:
-    No instance for (C a0 b1) arising from a use of ‘f’
-    The type variables ‘b1’, ‘a0’ are ambiguous
+    Ambiguous type variables ‘b1’, ‘a0’ arising from a use of ‘f’
+    prevents the constraint ‘(C a0 b1)’ from being solved.
     Relevant bindings include x :: a0 (bound at T4921.hs:10:1)
-    Potential instances:
+    Probable fix: use a type annotation to specify what ‘b1’, ‘a0’ should be.
+    These potential instance exist:
       instance C Int Char -- Defined at T4921.hs:7:10
     In the first argument of ‘fst’, namely ‘f’
     In the expression: fst f
     In an equation for ‘x’: x = fst f
 
 T4921.hs:12:9: error:
-    No instance for (C Int b0) arising from a use of ‘f’
-    The type variable ‘b0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘b0’ arising from a use of ‘f’
+    prevents the constraint ‘(C Int b0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘b0’ should be.
+    These potential instance exist:
       instance C Int Char -- Defined at T4921.hs:7:10
     In the first argument of ‘fst’, namely ‘f’
     In the expression: fst f :: Int
diff --git a/testsuite/tests/typecheck/should_fail/T5858.stderr b/testsuite/tests/typecheck/should_fail/T5858.stderr
index 9c381d9bf6..7d974d88b7 100644
--- a/testsuite/tests/typecheck/should_fail/T5858.stderr
+++ b/testsuite/tests/typecheck/should_fail/T5858.stderr
@@ -1,9 +1,10 @@
 
 T5858.hs:11:7: error:
-    No instance for (InferOverloaded ([t0], [t1]))
-      arising from a use of ‘infer’
-    The type variables ‘t0’, ‘t1’ are ambiguous
-    Potential instances:
+    Ambiguous type variables ‘t0’, ‘t1’ arising from a use of ‘infer’
+    prevents the constraint ‘(InferOverloaded
+                                ([t0], [t1]))’ from being solved.
+    Probable fix: use a type annotation to specify what ‘t0’, ‘t1’ should be.
+    These potential instance exist:
       instance (t1 ~ String) => InferOverloaded (t1, t1)
         -- Defined at T5858.hs:8:10
     In the expression: infer ([], [])
diff --git a/testsuite/tests/typecheck/should_fail/T7857.stderr b/testsuite/tests/typecheck/should_fail/T7857.stderr
index f413eb50f2..e923a02472 100644
--- a/testsuite/tests/typecheck/should_fail/T7857.stderr
+++ b/testsuite/tests/typecheck/should_fail/T7857.stderr
@@ -5,7 +5,7 @@ T7857.hs:8:11: error:
       bound by the inferred type of g :: PrintfArg t => t -> b
       at T7857.hs:8:1-21
     The type variable ‘r0’ is ambiguous
-    Potential instances:
+    These potential instances exist:
       instance [safe] (a ~ ()) => PrintfType (IO a)
         -- Defined in ‘Text.Printf’
       instance [safe] (PrintfArg a, PrintfType r) => PrintfType (a -> r)
diff --git a/testsuite/tests/typecheck/should_fail/tcfail008.stderr b/testsuite/tests/typecheck/should_fail/tcfail008.stderr
index db70a632f4..d84c3b90e3 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail008.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail008.stderr
@@ -1,9 +1,10 @@
 
 tcfail008.hs:3:5: error:
-    No instance for (Num a0) arising from the literal ‘1’
-    The type variable ‘a0’ is ambiguous
+    Ambiguous type variable ‘a0’ arising from the literal ‘1’
+    prevents the constraint ‘(Num a0)’ from being solved.
     Relevant bindings include o :: [a0] (bound at tcfail008.hs:3:1)
-    Potential instances:
+    Probable fix: use a type annotation to specify what ‘a0’ 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’
diff --git a/testsuite/tests/typecheck/should_fail/tcfail040.stderr b/testsuite/tests/typecheck/should_fail/tcfail040.stderr
index 68e958ecab..6e0da922c5 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail040.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail040.stderr
@@ -1,8 +1,9 @@
 
 tcfail040.hs:19:5: error:
-    No instance for (ORD a0) arising from a use of ‘<<’
-    The type variable ‘a0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘a0’ arising from a use of ‘<<’
+    prevents the constraint ‘(ORD a0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘a0’ should be.
+    These potential instance exist:
       instance ORD (a -> b) -- Defined at tcfail040.hs:17:10
     In the first argument of ‘(===)’, namely ‘(<<)’
     In the expression: (<<) === (<<)
diff --git a/testsuite/tests/typecheck/should_fail/tcfail043.stderr b/testsuite/tests/typecheck/should_fail/tcfail043.stderr
index fe24adc4e4..c30b5bf854 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail043.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail043.stderr
@@ -1,12 +1,13 @@
 
 tcfail043.hs:38:17: error:
-    No instance for (Ord_ a0) arising from a use of ‘gt’
-    The type variable ‘a0’ is ambiguous
+    Ambiguous type variable ‘a0’ arising from a use of ‘gt’
+    prevents the constraint ‘(Ord_ a0)’ from being solved.
     Relevant bindings include
       bs :: [a0] (bound at tcfail043.hs:38:8)
       a :: a0 (bound at tcfail043.hs:38:6)
       search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)
-    Potential instances:
+    Probable fix: use a type annotation to specify what ‘a0’ should be.
+    These potential instance exist:
       instance Ord_ Int -- Defined at tcfail043.hs:34:10
     In the expression: gt (hd bs) a
     In the expression:
@@ -22,13 +23,14 @@ tcfail043.hs:38:17: error:
                if eq a (hd bs) then True else search a (tl bs)
 
 tcfail043.hs:40:25: error:
-    No instance for (Eq_ a0) arising from a use of ‘eq’
-    The type variable ‘a0’ is ambiguous
+    Ambiguous type variable ‘a0’ arising from a use of ‘eq’
+    prevents the constraint ‘(Eq_ a0)’ from being solved.
     Relevant bindings include
       bs :: [a0] (bound at tcfail043.hs:38:8)
       a :: a0 (bound at tcfail043.hs:38:6)
       search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)
-    Potential instances:
+    Probable fix: use a type annotation to specify what ‘a0’ should be.
+    These potential instances exist:
       instance Eq_ Int -- Defined at tcfail043.hs:20:10
       instance Eq_ a => Eq_ [a] -- Defined at tcfail043.hs:23:10
     In the expression: eq a (hd bs)
diff --git a/testsuite/tests/typecheck/should_fail/tcfail072.stderr b/testsuite/tests/typecheck/should_fail/tcfail072.stderr
index 3f40718428..65b157332d 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail072.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail072.stderr
@@ -6,7 +6,7 @@ tcfail072.hs:23:13: error:
                  g :: (Ord p, Ord q) => AB p q -> Bool
       at tcfail072.hs:22:6-38
     The type variable ‘p0’ is ambiguous
-    Potential instances:
+    These potential instances exist:
       instance Ord Ordering -- Defined in ‘GHC.Classes’
       instance Ord Integer
         -- Defined in ‘integer-gmp-1.0.0.0:GHC.Integer.Type’
diff --git a/testsuite/tests/typecheck/should_fail/tcfail128.stderr b/testsuite/tests/typecheck/should_fail/tcfail128.stderr
index 4ad7273c0b..1aab117592 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail128.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail128.stderr
@@ -1,9 +1,10 @@
 
 tcfail128.hs:18:16: error:
-    No instance for (Data.Array.Base.MArray b0 FlatVector IO)
-      arising from a use of ‘thaw’
-    The type variable ‘b0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘b0’ arising from a use of ‘thaw’
+    prevents the constraint ‘(Data.Array.Base.MArray
+                                b0 FlatVector IO)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘b0’ should be.
+    These potential instance exist:
       instance Data.Array.Base.MArray IOArray e IO
         -- Defined in ‘Data.Array.Base’
     In a stmt of a 'do' block: v <- thaw tmp
diff --git a/testsuite/tests/typecheck/should_fail/tcfail133.stderr b/testsuite/tests/typecheck/should_fail/tcfail133.stderr
index bba5889603..f61320f4c1 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail133.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail133.stderr
@@ -3,9 +3,10 @@ tcfail133.hs:2:61: warning:
     -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
 
 tcfail133.hs:68:7: error:
-    No instance for (Show r0) arising from a use of ‘show’
-    The type variable ‘r0’ is ambiguous
-    Potential instances:
+    Ambiguous type variable ‘r0’ arising from a use of ‘show’
+    prevents the constraint ‘(Show r0)’ from being solved.
+    Probable fix: use a type annotation to specify what ‘r0’ should be.
+    These potential instances exist:
       instance Show Ordering -- Defined in ‘GHC.Show’
       instance Show Integer -- Defined in ‘GHC.Show’
       instance (Show a, Show b, Number a, Digit b) => Show (a :@ b)
diff --git a/testsuite/tests/typecheck/should_fail/tcfail181.stderr b/testsuite/tests/typecheck/should_fail/tcfail181.stderr
index 70dbbd5508..47aeccc586 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail181.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail181.stderr
@@ -6,7 +6,7 @@ tcfail181.hs:17:9: error:
                wog :: Monad m => t -> Something (m Bool) e
       at tcfail181.hs:17:1-30
     The type variable ‘m0’ is ambiguous
-    Potential instances:
+    These potential instances exist:
       instance Monad IO -- Defined in ‘GHC.Base’
       instance Monad Maybe -- Defined in ‘GHC.Base’
       instance Monad ((->) r) -- Defined in ‘GHC.Base’