Narrow scope of special-case for unqualified printing of names in core libraries

Commit 547c597112954353cef7157cb0a389bc4f6303eb modifies the
pretty-printer to render names from a set of core packages (`base`,
`ghc-prim`, `template-haskell`) as unqualified. The idea here was that
many of these names typically are not in scope but are well-known by the
user and therefore qualification merely introduces noise.

This, however, is a very large hammer and potentially breaks any
consumer who relies on parsing GHC output (hence #11208). This commit
partially reverts this change, now only printing `Constraint` (which
appears quite often in errors) as unqualified.

Fixes #11208.

Updates tests in `array` submodule.

Test Plan: validate

Reviewers: hvr, thomie, austin

Subscribers: thomie

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

GHC Trac Issues: #11208

85 files changed, 1266 insertions, 1025 deletions

diff --git a/compiler/main/HscTypes.hs b/compiler/main/HscTypes.hs
index a3eda3abaa..40c99f6436 100644
--- a/compiler/main/HscTypes.hs
+++ b/compiler/main/HscTypes.hs
@@ -159,7 +159,9 @@ import CoAxiom
 import ConLike
 import DataCon
 import PatSyn
-import PrelNames        ( gHC_PRIM, ioTyConName, printName, mkInteractiveModule )
+import PrelNames        ( gHC_PRIM, ioTyConName, printName, mkInteractiveModule
+                        , eqTyConName )
+import TysWiredIn
 import Packages hiding  ( Version(..) )
 import DynFlags
 import DriverPhases     ( Phase, HscSource(..), isHsBootOrSig, hscSourceString )
@@ -1562,27 +1564,26 @@ mkPrintUnqualified dflags env = QueryQualify qual_name
                                              (mkQualPackage dflags)
   where
   qual_name mod occ
-        | [] <- unqual_gres
-        , moduleUnitId mod `elem` [primUnitId, baseUnitId, thUnitId]
-        , not (isDerivedOccName occ)
-        = NameUnqual   -- For names from ubiquitous packages that come with GHC, if
-                       -- there are no entities called unqualified 'occ', then
-                       -- print unqualified.  Doing so does not cause ambiguity,
-                       -- and it reduces the amount of qualification in error
-                       -- messages.  We can't do this for all packages, because we
-                       -- might get errors like "Can't unify T with T".  But the
-                       -- ubiquitous packages don't contain any such gratuitous
-                       -- name clashes.
-                       --
-                       -- A motivating example is 'Constraint'. It's often not in
-                       -- scope, but printing GHC.Prim.Constraint seems overkill.
-
         | [gre] <- unqual_gres
         , right_name gre
         = NameUnqual   -- If there's a unique entity that's in scope
                        -- unqualified with 'occ' AND that entity is
                        -- the right one, then we can use the unqualified name
 
+        | [] <- unqual_gres
+        , any is_name forceUnqualNames
+        , not (isDerivedOccName occ)
+        = NameUnqual   -- Don't qualify names that come from modules
+                       -- that come with GHC, often appear in error messages,
+                       -- but aren't typically in scope. Doing this does not
+                       -- cause ambiguity, and it reduces the amount of
+                       -- qualification in error messages thus improving
+                       -- readability.
+                       --
+                       -- A motivating example is 'Constraint'. It's often not
+                       -- in scope, but printing GHC.Prim.Constraint seems
+                       -- overkill.
+
         | [gre] <- qual_gres
         = NameQual (greQualModName gre)
 
@@ -1595,6 +1596,15 @@ mkPrintUnqualified dflags env = QueryQualify qual_name
         = NameNotInScope1   -- Can happen if 'f' is bound twice in the module
                             -- Eg  f = True; g = 0; f = False
       where
+        is_name :: Name -> Bool
+        is_name name = nameModule name == mod && nameOccName name == occ
+
+        forceUnqualNames :: [Name]
+        forceUnqualNames =
+          map tyConName [ constraintKindTyCon, heqTyCon, coercibleTyCon
+                        , starKindTyCon, unicodeStarKindTyCon, ipTyCon ]
+          ++ [ eqTyConName ]
+
         right_name gre = nameModule_maybe (gre_name gre) == Just mod
 
         unqual_gres = lookupGRE_RdrName (mkRdrUnqual occ) env
diff --git a/compiler/prelude/TysWiredIn.hs b/compiler/prelude/TysWiredIn.hs
index 8a4ca4d570..da1fa70f68 100644
--- a/compiler/prelude/TysWiredIn.hs
+++ b/compiler/prelude/TysWiredIn.hs
@@ -68,7 +68,8 @@ module TysWiredIn (
         -- * Kinds
         typeNatKindCon, typeNatKind, typeSymbolKindCon, typeSymbolKind,
         isLiftedTypeKindTyConName, liftedTypeKind, constraintKind,
-        starKindTyConName, unicodeStarKindTyConName,
+        starKindTyCon, starKindTyConName,
+        unicodeStarKindTyCon, unicodeStarKindTyConName,
         liftedTypeKindTyCon, constraintKindTyCon,
 
         -- * Parallel arrays
diff --git a/libraries/array b/libraries/array
-Subproject 4b43c95af80ed7e1567244527e5e459912d3e50
+Subproject f643793b3fbffd7419f403bedc65b7ac06dff0c
diff --git a/testsuite/tests/annotations/should_fail/annfail05.stderr b/testsuite/tests/annotations/should_fail/annfail05.stderr
index e9b281ecb8..237c238a8d 100644
--- a/testsuite/tests/annotations/should_fail/annfail05.stderr
+++ b/testsuite/tests/annotations/should_fail/annfail05.stderr
@@ -1,4 +1,5 @@
-

-annfail05.hs:11:1:

-    No instance for (Data NoInstances) arising from an annotation

-    In the annotation: {-# ANN f NoInstances #-}

+
+annfail05.hs:11:1: error:
+    • No instance for (Data.Data.Data NoInstances)
+        arising from an annotation
+    • In the annotation: {-# ANN f NoInstances #-}
diff --git a/testsuite/tests/annotations/should_fail/annfail08.stderr b/testsuite/tests/annotations/should_fail/annfail08.stderr
index 66e9c7e29b..6fafaf919e 100644
--- a/testsuite/tests/annotations/should_fail/annfail08.stderr
+++ b/testsuite/tests/annotations/should_fail/annfail08.stderr
@@ -1,10 +1,11 @@
 
 annfail08.hs:9:1: error:
-    No instance for (Data (a0 -> a0)) arising from an annotation
-      (maybe you haven't applied a function to enough arguments?)
-    In the annotation: {-# ANN f (id + 1) #-}
+    • No instance for (Data.Data.Data (a0 -> a0))
+        arising from an annotation
+        (maybe you haven't applied a function to enough arguments?)
+    • In the annotation: {-# ANN f (id + 1) #-}
 
 annfail08.hs:9:15: error:
-    No instance for (Num (a0 -> a0)) arising from a use of ‘+’
-      (maybe you haven't applied a function to enough arguments?)
-    In the annotation: {-# ANN f (id + 1) #-}
+    • No instance for (Num (a0 -> a0)) arising from a use of ‘+’
+        (maybe you haven't applied a function to enough arguments?)
+    • In the annotation: {-# ANN f (id + 1) #-}
diff --git a/testsuite/tests/annotations/should_fail/annfail10.stderr b/testsuite/tests/annotations/should_fail/annfail10.stderr
index 5c6f71b486..251f0c317c 100644
--- a/testsuite/tests/annotations/should_fail/annfail10.stderr
+++ b/testsuite/tests/annotations/should_fail/annfail10.stderr
@@ -1,29 +1,28 @@
 
 annfail10.hs:9:1: error:
-    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’
-      instance (Data (f a), Data a, Typeable f) => Data (Alt f a)
-        -- Defined in ‘Data.Data’
-      ...plus 39 others
-      (use -fprint-potential-instances to see them all)
-    In the annotation: {-# ANN f 1 #-}
+    • Ambiguous type variable ‘a0’ arising from an annotation
+      prevents the constraint ‘(Data.Data.Data a0)’ from being solved.
+      Probable fix: use a type annotation to specify what ‘a0’ should be.
+      These potential instances exist:
+        instance (Data.Data.Data a, Data.Data.Data b) =>
+                 Data.Data.Data (Either a b)
+          -- Defined in ‘Data.Data’
+        instance Data.Data.Data Ordering -- Defined in ‘Data.Data’
+        instance Data.Data.Data Integer -- Defined in ‘Data.Data’
+        ...plus 15 others
+        ...plus 24 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the annotation: {-# ANN f 1 #-}
 
 annfail10.hs:9:11: error:
-    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 (f :: k -> *) (a :: k).
-               Num (f a) =>
-               Num (Alt f a)
-        -- Defined in ‘Data.Monoid’
-      instance Num a => Num (Product a) -- Defined in ‘Data.Monoid’
-      instance Num a => Num (Sum a) -- Defined in ‘Data.Monoid’
-      ...plus 14 others
-      (use -fprint-potential-instances to see them all)
-    In the annotation: {-# ANN f 1 #-}
+    • 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 Num Integer -- Defined in ‘GHC.Num’
+        instance Num Double -- Defined in ‘GHC.Float’
+        instance Num Float -- Defined in ‘GHC.Float’
+        ...plus two others
+        ...plus 12 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the annotation: {-# ANN f 1 #-}
diff --git a/testsuite/tests/deSugar/should_compile/T2431.stderr b/testsuite/tests/deSugar/should_compile/T2431.stderr
index b89b3a868d..241a13c777 100644
--- a/testsuite/tests/deSugar/should_compile/T2431.stderr
+++ b/testsuite/tests/deSugar/should_compile/T2431.stderr
@@ -10,43 +10,44 @@ T2431.$WRefl [InlPrag=INLINE] :: forall a. a :~: a
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=0,unsat_ok=False,boring_ok=False)
-         Tmpl= \ (@ a) -> T2431.Refl @ a @ a @~ (<a>_N :: a ~# a)}]
-T2431.$WRefl = \ (@ a) -> T2431.Refl @ a @ a @~ (<a>_N :: a ~# a)
+         Tmpl= \ (@ a) -> T2431.Refl @ a @ a @~ (<a>_N :: a GHC.Prim.~# a)}]
+T2431.$WRefl =
+  \ (@ a) -> T2431.Refl @ a @ a @~ (<a>_N :: a GHC.Prim.~# a)
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a :: TrName
+a :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a = TrNameS "main"#
+a = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a1 :: TrName
+a1 :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a1 = TrNameS "T2431"#
+a1 = GHC.Types.TrNameS "T2431"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
-T2431.$trModule :: Module
+T2431.$trModule :: GHC.Types.Module
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-T2431.$trModule = Module a a1
+T2431.$trModule = GHC.Types.Module a a1
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a2 :: TrName
+a2 :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a2 = TrNameS "'Refl"#
+a2 = GHC.Types.TrNameS "'Refl"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-T2431.$tc'Refl :: TyCon
+T2431.$tc'Refl :: GHC.Types.TyCon
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-T2431.$tc'Refl = TyCon 0## 0## T2431.$trModule a2
+T2431.$tc'Refl = GHC.Types.TyCon 0## 0## T2431.$trModule a2
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a3 :: TrName
+a3 :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a3 = TrNameS ":~:"#
+a3 = GHC.Types.TrNameS ":~:"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-T2431.$tc:~: :: TyCon
+T2431.$tc:~: :: GHC.Types.TyCon
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-T2431.$tc:~: = TyCon 0## 0## T2431.$trModule a3
+T2431.$tc:~: = GHC.Types.TyCon 0## 0## T2431.$trModule a3
 
 -- RHS size: {terms: 4, types: 8, coercions: 0}
 absurd :: forall a. Int :~: Bool -> a
diff --git a/testsuite/tests/deriving/should_fail/T4846.stderr b/testsuite/tests/deriving/should_fail/T4846.stderr
index 5a7339bf21..3d3ccc4b86 100644
--- a/testsuite/tests/deriving/should_fail/T4846.stderr
+++ b/testsuite/tests/deriving/should_fail/T4846.stderr
@@ -1,11 +1,12 @@
 
 T4846.hs:29:1: error:
-    Couldn't match type ‘Bool’ with ‘BOOL’
-      arising from a use of ‘coerce’
-    In the expression: coerce (mkExpr :: Expr Bool) :: Expr BOOL
-    In an equation for ‘mkExpr’:
-        mkExpr = coerce (mkExpr :: Expr Bool) :: Expr BOOL
-    When typechecking the code for ‘mkExpr’
-      in a derived instance for ‘B BOOL’:
-      To see the code I am typechecking, use -ddump-deriv
-    In the instance declaration for ‘B BOOL’
+    • Couldn't match type ‘Bool’ with ‘BOOL’
+        arising from a use of ‘GHC.Prim.coerce’
+    • In the expression:
+          GHC.Prim.coerce (mkExpr :: Expr Bool) :: Expr BOOL
+      In an equation for ‘mkExpr’:
+          mkExpr = GHC.Prim.coerce (mkExpr :: Expr Bool) :: Expr BOOL
+      When typechecking the code for ‘mkExpr’
+        in a derived instance for ‘B BOOL’:
+        To see the code I am typechecking, use -ddump-deriv
+      In the instance declaration for ‘B BOOL’
diff --git a/testsuite/tests/ghc-api/annotations/T10268.stderr b/testsuite/tests/ghc-api/annotations/T10268.stderr
index cc879572a6..28ef021be0 100644
--- a/testsuite/tests/ghc-api/annotations/T10268.stderr
+++ b/testsuite/tests/ghc-api/annotations/T10268.stderr
@@ -1,8 +1,9 @@
-

-Test10268.hs:5:6: error: Variable not in scope: footemplate :: ExpQ

-

-Test10268.hs:7:14: error:

-    Not in scope: type constructor or class ‘Pattern’

-

-Test10268.hs:10:10: error:

-    Not in scope: type constructor or class ‘Pattern’

+
+Test10268.hs:5:6: error:
+    Variable not in scope: footemplate :: Language.Haskell.TH.Lib.ExpQ
+
+Test10268.hs:7:14: error:
+    Not in scope: type constructor or class ‘Pattern’
+
+Test10268.hs:10:10: error:
+    Not in scope: type constructor or class ‘Pattern’
diff --git a/testsuite/tests/ghci.debugger/scripts/break006.stderr b/testsuite/tests/ghci.debugger/scripts/break006.stderr
index f1567ed7ff..16ba5ec004 100644
--- a/testsuite/tests/ghci.debugger/scripts/break006.stderr
+++ b/testsuite/tests/ghci.debugger/scripts/break006.stderr
@@ -1,34 +1,30 @@
 
 <interactive>:5:1: error:
-    No instance for (Show t) arising from a use of ‘print’
-    Cannot resolve unknown runtime type ‘t’
-    Use :print or :force to determine these types
-    Relevant bindings include it :: t (bound at <interactive>:5:1)
-    These potential instances exist:
-      instance (Show a, Show b) => Show (Either a b)
-        -- Defined in ‘Data.Either’
-      instance Show All -- Defined in ‘Data.Monoid’
-      instance forall k (f :: k -> *) (a :: k).
-               Show (f a) =>
-               Show (Alt f a)
-        -- Defined in ‘Data.Monoid’
-      ...plus 36 others
-      (use -fprint-potential-instances to see them all)
-    In a stmt of an interactive GHCi command: print it
+    • No instance for (Show t) arising from a use of ‘print’
+      Cannot resolve unknown runtime type ‘t’
+      Use :print or :force to determine these types
+      Relevant bindings include it :: t (bound at <interactive>:5:1)
+      These potential instances exist:
+        instance (Show a, Show b) => Show (Either a b)
+          -- Defined in ‘Data.Either’
+        instance Show Ordering -- Defined in ‘GHC.Show’
+        instance Show Integer -- Defined in ‘GHC.Show’
+        ...plus 23 others
+        ...plus 13 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In a stmt of an interactive GHCi command: print it
 
 <interactive>:7:1: error:
-    No instance for (Show t) arising from a use of ‘print’
-    Cannot resolve unknown runtime type ‘t’
-    Use :print or :force to determine these types
-    Relevant bindings include it :: t (bound at <interactive>:7:1)
-    These potential instances exist:
-      instance (Show a, Show b) => Show (Either a b)
-        -- Defined in ‘Data.Either’
-      instance Show All -- Defined in ‘Data.Monoid’
-      instance forall k (f :: k -> *) (a :: k).
-               Show (f a) =>
-               Show (Alt f a)
-        -- Defined in ‘Data.Monoid’
-      ...plus 36 others
-      (use -fprint-potential-instances to see them all)
-    In a stmt of an interactive GHCi command: print it
+    • No instance for (Show t) arising from a use of ‘print’
+      Cannot resolve unknown runtime type ‘t’
+      Use :print or :force to determine these types
+      Relevant bindings include it :: t (bound at <interactive>:7:1)
+      These potential instances exist:
+        instance (Show a, Show b) => Show (Either a b)
+          -- Defined in ‘Data.Either’
+        instance Show Ordering -- Defined in ‘GHC.Show’
+        instance Show Integer -- Defined in ‘GHC.Show’
+        ...plus 23 others
+        ...plus 13 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In a stmt of an interactive GHCi command: print it
diff --git a/testsuite/tests/ghci.debugger/scripts/break024.stdout b/testsuite/tests/ghci.debugger/scripts/break024.stdout
index 62aa429cad..dc3bd73425 100644
--- a/testsuite/tests/ghci.debugger/scripts/break024.stdout
+++ b/testsuite/tests/ghci.debugger/scripts/break024.stdout
@@ -1,16 +1,19 @@
-Left user error (error)

-Stopped at <exception thrown>

-_exception :: e = _

-_exception = SomeException

-               (IOError Nothing UserError [] "error" Nothing Nothing)

-*** Exception: user error (error)

-Stopped at <exception thrown>

-_exception :: e = _

-_exception = SomeException

-               (IOError Nothing UserError [] "error" Nothing Nothing)

-*** Exception: user error (error)

-Stopped at <exception thrown>

-_exception :: e = _

-_exception = SomeException

-               (IOError Nothing UserError [] "error" Nothing Nothing)

-Left user error (error)

+Left user error (error)
+Stopped at <exception thrown>
+_exception :: e = _
+_exception = SomeException
+               (GHC.IO.Exception.IOError
+                  Nothing GHC.IO.Exception.UserError [] "error" Nothing Nothing)
+*** Exception: user error (error)
+Stopped at <exception thrown>
+_exception :: e = _
+_exception = SomeException
+               (GHC.IO.Exception.IOError
+                  Nothing GHC.IO.Exception.UserError [] "error" Nothing Nothing)
+*** Exception: user error (error)
+Stopped at <exception thrown>
+_exception :: e = _
+_exception = SomeException
+               (GHC.IO.Exception.IOError
+                  Nothing GHC.IO.Exception.UserError [] "error" Nothing Nothing)
+Left user error (error)
diff --git a/testsuite/tests/ghci.debugger/scripts/print019.stderr b/testsuite/tests/ghci.debugger/scripts/print019.stderr
index 3c0edbde5a..fa53d94701 100644
--- a/testsuite/tests/ghci.debugger/scripts/print019.stderr
+++ b/testsuite/tests/ghci.debugger/scripts/print019.stderr
@@ -1,13 +1,14 @@
 
 <interactive>:10:1: error:
-    No instance for (Show a1) arising from a use of ‘print’
-    Cannot resolve unknown runtime type ‘a1’
-    Use :print or :force to determine these types
-    Relevant bindings include it :: a1 (bound at <interactive>:10:1)
-    These potential instances exist:
-      instance Show TypeRep -- Defined in ‘Data.Typeable.Internal’
-      instance Show Module -- Defined in ‘GHC.Show’
-      instance Show Ordering -- Defined in ‘GHC.Show’
-      ...plus 32 others
-      (use -fprint-potential-instances to see them all)
-    In a stmt of an interactive GHCi command: print it
+    • No instance for (Show a1) arising from a use of ‘print’
+      Cannot resolve unknown runtime type ‘a1’
+      Use :print or :force to determine these types
+      Relevant bindings include it :: a1 (bound at <interactive>:10:1)
+      These potential instances exist:
+        instance Show TypeRep -- Defined in ‘Data.Typeable.Internal’
+        instance Show Ordering -- Defined in ‘GHC.Show’
+        instance Show TyCon -- Defined in ‘GHC.Show’
+        ...plus 30 others
+        ...plus two instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In a stmt of an interactive GHCi command: print it
diff --git a/testsuite/tests/ghci.debugger/scripts/print028.stdout b/testsuite/tests/ghci.debugger/scripts/print028.stdout
index 3e44dccbc8..93a80bc69d 100644
--- a/testsuite/tests/ghci.debugger/scripts/print028.stdout
+++ b/testsuite/tests/ghci.debugger/scripts/print028.stdout
@@ -1,5 +1,6 @@
-l = (_t1::[Maybe Integer])

-Just 1

-r = IORef (STRef

-             (GHC.Prim.MutVar# (Just 1 : (_t2::[Maybe Integer]))))

-r = IORef (STRef (GHC.Prim.MutVar# (Just 1 : _)))

+l = (_t1::[Maybe Integer])
+Just 1
+r = GHC.IORef.IORef (GHC.STRef.STRef
+                       (GHC.Prim.MutVar# (Just 1 : (_t2::[Maybe Integer]))))
+r = GHC.IORef.IORef (GHC.STRef.STRef
+                       (GHC.Prim.MutVar# (Just 1 : _)))
diff --git a/testsuite/tests/ghci.debugger/scripts/print033.stdout b/testsuite/tests/ghci.debugger/scripts/print033.stdout
index 1aa12c7465..4963c68366 100644
--- a/testsuite/tests/ghci.debugger/scripts/print033.stdout
+++ b/testsuite/tests/ghci.debugger/scripts/print033.stdout
@@ -1 +1,2 @@
-u = (_t1::(?callStack::CallStack) => ST s (forall s'. ST s' a))
+u = (_t1::(?callStack::GHC.Stack.Types.CallStack) =>
+          ST s (forall s'. ST s' a))
diff --git a/testsuite/tests/ghci/scripts/T11208.hs b/testsuite/tests/ghci/scripts/T11208.hs
new file mode 100644
index 0000000000..b6ddd167d5
--- /dev/null
+++ b/testsuite/tests/ghci/scripts/T11208.hs
@@ -0,0 +1,8 @@
+module T11208 where
+
+import qualified Prelude as P
+
+f n = n P.+ 1
+
+g h (P.Just x) = P.Just (h x)
+g _ P.Nothing  = P.Nothing
diff --git a/testsuite/tests/ghci/scripts/T11208.script b/testsuite/tests/ghci/scripts/T11208.script
new file mode 100644
index 0000000000..e177c59e0a
--- /dev/null
+++ b/testsuite/tests/ghci/scripts/T11208.script
@@ -0,0 +1,2 @@
+:load T11208
+:browse T11208
\ No newline at end of file
diff --git a/testsuite/tests/ghci/scripts/T11208.stdout b/testsuite/tests/ghci/scripts/T11208.stdout
new file mode 100644
index 0000000000..a00f202e41
--- /dev/null
+++ b/testsuite/tests/ghci/scripts/T11208.stdout
@@ -0,0 +1,2 @@
+f :: P.Num a => a -> a
+g :: (r -> a) -> P.Maybe r -> P.Maybe a
diff --git a/testsuite/tests/ghci/scripts/T2182ghci2.stderr b/testsuite/tests/ghci/scripts/T2182ghci2.stderr
index fde88e3c8a..5ebe106bfa 100644
--- a/testsuite/tests/ghci/scripts/T2182ghci2.stderr
+++ b/testsuite/tests/ghci/scripts/T2182ghci2.stderr
@@ -1,8 +1,10 @@
-

-<interactive>:7:1:

-    No instance for (Show Float) arising from a use of ‘print’

-    In a stmt of an interactive GHCi command: print it

-

-<interactive>:15:1:

-    No instance for (Show Float) arising from a use of ‘print’

-    In a stmt of an interactive GHCi command: print it

+
+<interactive>:7:1: error:
+    • No instance for (GHC.Show.Show Float)
+        arising from a use of ‘System.IO.print’
+    • In a stmt of an interactive GHCi command: System.IO.print it
+
+<interactive>:15:1: error:
+    • No instance for (GHC.Show.Show Float)
+        arising from a use of ‘System.IO.print’
+    • In a stmt of an interactive GHCi command: System.IO.print it
diff --git a/testsuite/tests/ghci/scripts/T7873.stdout b/testsuite/tests/ghci/scripts/T7873.stdout
index b7415d6222..3f15c0d333 100644
--- a/testsuite/tests/ghci/scripts/T7873.stdout
+++ b/testsuite/tests/ghci/scripts/T7873.stdout
@@ -1,4 +1,6 @@
-data D2 = MkD2 (forall (p :: Any -> *) (a :: Any). p a -> Int)
+data D2
+  = MkD2 (forall (p :: GHC.Prim.Any -> *) (a :: GHC.Prim.Any).
+          p a -> Int)
   	-- Defined at <interactive>:3:1
 data D3 = MkD3 (forall k (p :: k -> *) (a :: k). p a -> Int)
   	-- Defined at <interactive>:4:1
diff --git a/testsuite/tests/ghci/scripts/T8469.stdout b/testsuite/tests/ghci/scripts/T8469.stdout
index c052868ebb..cd7966ee66 100644
--- a/testsuite/tests/ghci/scripts/T8469.stdout
+++ b/testsuite/tests/ghci/scripts/T8469.stdout
@@ -1,10 +1,10 @@
-data Int = I# Int# 	-- Defined in ‘GHC.Types’

-instance Bounded Int -- Defined in ‘GHC.Enum’

-instance Enum Int -- Defined in ‘GHC.Enum’

-instance Eq Int -- Defined in ‘GHC.Classes’

-instance Integral Int -- Defined in ‘GHC.Real’

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

-instance Ord Int -- Defined in ‘GHC.Classes’

-instance Read Int -- Defined in ‘GHC.Read’

-instance Real Int -- Defined in ‘GHC.Real’

-instance Show Int -- Defined in ‘GHC.Show’

+data Int = GHC.Types.I# GHC.Prim.Int# 	-- Defined in ‘GHC.Types’
+instance Bounded Int -- Defined in ‘GHC.Enum’
+instance Enum Int -- Defined in ‘GHC.Enum’
+instance Eq Int -- Defined in ‘GHC.Classes’
+instance Integral Int -- Defined in ‘GHC.Real’
+instance Num Int -- Defined in ‘GHC.Num’
+instance Ord Int -- Defined in ‘GHC.Classes’
+instance Read Int -- Defined in ‘GHC.Read’
+instance Real Int -- Defined in ‘GHC.Real’
+instance Show Int -- Defined in ‘GHC.Show’
diff --git a/testsuite/tests/ghci/scripts/T8959.stdout b/testsuite/tests/ghci/scripts/T8959.stdout
index 77d1b7d63b..02b5f828c2 100644
--- a/testsuite/tests/ghci/scripts/T8959.stdout
+++ b/testsuite/tests/ghci/scripts/T8959.stdout
@@ -1,9 +1,11 @@
 lookup :: Eq a => a -> [(a, b)] -> Maybe b
 undefined :: (forall a. a -> a) -> a
-  :: (?callStack::CallStack) => (forall a1. a1 -> a1) -> a
+  :: (?callStack::GHC.Stack.Types.CallStack) =>
+     (forall a1. a1 -> a1) -> a
 lookup ∷ Eq a ⇒ a → [(a, b)] → Maybe b
 undefined :: (forall a. a -> a) -> a
-  ∷ (?callStack::CallStack) ⇒ (∀ a1. a1 → a1) → a
+  ∷ (?callStack::GHC.Stack.Types.CallStack) ⇒ (∀ a1. a1 → a1) → a
 lookup :: Eq a => a -> [(a, b)] -> Maybe b
 undefined :: (forall a. a -> a) -> a
-  :: (?callStack::CallStack) => (forall a1. a1 -> a1) -> a
+  :: (?callStack::GHC.Stack.Types.CallStack) =>
+     (forall a1. a1 -> a1) -> a
diff --git a/testsuite/tests/ghci/scripts/T9181.stdout b/testsuite/tests/ghci/scripts/T9181.stdout
index 0e9913966f..3482d54ba4 100644
--- a/testsuite/tests/ghci/scripts/T9181.stdout
+++ b/testsuite/tests/ghci/scripts/T9181.stdout
@@ -1,45 +1,64 @@
-type family (*) (a :: Nat) (b :: Nat)
-  Kind: Nat -> Nat -> Nat
-type family (+) (a :: Nat) (b :: Nat)
-  Kind: Nat -> Nat -> Nat
-type family (-) (a :: Nat) (b :: Nat)
-  Kind: Nat -> Nat -> Nat
-type (<=) (x :: Nat) (y :: Nat) = (x <=? y) ~ 'True
-type family (<=?) (a :: Nat) (b :: Nat)
-  Kind: Nat -> Nat -> Bool
-type family CmpNat (a :: Nat) (b :: Nat)
-  Kind: Nat -> Nat -> Ordering
-type family CmpSymbol (a :: Symbol) (b :: Symbol)
-  Kind: Symbol -> Symbol -> Ordering
-data ErrorMessage where
-  Text :: Symbol -> ErrorMessage
-  ShowType :: t -> ErrorMessage
-  (:<>:) :: ErrorMessage -> ErrorMessage -> ErrorMessage
-  (:$$:) :: ErrorMessage -> ErrorMessage -> ErrorMessage
-class KnownNat (n :: Nat) where
-  natSing :: SNat n
+type family (GHC.TypeLits.*) (a :: GHC.Types.Nat)
+                             (b :: GHC.Types.Nat)
+  Kind: GHC.Types.Nat -> GHC.Types.Nat -> GHC.Types.Nat
+type family (GHC.TypeLits.+) (a :: GHC.Types.Nat)
+                             (b :: GHC.Types.Nat)
+  Kind: GHC.Types.Nat -> GHC.Types.Nat -> GHC.Types.Nat
+type family (GHC.TypeLits.-) (a :: GHC.Types.Nat)
+                             (b :: GHC.Types.Nat)
+  Kind: GHC.Types.Nat -> GHC.Types.Nat -> GHC.Types.Nat
+type (GHC.TypeLits.<=) (x :: GHC.Types.Nat) (y :: GHC.Types.Nat) =
+  (x GHC.TypeLits.<=? y) ~ 'True
+type family (GHC.TypeLits.<=?) (a :: GHC.Types.Nat)
+                               (b :: GHC.Types.Nat)
+  Kind: GHC.Types.Nat -> GHC.Types.Nat -> Bool
+type family GHC.TypeLits.CmpNat (a :: GHC.Types.Nat)
+                                (b :: GHC.Types.Nat)
+  Kind: GHC.Types.Nat -> GHC.Types.Nat -> Ordering
+type family GHC.TypeLits.CmpSymbol (a :: GHC.Types.Symbol)
+                                   (b :: GHC.Types.Symbol)
+  Kind: GHC.Types.Symbol -> GHC.Types.Symbol -> Ordering
+data GHC.TypeLits.ErrorMessage where
+  GHC.TypeLits.Text :: GHC.Types.Symbol -> GHC.TypeLits.ErrorMessage
+  GHC.TypeLits.ShowType :: t -> GHC.TypeLits.ErrorMessage
+  (GHC.TypeLits.:<>:) :: GHC.TypeLits.ErrorMessage
+                         -> GHC.TypeLits.ErrorMessage -> GHC.TypeLits.ErrorMessage
+  (GHC.TypeLits.:$$:) :: GHC.TypeLits.ErrorMessage
+                         -> GHC.TypeLits.ErrorMessage -> GHC.TypeLits.ErrorMessage
+class GHC.TypeLits.KnownNat (n :: GHC.Types.Nat) where
+  GHC.TypeLits.natSing :: GHC.TypeLits.SNat n
   {-# MINIMAL natSing #-}
-class KnownSymbol (n :: Symbol) where
-  symbolSing :: SSymbol n
+class GHC.TypeLits.KnownSymbol (n :: GHC.Types.Symbol) where
+  GHC.TypeLits.symbolSing :: GHC.TypeLits.SSymbol n
   {-# MINIMAL symbolSing #-}
-data SomeNat where
-  SomeNat :: KnownNat n => (Proxy n) -> SomeNat
-data SomeSymbol where
-  SomeSymbol :: KnownSymbol n => (Proxy n) -> SomeSymbol
-type family TypeError (a :: ErrorMessage)
-  Kind: forall b1. ErrorMessage -> b1
-type family (^) (a :: Nat) (b :: Nat)
-  Kind: Nat -> Nat -> Nat
-natVal :: KnownNat n => proxy n -> Integer
-natVal' :: KnownNat n => Proxy# n -> Integer
-sameNat ::
-  (KnownNat a, KnownNat b) => Proxy a -> Proxy b -> Maybe (a :~: b)
-sameSymbol ::
-  (KnownSymbol a, KnownSymbol b) =>
-  Proxy a -> Proxy b -> Maybe (a :~: b)
-someNatVal :: Integer -> Maybe SomeNat
-someSymbolVal :: String -> SomeSymbol
-symbolVal :: KnownSymbol n => proxy n -> String
-symbolVal' :: KnownSymbol n => Proxy# n -> String
-data Nat
-data Symbol
+data GHC.TypeLits.SomeNat where
+  GHC.TypeLits.SomeNat :: GHC.TypeLits.KnownNat n =>
+                          (Data.Proxy.Proxy n) -> GHC.TypeLits.SomeNat
+data GHC.TypeLits.SomeSymbol where
+  GHC.TypeLits.SomeSymbol :: GHC.TypeLits.KnownSymbol n =>
+                             (Data.Proxy.Proxy n) -> GHC.TypeLits.SomeSymbol
+type family GHC.TypeLits.TypeError (a :: GHC.TypeLits.ErrorMessage)
+  Kind: forall b1. GHC.TypeLits.ErrorMessage -> b1
+type family (GHC.TypeLits.^) (a :: GHC.Types.Nat)
+                             (b :: GHC.Types.Nat)
+  Kind: GHC.Types.Nat -> GHC.Types.Nat -> GHC.Types.Nat
+GHC.TypeLits.natVal ::
+  GHC.TypeLits.KnownNat n => proxy n -> Integer
+GHC.TypeLits.natVal' ::
+  GHC.TypeLits.KnownNat n => GHC.Prim.Proxy# n -> Integer
+GHC.TypeLits.sameNat ::
+  (GHC.TypeLits.KnownNat a, GHC.TypeLits.KnownNat b) =>
+  Data.Proxy.Proxy a
+  -> Data.Proxy.Proxy b -> Maybe (a Data.Type.Equality.:~: b)
+GHC.TypeLits.sameSymbol ::
+  (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) =>
+  Data.Proxy.Proxy a
+  -> Data.Proxy.Proxy b -> Maybe (a Data.Type.Equality.:~: b)
+GHC.TypeLits.someNatVal :: Integer -> Maybe GHC.TypeLits.SomeNat
+GHC.TypeLits.someSymbolVal :: String -> GHC.TypeLits.SomeSymbol
+GHC.TypeLits.symbolVal ::
+  GHC.TypeLits.KnownSymbol n => proxy n -> String
+GHC.TypeLits.symbolVal' ::
+  GHC.TypeLits.KnownSymbol n => GHC.Prim.Proxy# n -> String
+data GHC.Types.Nat
+data GHC.Types.Symbol
diff --git a/testsuite/tests/ghci/scripts/T9881.stdout b/testsuite/tests/ghci/scripts/T9881.stdout
index 1fa697f102..6866a6a79c 100644
--- a/testsuite/tests/ghci/scripts/T9881.stdout
+++ b/testsuite/tests/ghci/scripts/T9881.stdout
@@ -1,31 +1,32 @@
-data Data.ByteString.Lazy.ByteString

-  = Data.ByteString.Lazy.Internal.Empty

-  | Data.ByteString.Lazy.Internal.Chunk {-# UNPACK #-}Data.ByteString.ByteString

-                                        Data.ByteString.Lazy.ByteString

-  	-- Defined in ‘Data.ByteString.Lazy.Internal’

-instance Eq Data.ByteString.Lazy.ByteString

-  -- Defined in ‘Data.ByteString.Lazy.Internal’

-instance Ord Data.ByteString.Lazy.ByteString

-  -- Defined in ‘Data.ByteString.Lazy.Internal’

-instance Read Data.ByteString.Lazy.ByteString

-  -- Defined in ‘Data.ByteString.Lazy.Internal’

-instance Show Data.ByteString.Lazy.ByteString

-  -- Defined in ‘Data.ByteString.Lazy.Internal’

-instance Monoid Data.ByteString.Lazy.ByteString

-  -- Defined in ‘Data.ByteString.Lazy.Internal’

-

-data Data.ByteString.ByteString

-  = Data.ByteString.Internal.PS {-# UNPACK #-}(ForeignPtr Word8)

-                                {-# UNPACK #-}Int

-                                {-# UNPACK #-}Int

-  	-- Defined in ‘Data.ByteString.Internal’

-instance Eq Data.ByteString.ByteString

-  -- Defined in ‘Data.ByteString.Internal’

-instance Ord Data.ByteString.ByteString

-  -- Defined in ‘Data.ByteString.Internal’

-instance Read Data.ByteString.ByteString

-  -- Defined in ‘Data.ByteString.Internal’

-instance Show Data.ByteString.ByteString

-  -- Defined in ‘Data.ByteString.Internal’

-instance Monoid Data.ByteString.ByteString

-  -- Defined in ‘Data.ByteString.Internal’

+data Data.ByteString.Lazy.ByteString
+  = Data.ByteString.Lazy.Internal.Empty
+  | Data.ByteString.Lazy.Internal.Chunk {-# UNPACK #-}Data.ByteString.ByteString
+                                        Data.ByteString.Lazy.ByteString
+  	-- Defined in ‘Data.ByteString.Lazy.Internal’
+instance Eq Data.ByteString.Lazy.ByteString
+  -- Defined in ‘Data.ByteString.Lazy.Internal’
+instance Ord Data.ByteString.Lazy.ByteString
+  -- Defined in ‘Data.ByteString.Lazy.Internal’
+instance Read Data.ByteString.Lazy.ByteString
+  -- Defined in ‘Data.ByteString.Lazy.Internal’
+instance Show Data.ByteString.Lazy.ByteString
+  -- Defined in ‘Data.ByteString.Lazy.Internal’
+instance Monoid Data.ByteString.Lazy.ByteString
+  -- Defined in ‘Data.ByteString.Lazy.Internal’
+
+data Data.ByteString.ByteString
+  = Data.ByteString.Internal.PS {-# UNPACK #-}(GHC.ForeignPtr.ForeignPtr
+                                                 GHC.Word.Word8)
+                                {-# UNPACK #-}Int
+                                {-# UNPACK #-}Int
+  	-- Defined in ‘Data.ByteString.Internal’
+instance Eq Data.ByteString.ByteString
+  -- Defined in ‘Data.ByteString.Internal’
+instance Ord Data.ByteString.ByteString
+  -- Defined in ‘Data.ByteString.Internal’
+instance Read Data.ByteString.ByteString
+  -- Defined in ‘Data.ByteString.Internal’
+instance Show Data.ByteString.ByteString
+  -- Defined in ‘Data.ByteString.Internal’
+instance Monoid Data.ByteString.ByteString
+  -- Defined in ‘Data.ByteString.Internal’
diff --git a/testsuite/tests/ghci/scripts/ghci008.stdout b/testsuite/tests/ghci/scripts/ghci008.stdout
index 20c7f0dcad..4cf7448e2b 100644
--- a/testsuite/tests/ghci/scripts/ghci008.stdout
+++ b/testsuite/tests/ghci/scripts/ghci008.stdout
@@ -1,37 +1,39 @@
-class Num a where

-  (+) :: a -> a -> a

-  ...

-  	-- Defined in ‘GHC.Num’

-infixl 6 +

-class Num a where

-  (+) :: a -> a -> a

-  ...

-  	-- Defined in ‘GHC.Num’

-infixl 6 +

-data Complex a = !a :+ !a 	-- Defined in ‘Data.Complex’

-infix 6 :+

-data Complex a = !a :+ !a 	-- Defined in ‘Data.Complex’

-infix 6 :+

-class (RealFrac a, Floating a) => RealFloat a where

-  floatRadix :: a -> Integer

-  floatDigits :: a -> Int

-  floatRange :: a -> (Int, Int)

-  decodeFloat :: a -> (Integer, Int)

-  encodeFloat :: Integer -> Int -> a

-  exponent :: a -> Int

-  significand :: a -> a

-  scaleFloat :: Int -> a -> a

-  isNaN :: a -> Bool

-  isInfinite :: a -> Bool

-  isDenormalized :: a -> Bool

-  isNegativeZero :: a -> Bool

-  isIEEE :: a -> Bool

-  atan2 :: a -> a -> a

-  {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat,

-              encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero,

-              isIEEE #-}

-  	-- Defined in ‘GHC.Float’

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

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

-isPrefixOf :: Eq a => [a] -> [a] -> Bool

-  	-- Defined in ‘base-4.9.0.0:Data.OldList’

+class Num a where
+  (+) :: a -> a -> a
+  ...
+  	-- Defined in ‘GHC.Num’
+infixl 6 +
+class Num a where
+  (+) :: a -> a -> a
+  ...
+  	-- Defined in ‘GHC.Num’
+infixl 6 +
+data Data.Complex.Complex a = !a Data.Complex.:+ !a
+  	-- Defined in ‘Data.Complex’
+infix 6 Data.Complex.:+
+data Data.Complex.Complex a = !a Data.Complex.:+ !a
+  	-- Defined in ‘Data.Complex’
+infix 6 Data.Complex.:+
+class (RealFrac a, Floating a) => RealFloat a where
+  floatRadix :: a -> Integer
+  floatDigits :: a -> Int
+  floatRange :: a -> (Int, Int)
+  decodeFloat :: a -> (Integer, Int)
+  encodeFloat :: Integer -> Int -> a
+  exponent :: a -> Int
+  significand :: a -> a
+  scaleFloat :: Int -> a -> a
+  isNaN :: a -> Bool
+  isInfinite :: a -> Bool
+  isDenormalized :: a -> Bool
+  isNegativeZero :: a -> Bool
+  isIEEE :: a -> Bool
+  atan2 :: a -> a -> a
+  {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat,
+              encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero,
+              isIEEE #-}
+  	-- Defined in ‘GHC.Float’
+instance RealFloat Float -- Defined in ‘GHC.Float’
+instance RealFloat Double -- Defined in ‘GHC.Float’
+base-4.9.0.0:Data.OldList.isPrefixOf :: Eq a => [a] -> [a] -> Bool
+  	-- Defined in ‘base-4.9.0.0:Data.OldList’
diff --git a/testsuite/tests/ghci/scripts/ghci013.stdout b/testsuite/tests/ghci/scripts/ghci013.stdout
index d5afe0a691..b7065c5169 100644
--- a/testsuite/tests/ghci/scripts/ghci013.stdout
+++ b/testsuite/tests/ghci/scripts/ghci013.stdout
@@ -1 +1,2 @@
-f :: (?callStack::CallStack, Monad m) => (m a, r) -> m b
+f :: (?callStack::GHC.Stack.Types.CallStack, Monad m) =>
+     (m a, r) -> m b
diff --git a/testsuite/tests/ghci/scripts/ghci019.stderr b/testsuite/tests/ghci/scripts/ghci019.stderr
index 10f6a54bfe..aedf854e8a 100644
--- a/testsuite/tests/ghci/scripts/ghci019.stderr
+++ b/testsuite/tests/ghci/scripts/ghci019.stderr
@@ -1,5 +1,5 @@
-

-ghci019.hs:9:10: Warning:

-    No explicit implementation for

-      either ‘==’ or ‘/=’

-    In the instance declaration for ‘Eq Foo’

+
+ghci019.hs:9:10: warning:
+    • No explicit implementation for
+        either ‘Prelude.==’ or ‘Prelude./=’
+    • In the instance declaration for ‘Prelude.Eq Foo’
diff --git a/testsuite/tests/ghci/scripts/ghci019.stdout b/testsuite/tests/ghci/scripts/ghci019.stdout
index 5c8b242339..d03720d2b5 100644
--- a/testsuite/tests/ghci/scripts/ghci019.stdout
+++ b/testsuite/tests/ghci/scripts/ghci019.stdout
@@ -1,2 +1,2 @@
 data Foo = Foo 	-- Defined at ghci019.hs:8:1
-instance [safe] Eq Foo -- Defined at ghci019.hs:9:10
+instance [safe] Prelude.Eq Foo -- Defined at ghci019.hs:9:10
diff --git a/testsuite/tests/ghci/scripts/ghci023.stdout b/testsuite/tests/ghci/scripts/ghci023.stdout
index 61a859a73c..334b67d9fe 100644
--- a/testsuite/tests/ghci/scripts/ghci023.stdout
+++ b/testsuite/tests/ghci/scripts/ghci023.stdout
@@ -3,15 +3,15 @@
 (1,2,3)
 -- layout rule instead of explicit braces and semicolons works too
 (1,2,3)
-catMaybes :: [Maybe a] -> [a]
-fromJust :: Maybe a -> a
-fromMaybe :: a -> Maybe a -> a
-isJust :: Maybe a -> Bool
-isNothing :: Maybe a -> Bool
-listToMaybe :: [a] -> Maybe a
-mapMaybe :: (a -> Maybe b) -> [a] -> [b]
+Data.Maybe.catMaybes :: [Maybe a] -> [a]
+Data.Maybe.fromJust :: Maybe a -> a
+Data.Maybe.fromMaybe :: a -> Maybe a -> a
+Data.Maybe.isJust :: Maybe a -> Bool
+Data.Maybe.isNothing :: Maybe a -> Bool
+Data.Maybe.listToMaybe :: [a] -> Maybe a
+Data.Maybe.mapMaybe :: (a -> Maybe b) -> [a] -> [b]
 maybe :: b -> (a -> b) -> Maybe a -> b
-maybeToList :: Maybe a -> [a]
+Data.Maybe.maybeToList :: Maybe a -> [a]
 data Maybe a = Nothing | Just a
 -- via readFile
 (True,False)
diff --git a/testsuite/tests/ghci/scripts/ghci025.stdout b/testsuite/tests/ghci/scripts/ghci025.stdout
index fc9bd6e2b1..80c4d4b7a5 100644
--- a/testsuite/tests/ghci/scripts/ghci025.stdout
+++ b/testsuite/tests/ghci/scripts/ghci025.stdout
@@ -1,117 +1,119 @@
--- test :browse! functionality

-:browse! *T

--- defined locally

-T.length :: T.Integer

-class N a

-class S a

-class C a b where

-  c1 :: N b => a -> b

-  c2 :: (N b, S b) => a -> b

-  c3 :: a1 -> b

-  c4 :: a1 -> b

-  {-# MINIMAL c1, c2, c3, c4 #-}

-c1 :: (C a b, N b) => a -> b

-c2 :: (C a b, N b, S b) => a -> b

-c3 :: C a b => forall a. a -> b

-c4 :: C a b => forall a1. a1 -> b

--- imported via Control.Monad

-class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where

-  mzero :: m a

-  mplus :: m a -> m a -> m a

-mplus :: MonadPlus m => forall a. m a -> m a -> m a

-mzero :: MonadPlus m => forall a. m a

--- imported via Control.Monad, Prelude

-(>>) :: Monad m => forall a b. m a -> m b -> m b

-(>>=) :: Monad m => forall a b. m a -> (a -> m b) -> m b

-fail :: Monad m => forall a. String -> m a

-return :: Monad m => forall a. a -> m a

--- imported via Control.Monad, Prelude, T

-class Applicative m => Monad (m :: * -> *) where

-  (>>=) :: m a -> (a -> m b) -> m b

-  (>>) :: m a -> m b -> m b

-  return :: a -> m a

-  fail :: String -> m a

-  {-# MINIMAL (>>=) #-}

--- imported via Data.Maybe

-catMaybes :: [Maybe a] -> [a]

-fromJust :: Maybe a -> a

-fromMaybe :: a -> Maybe a -> a

-isJust :: Maybe a -> Bool

-isNothing :: Maybe a -> Bool

-listToMaybe :: [a] -> Maybe a

-mapMaybe :: (a -> Maybe b) -> [a] -> [b]

-maybe :: b -> (a -> b) -> Maybe a -> b

-maybeToList :: Maybe a -> [a]

--- imported via Data.Maybe, Prelude

-Just :: a -> Maybe a

-data Maybe a = Nothing | Just a

-Nothing :: Maybe a

--- imported via Prelude

-(+) :: Num a => a -> a -> a

-(=<<) :: Monad m => (a -> m b) -> m a -> m b

-class Eq a where

-  (==) :: a -> a -> Bool

-  (/=) :: a -> a -> Bool

-  {-# MINIMAL (==) | (/=) #-}

--- imported via Prelude, T

-Prelude.length :: Foldable t => forall a. t a -> Int

--- imported via T

-data T.Integer

-  = integer-gmp-1.0.0.0:GHC.Integer.Type.S# !Int#

-  | integer-gmp-1.0.0.0:GHC.Integer.Type.Jp# {-# UNPACK #-}integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat

-  | integer-gmp-1.0.0.0:GHC.Integer.Type.Jn# {-# UNPACK #-}integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat

-T.length :: Data.ByteString.Internal.ByteString -> Int

-:browse! T

--- defined locally

-T.length :: T.Integer

-class N a

-class S a

-class C a b where

-  c1 :: N b => a -> b

-  c2 :: (N b, S b) => a -> b

-  c3 :: a1 -> b

-  c4 :: a1 -> b

-  {-# MINIMAL c1, c2, c3, c4 #-}

-c1 :: (C a b, N b) => a -> b

-c2 :: (C a b, N b, S b) => a -> b

-c3 :: C a b => forall a. a -> b

-c4 :: C a b => forall a1. a1 -> b

-:browse! T -- with -fprint-explicit-foralls

--- defined locally

-T.length :: T.Integer

-class N a

-class S a

-class C a b where

-  c1 :: N b => a -> b

-  c2 :: (N b, S b) => a -> b

-  c3 :: forall a1. a1 -> b

-  c4 :: forall a1. a1 -> b

-  {-# MINIMAL c1, c2, c3, c4 #-}

-c1 :: forall a b. (C a b, N b) => a -> b

-c2 :: forall a b. (C a b, N b, S b) => a -> b

-c3 :: forall a b. C a b => forall a. a -> b

-c4 :: forall a b. C a b => forall a1. a1 -> b

--- test :browse! <target> relative to different contexts

-:browse! Ghci025C -- from *Ghci025C>

--- defined locally

-g :: forall a. Num a => a -> a

-h :: forall a. Integral a => a -> a

--- imported via Ghci025D

-f :: forall a. Num a => a -> a

-:browse! Ghci025C -- from *Ghci025B>, after :add Ghci025B

--- imported via Ghci025C

-g :: forall a. Num a => a -> a

-h :: forall a. Integral a => a -> a

-f :: forall a. Num a => a -> a

-:browse! Ghci025C -- from *Ghci025C>, after :m *Ghci025C

--- defined locally

-g :: forall a. Num a => a -> a

-h :: forall a. Integral a => a -> a

--- imported via Ghci025D

-f :: forall a. Num a => a -> a

-:browse! Ghci025C -- from *Ghci025D>, after :m *Ghci025D

--- not currently imported

-Ghci025C.g :: forall a. Num a => a -> a

-Ghci025C.h :: forall a. Integral a => a -> a

--- defined locally

-f :: forall a. Num a => a -> a

+-- test :browse! functionality
+:browse! *T
+-- defined locally
+T.length :: T.Integer
+class N a
+class S a
+class C a b where
+  c1 :: N b => a -> b
+  c2 :: (N b, S b) => a -> b
+  c3 :: a1 -> b
+  c4 :: a1 -> b
+  {-# MINIMAL c1, c2, c3, c4 #-}
+c1 :: (C a b, N b) => a -> b
+c2 :: (C a b, N b, S b) => a -> b
+c3 :: C a b => forall a. a -> b
+c4 :: C a b => forall a1. a1 -> b
+-- imported via Control.Monad
+class (GHC.Base.Alternative m, Monad m) =>
+      MonadPlus (m :: * -> *) where
+  mzero :: m a
+  mplus :: m a -> m a -> m a
+mplus :: MonadPlus m => forall a. m a -> m a -> m a
+mzero :: MonadPlus m => forall a. m a
+-- imported via Control.Monad, Prelude
+(>>) :: Monad m => forall a b. m a -> m b -> m b
+(>>=) :: Monad m => forall a b. m a -> (a -> m b) -> m b
+fail :: Monad m => forall a. GHC.Base.String -> m a
+return :: Monad m => forall a. a -> m a
+-- imported via Control.Monad, Prelude, T
+class GHC.Base.Applicative m => Monad (m :: * -> *) where
+  (>>=) :: m a -> (a -> m b) -> m b
+  (>>) :: m a -> m b -> m b
+  return :: a -> m a
+  fail :: GHC.Base.String -> m a
+  {-# MINIMAL (>>=) #-}
+-- imported via Data.Maybe
+catMaybes :: [Maybe a] -> [a]
+fromJust :: Maybe a -> a
+fromMaybe :: a -> Maybe a -> a
+isJust :: Maybe a -> GHC.Types.Bool
+isNothing :: Maybe a -> GHC.Types.Bool
+listToMaybe :: [a] -> Maybe a
+mapMaybe :: (a -> Maybe b) -> [a] -> [b]
+maybe :: b -> (a -> b) -> Maybe a -> b
+maybeToList :: Maybe a -> [a]
+-- imported via Data.Maybe, Prelude
+Just :: a -> Maybe a
+data Maybe a = Nothing | Just a
+Nothing :: Maybe a
+-- imported via Prelude
+(+) :: GHC.Num.Num a => a -> a -> a
+(=<<) :: Monad m => (a -> m b) -> m a -> m b
+class Eq a where
+  (GHC.Classes.==) :: a -> a -> GHC.Types.Bool
+  (GHC.Classes./=) :: a -> a -> GHC.Types.Bool
+  {-# MINIMAL (==) | (/=) #-}
+-- imported via Prelude, T
+Prelude.length ::
+  Data.Foldable.Foldable t => forall a. t a -> GHC.Types.Int
+-- imported via T
+data T.Integer
+  = integer-gmp-1.0.0.0:GHC.Integer.Type.S# !GHC.Prim.Int#
+  | integer-gmp-1.0.0.0:GHC.Integer.Type.Jp# {-# UNPACK #-}integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat
+  | integer-gmp-1.0.0.0:GHC.Integer.Type.Jn# {-# UNPACK #-}integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat
+T.length :: Data.ByteString.Internal.ByteString -> GHC.Types.Int
+:browse! T
+-- defined locally
+T.length :: T.Integer
+class N a
+class S a
+class C a b where
+  c1 :: N b => a -> b
+  c2 :: (N b, S b) => a -> b
+  c3 :: a1 -> b
+  c4 :: a1 -> b
+  {-# MINIMAL c1, c2, c3, c4 #-}
+c1 :: (C a b, N b) => a -> b
+c2 :: (C a b, N b, S b) => a -> b
+c3 :: C a b => forall a. a -> b
+c4 :: C a b => forall a1. a1 -> b
+:browse! T -- with -fprint-explicit-foralls
+-- defined locally
+T.length :: T.Integer
+class N a
+class S a
+class C a b where
+  c1 :: N b => a -> b
+  c2 :: (N b, S b) => a -> b
+  c3 :: forall a1. a1 -> b
+  c4 :: forall a1. a1 -> b
+  {-# MINIMAL c1, c2, c3, c4 #-}
+c1 :: forall a b. (C a b, N b) => a -> b
+c2 :: forall a b. (C a b, N b, S b) => a -> b
+c3 :: forall a b. C a b => forall a. a -> b
+c4 :: forall a b. C a b => forall a1. a1 -> b
+-- test :browse! <target> relative to different contexts
+:browse! Ghci025C -- from *Ghci025C>
+-- defined locally
+g :: forall a. Num a => a -> a
+h :: forall a. Integral a => a -> a
+-- imported via Ghci025D
+f :: forall a. Num a => a -> a
+:browse! Ghci025C -- from *Ghci025B>, after :add Ghci025B
+-- imported via Ghci025C
+g :: forall a. Num a => a -> a
+h :: forall a. Integral a => a -> a
+f :: forall a. Num a => a -> a
+:browse! Ghci025C -- from *Ghci025C>, after :m *Ghci025C
+-- defined locally
+g :: forall a. Num a => a -> a
+h :: forall a. Integral a => a -> a
+-- imported via Ghci025D
+f :: forall a. Num a => a -> a
+:browse! Ghci025C -- from *Ghci025D>, after :m *Ghci025D
+-- not currently imported
+Ghci025C.g :: forall a. Num a => a -> a
+Ghci025C.h :: forall a. Integral a => a -> a
+-- defined locally
+f :: forall a. Num a => a -> a
diff --git a/testsuite/tests/ghci/scripts/ghci027.stdout b/testsuite/tests/ghci/scripts/ghci027.stdout
index 33b138d2da..bbe355c17a 100644
--- a/testsuite/tests/ghci/scripts/ghci027.stdout
+++ b/testsuite/tests/ghci/scripts/ghci027.stdout
@@ -1,6 +1,8 @@
-class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where

-  ...

-  mplus :: m a -> m a -> m a

-class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where

-  ...

-  mplus :: m a -> m a -> m a

+class (GHC.Base.Alternative m, GHC.Base.Monad m) =>
+      GHC.Base.MonadPlus (m :: * -> *) where
+  ...
+  mplus :: m a -> m a -> m a
+class (GHC.Base.Alternative m, GHC.Base.Monad m) =>
+      GHC.Base.MonadPlus (m :: * -> *) where
+  ...
+  Control.Monad.mplus :: m a -> m a -> m a
diff --git a/testsuite/tests/ghci/scripts/ghci046.stdout b/testsuite/tests/ghci/scripts/ghci046.stdout
index 8b112976af..da71a9a73d 100644
--- a/testsuite/tests/ghci/scripts/ghci046.stdout
+++ b/testsuite/tests/ghci/scripts/ghci046.stdout
@@ -2,5 +2,5 @@ AND HTrue HTrue :: *
 = HTrue
 AND (OR HFalse HTrue) (OR HTrue HFalse) :: *
 = HTrue
-t :: (?callStack::CallStack) => HTrue
-t :: (?callStack::CallStack) => HFalse
+t :: (?callStack::GHC.Stack.Types.CallStack) => HTrue
+t :: (?callStack::GHC.Stack.Types.CallStack) => HFalse
diff --git a/testsuite/tests/ghci/scripts/ghci055.stdout b/testsuite/tests/ghci/scripts/ghci055.stdout
index 6011c68f26..c7450d0def 100644
--- a/testsuite/tests/ghci/scripts/ghci055.stdout
+++ b/testsuite/tests/ghci/scripts/ghci055.stdout
@@ -1,3 +1,3 @@
 x = _
-x :: ?callStack::CallStack => r = _
+x :: ?callStack::GHC.Stack.Types.CallStack => r = _
 y :: Integer = 3
diff --git a/testsuite/tests/module/mod87.stderr b/testsuite/tests/module/mod87.stderr
index 60adc95676..504075b47c 100644
--- a/testsuite/tests/module/mod87.stderr
+++ b/testsuite/tests/module/mod87.stderr
@@ -1,5 +1,5 @@
 
 mod87.hs:4:5: error:
-    Data constructor not in scope: Left :: Char -> t
-    Perhaps you want to add ‘Left’ to the import list in the import of
-    ‘Prelude’ (mod87.hs:3:1-22).
+    • Data constructor not in scope: Left :: GHC.Types.Char -> t
+    • Perhaps you want to add ‘Left’ to the import list
+      in the import of ‘Prelude’ (mod87.hs:3:1-22).
diff --git a/testsuite/tests/module/mod97.stderr b/testsuite/tests/module/mod97.stderr
index 83a4527427..f5cec79104 100644
--- a/testsuite/tests/module/mod97.stderr
+++ b/testsuite/tests/module/mod97.stderr
@@ -1,5 +1,6 @@
 
 mod97.hs:4:9: error:
-    Variable not in scope: (==) :: Char -> Char -> t
-    Perhaps you want to add ‘==’ to the import list in the import of
-    ‘Prelude’ (mod97.hs:3:1-18).
+    • Variable not in scope:
+        (==) :: GHC.Types.Char -> GHC.Types.Char -> t
+    • Perhaps you want to add ‘==’ to the import list in the import of
+      ‘Prelude’ (mod97.hs:3:1-18).
diff --git a/testsuite/tests/numeric/should_compile/T7116.stdout b/testsuite/tests/numeric/should_compile/T7116.stdout
index c9d744d6be..f64b8414b3 100644
--- a/testsuite/tests/numeric/should_compile/T7116.stdout
+++ b/testsuite/tests/numeric/should_compile/T7116.stdout
@@ -3,31 +3,32 @@
 Result size of Tidy Core = {terms: 32, types: 17, coercions: 0}
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T7116.$trModule2 :: TrName
+T7116.$trModule2 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 20}]
-T7116.$trModule2 = TrNameS "main"#
+T7116.$trModule2 = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T7116.$trModule1 :: TrName
+T7116.$trModule1 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T7116.$trModule1 = TrNameS "T7116"#
+T7116.$trModule1 = GHC.Types.TrNameS "T7116"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
-T7116.$trModule :: Module
+T7116.$trModule :: GHC.Types.Module
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
-T7116.$trModule = Module T7116.$trModule2 T7116.$trModule1
+T7116.$trModule =
+  GHC.Types.Module T7116.$trModule2 T7116.$trModule1
 
 -- RHS size: {terms: 8, types: 3, coercions: 0}
 dr :: Double -> Double
@@ -39,10 +40,14 @@ dr :: Double -> Double
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
          Tmpl= \ (x [Occ=Once!] :: Double) ->
-                 case x of _ [Occ=Dead] { D# x1 -> D# (+## x1 x1) }}]
+                 case x of _ [Occ=Dead] { GHC.Types.D# x1 ->
+                 GHC.Types.D# (GHC.Prim.+## x1 x1)
+                 }}]
 dr =
   \ (x :: Double) ->
-    case x of _ [Occ=Dead] { D# x1 -> D# (+## x1 x1) }
+    case x of _ [Occ=Dead] { GHC.Types.D# x1 ->
+    GHC.Types.D# (GHC.Prim.+## x1 x1)
+    }
 
 -- RHS size: {terms: 1, types: 0, coercions: 0}
 dl :: Double -> Double
@@ -54,7 +59,9 @@ dl :: Double -> Double
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
          Tmpl= \ (x [Occ=Once!] :: Double) ->
-                 case x of _ [Occ=Dead] { D# y -> D# (+## y y) }}]
+                 case x of _ [Occ=Dead] { GHC.Types.D# y ->
+                 GHC.Types.D# (GHC.Prim.+## y y)
+                 }}]
 dl = dr
 
 -- RHS size: {terms: 8, types: 3, coercions: 0}
@@ -67,10 +74,14 @@ fr :: Float -> Float
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
          Tmpl= \ (x [Occ=Once!] :: Float) ->
-                 case x of _ [Occ=Dead] { F# x1 -> F# (plusFloat# x1 x1) }}]
+                 case x of _ [Occ=Dead] { GHC.Types.F# x1 ->
+                 GHC.Types.F# (GHC.Prim.plusFloat# x1 x1)
+                 }}]
 fr =
   \ (x :: Float) ->
-    case x of _ [Occ=Dead] { F# x1 -> F# (plusFloat# x1 x1) }
+    case x of _ [Occ=Dead] { GHC.Types.F# x1 ->
+    GHC.Types.F# (GHC.Prim.plusFloat# x1 x1)
+    }
 
 -- RHS size: {terms: 1, types: 0, coercions: 0}
 fl :: Float -> Float
@@ -82,7 +93,9 @@ fl :: Float -> Float
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
          Tmpl= \ (x [Occ=Once!] :: Float) ->
-                 case x of _ [Occ=Dead] { F# y -> F# (plusFloat# y y) }}]
+                 case x of _ [Occ=Dead] { GHC.Types.F# y ->
+                 GHC.Types.F# (GHC.Prim.plusFloat# y y)
+                 }}]
 fl = fr
 
 
diff --git a/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr b/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr
index dbc250d794..7a43f4f778 100644
--- a/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr
+++ b/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr
@@ -1,38 +1,41 @@
 
 overloadedlistsfail01.hs:5:8: error:
-    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 Module -- Defined in ‘GHC.Show’
-      instance Show Ordering -- Defined in ‘GHC.Show’
-      ...plus 26 others
-      (use -fprint-potential-instances to see them all)
-    In the expression: print [1]
-    In an equation for ‘main’: main = print [1]
+    • 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 Show Ordering -- Defined in ‘GHC.Show’
+        instance Show Integer -- Defined in ‘GHC.Show’
+        instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
+        ...plus 22 others
+        ...plus four instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: print [1]
+      In an equation for ‘main’: main = print [1]
 
 overloadedlistsfail01.hs:5:14: error:
-    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]’
-    In the expression: print [1]
-    In an equation for ‘main’: main = print [1]
+    • Ambiguous type variable ‘a0’ arising from an overloaded list
+      prevents the constraint ‘(GHC.Exts.IsList a0)’ from being solved.
+      Probable fix: use a type annotation to specify what ‘a0’ should be.
+      These potential instances exist:
+        instance GHC.Exts.IsList [a] -- Defined in ‘GHC.Exts’
+        ...plus one instance involving out-of-scope types
+        (use -fprint-potential-instances to see them all)
+    • In the first argument of ‘print’, namely ‘[1]’
+      In the expression: print [1]
+      In an equation for ‘main’: main = print [1]
 
 overloadedlistsfail01.hs:5:15: error:
-    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’
-      ...plus two others
-      (use -fprint-potential-instances to see them all)
-    In the expression: 1
-    In the first argument of ‘print’, namely ‘[1]’
-    In the expression: print [1]
+    • Ambiguous type variable ‘a0’ arising from the literal ‘1’
+      prevents the constraint ‘(Num
+                                  (GHC.Exts.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’
+        ...plus two others
+        (use -fprint-potential-instances to see them all)
+    • In the expression: 1
+      In the first argument of ‘print’, namely ‘[1]’
+      In the expression: print [1]
diff --git a/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail02.stderr b/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail02.stderr
index 4597e1ce56..e0be7ab4e5 100644
--- a/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail02.stderr
+++ b/testsuite/tests/overloadedlists/should_fail/overloadedlistsfail02.stderr
@@ -1,11 +1,13 @@
-

-overloadedlistsfail02.hs:6:8:

-    No instance for (IsList Foo) arising from an overloaded list

-    In the expression: [7]

-    In an equation for ‘test’: test = [7]

-

-overloadedlistsfail02.hs:6:9:

-    No instance for (Num (Item Foo)) arising from the literal ‘7’

-    In the expression: 7

-    In the expression: [7]

-    In an equation for ‘test’: test = [7]

+
+overloadedlistsfail02.hs:6:8: error:
+    • No instance for (GHC.Exts.IsList Foo)
+        arising from an overloaded list
+    • In the expression: [7]
+      In an equation for ‘test’: test = [7]
+
+overloadedlistsfail02.hs:6:9: error:
+    • No instance for (Num (GHC.Exts.Item Foo))
+        arising from the literal ‘7’
+    • In the expression: 7
+      In the expression: [7]
+      In an equation for ‘test’: test = [7]
diff --git a/testsuite/tests/overloadedrecflds/ghci/overloadedlabelsghci01.stdout b/testsuite/tests/overloadedrecflds/ghci/overloadedlabelsghci01.stdout
index 08a34c0bdd..ad4352ef10 100644
--- a/testsuite/tests/overloadedrecflds/ghci/overloadedlabelsghci01.stdout
+++ b/testsuite/tests/overloadedrecflds/ghci/overloadedlabelsghci01.stdout
@@ -1,4 +1,4 @@
-#x :: IsLabel "x" t => t
+#x :: GHC.OverloadedLabels.IsLabel "x" t => t
 "hello"
 "hello world"
 "goodbye world"
diff --git a/testsuite/tests/partial-sigs/should_compile/ExtraConstraints3.stderr b/testsuite/tests/partial-sigs/should_compile/ExtraConstraints3.stderr
index e7fc912a12..e0daa4e87d 100644
--- a/testsuite/tests/partial-sigs/should_compile/ExtraConstraints3.stderr
+++ b/testsuite/tests/partial-sigs/should_compile/ExtraConstraints3.stderr
@@ -27,10 +27,10 @@ TYPE SIGNATURES
   acos :: forall a. Floating a => a -> a
   acosh :: forall a. Floating a => a -> a
   all ::
-    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
-  and :: forall (t :: * -> *). Foldable t => t Bool -> Bool
+    forall (t :: * -> *) a. P.Foldable t => (a -> Bool) -> t a -> Bool
+  and :: forall (t :: * -> *). P.Foldable t => t Bool -> Bool
   any ::
-    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
+    forall (t :: * -> *) a. P.Foldable t => (a -> Bool) -> t a -> Bool
   appendFile :: FilePath -> String -> IO ()
   asTypeOf :: forall a. a -> a -> a
   asin :: forall a. Floating a => a -> a
@@ -41,9 +41,9 @@ TYPE SIGNATURES
   break :: forall a. (a -> Bool) -> [a] -> ([a], [a])
   ceiling :: forall a b. (RealFrac a, Integral b) => a -> b
   compare :: forall a. Ord a => a -> a -> Ordering
-  concat :: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
+  concat :: forall (t :: * -> *) a. P.Foldable t => t [a] -> [a]
   concatMap ::
-    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
+    forall (t :: * -> *) a b. P.Foldable t => (a -> [b]) -> t a -> [b]
   const :: forall a b. a -> b -> a
   cos :: forall a. Floating a => a -> a
   cosh :: forall a. Floating a => a -> a
@@ -56,13 +56,14 @@ TYPE SIGNATURES
   dropWhile :: forall a. (a -> Bool) -> [a] -> [a]
   either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
   elem ::
-    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
+    forall (t :: * -> *) a. (P.Foldable t, Eq a) => a -> t a -> Bool
   encodeFloat :: forall a. RealFloat a => Integer -> Int -> a
   enumFrom :: forall a. Enum a => a -> [a]
   enumFromThen :: forall a. Enum a => a -> a -> [a]
   enumFromThenTo :: forall a. Enum a => a -> a -> a -> [a]
   enumFromTo :: forall a. Enum a => a -> a -> [a]
-  error :: forall a. (?callStack::CallStack) => [Char] -> a
+  error ::
+    forall a. (?callStack::GHC.Stack.Types.CallStack) => [Char] -> a
   even :: forall a. Integral a => a -> Bool
   exp :: forall a. Floating a => a -> a
   exponent :: forall a. RealFloat a => a -> Int
@@ -77,16 +78,16 @@ TYPE SIGNATURES
     forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
   foldl ::
     forall (t :: * -> *) b a.
-    Foldable t =>
+    P.Foldable t =>
     (b -> a -> b) -> b -> t a -> b
   foldl1 ::
-    forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
+    forall (t :: * -> *) a. P.Foldable t => (a -> a -> a) -> t a -> a
   foldr ::
     forall (t :: * -> *) a b.
-    Foldable t =>
+    P.Foldable t =>
     (a -> b -> b) -> b -> t a -> b
   foldr1 ::
-    forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
+    forall (t :: * -> *) a. P.Foldable t => (a -> a -> a) -> t a -> a
   fromEnum :: forall a. Enum a => a -> Int
   fromInteger :: forall a. Num a => Integer -> a
   fromIntegral :: forall a b. (Num b, Integral a) => a -> b
@@ -109,7 +110,7 @@ TYPE SIGNATURES
   iterate :: forall a. (a -> a) -> a -> [a]
   last :: forall a. [a] -> a
   lcm :: forall a. Integral a => a -> a -> a
-  length :: forall (t :: * -> *) a. Foldable t => t a -> Int
+  length :: forall (t :: * -> *) a. P.Foldable t => t a -> Int
   lex :: ReadS String
   lines :: String -> [String]
   log :: forall a. Floating a => a -> a
@@ -118,32 +119,35 @@ TYPE SIGNATURES
   map :: forall a b. (a -> b) -> [a] -> [b]
   mapM ::
     forall (t :: * -> *) (m :: * -> *) a b.
-    (Traversable t, Monad m) =>
+    (P.Traversable t, Monad m) =>
     (a -> m b) -> t a -> m (t b)
   mapM_ ::
     forall (t :: * -> *) (m :: * -> *) a b.
-    (Foldable t, Monad m) =>
+    (P.Foldable t, Monad m) =>
     (a -> m b) -> t a -> m ()
   max :: forall a. Ord a => a -> a -> a
   maxBound :: forall t. Bounded t => t
-  maximum :: forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
+  maximum ::
+    forall (t :: * -> *) a. (P.Foldable t, Ord a) => t a -> a
   maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
   min :: forall a. Ord a => a -> a -> a
   minBound :: forall t. Bounded t => t
-  minimum :: forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
+  minimum ::
+    forall (t :: * -> *) a. (P.Foldable t, Ord a) => t a -> a
   mod :: forall a. Integral a => a -> a -> a
   negate :: forall a. Num a => a -> a
   not :: Bool -> Bool
   notElem ::
-    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
-  null :: forall (t :: * -> *) a. Foldable t => t a -> Bool
+    forall (t :: * -> *) a. (P.Foldable t, Eq a) => a -> t a -> Bool
+  null :: forall (t :: * -> *) a. P.Foldable t => t a -> Bool
   odd :: forall a. Integral a => a -> Bool
-  or :: forall (t :: * -> *). Foldable t => t Bool -> Bool
+  or :: forall (t :: * -> *). P.Foldable t => t Bool -> Bool
   otherwise :: Bool
   pi :: forall t. Floating t => t
   pred :: forall a. Enum a => a -> a
   print :: forall a. Show a => a -> IO ()
-  product :: forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
+  product ::
+    forall (t :: * -> *) a. (P.Foldable t, Num a) => t a -> a
   properFraction ::
     forall a b. (RealFrac a, Integral b) => a -> (b, a)
   putChar :: Char -> IO ()
@@ -175,11 +179,11 @@ TYPE SIGNATURES
   seq :: forall a b. a -> b -> b
   sequence ::
     forall (t :: * -> *) (m :: * -> *) a.
-    (Traversable t, Monad m) =>
+    (P.Traversable t, Monad m) =>
     t (m a) -> m (t a)
   sequence_ ::
     forall (t :: * -> *) (m :: * -> *) a.
-    (Foldable t, Monad m) =>
+    (P.Foldable t, Monad m) =>
     t (m a) -> m ()
   show :: forall a. Show a => a -> String
   showChar :: Char -> ShowS
@@ -198,7 +202,7 @@ TYPE SIGNATURES
   sqrt :: forall a. Floating a => a -> a
   subtract :: forall a. Num a => a -> a -> a
   succ :: forall a. Enum a => a -> a
-  sum :: forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
+  sum :: forall (t :: * -> *) a. (P.Foldable t, Num a) => t a -> a
   tail :: forall a. [a] -> [a]
   take :: forall a. Int -> [a] -> [a]
   takeWhile :: forall a. (a -> Bool) -> [a] -> [a]
@@ -209,7 +213,7 @@ TYPE SIGNATURES
   toRational :: forall a. Real a => a -> Rational
   truncate :: forall a b. (RealFrac a, Integral b) => a -> b
   uncurry :: forall a b c. (a -> b -> c) -> (a, b) -> c
-  undefined :: forall t. (?callStack::CallStack) => t
+  undefined :: forall t. (?callStack::GHC.Stack.Types.CallStack) => t
   unlines :: [String] -> String
   until :: forall a. (a -> Bool) -> (a -> a) -> a -> a
   unwords :: [String] -> String
diff --git a/testsuite/tests/partial-sigs/should_fail/T10999.stderr b/testsuite/tests/partial-sigs/should_fail/T10999.stderr
index 3244db60ca..ef4d9f83c1 100644
--- a/testsuite/tests/partial-sigs/should_fail/T10999.stderr
+++ b/testsuite/tests/partial-sigs/should_fail/T10999.stderr
@@ -1,7 +1,7 @@
 
 T10999.hs:5:6: error:
-    Found constraint wildcard ‘_’ standing for ‘(?callStack::CallStack,
-                                                 Ord a)’
+    Found constraint wildcard ‘_’
+      standing for ‘(?callStack::GHC.Stack.Types.CallStack, Ord a)’
     To use the inferred type, enable PartialTypeSignatures
     In the type signature:
       f :: _ => () -> _
@@ -10,7 +10,8 @@ T10999.hs:5:17: error:
     • Found type wildcard ‘_’ standing for ‘Set.Set a’
       Where: ‘a’ is a rigid type variable bound by
                the inferred type of
-               f :: (?callStack::CallStack, Ord a) => () -> Set.Set a
+               f :: (?callStack::GHC.Stack.Types.CallStack, Ord a) =>
+                    () -> Set.Set a
                at T10999.hs:6:1
       To use the inferred type, enable PartialTypeSignatures
     • In the type signature:
diff --git a/testsuite/tests/quotes/TH_localname.stderr b/testsuite/tests/quotes/TH_localname.stderr
index dfb1e41383..3ca443e981 100644
--- a/testsuite/tests/quotes/TH_localname.stderr
+++ b/testsuite/tests/quotes/TH_localname.stderr
@@ -1,23 +1,31 @@
 
 TH_localname.hs:3:11: error:
-    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)
-    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’
-      instance Lift Int32 -- Defined in ‘Language.Haskell.TH.Syntax’
-      ...plus 24 others
-      (use -fprint-potential-instances to see them all)
-    In the expression: lift y
-    In the expression:
-      [| y |]
-      pending(rn) [<y, lift y>]
-    In the expression:
-      \ y
-        -> [| y |]
-           pending(rn) [<y, lift y>]
+    • Ambiguous type variable ‘t0’ arising from a use of ‘Language.Haskell.TH.Syntax.lift’
+      prevents the constraint ‘(Language.Haskell.TH.Syntax.Lift
+                                  t0)’ from being solved.
+      Relevant bindings include
+        y :: t0 (bound at TH_localname.hs:3:6)
+        x :: t0 -> Language.Haskell.TH.Lib.ExpQ
+          (bound at TH_localname.hs:3:1)
+      Probable fix: use a type annotation to specify what ‘t0’ should be.
+      These potential instances exist:
+        instance (Language.Haskell.TH.Syntax.Lift a,
+                  Language.Haskell.TH.Syntax.Lift b) =>
+                 Language.Haskell.TH.Syntax.Lift (Either a b)
+          -- Defined in ‘Language.Haskell.TH.Syntax’
+        instance Language.Haskell.TH.Syntax.Lift Integer
+          -- Defined in ‘Language.Haskell.TH.Syntax’
+        instance Language.Haskell.TH.Syntax.Lift a =>
+                 Language.Haskell.TH.Syntax.Lift (Maybe a)
+          -- Defined in ‘Language.Haskell.TH.Syntax’
+        ...plus 14 others
+        ...plus 10 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: Language.Haskell.TH.Syntax.lift y
+      In the expression:
+        [| y |]
+        pending(rn) [<y, Language.Haskell.TH.Syntax.lift y>]
+      In the expression:
+        \ y
+          -> [| y |]
+             pending(rn) [<y, Language.Haskell.TH.Syntax.lift y>]
diff --git a/testsuite/tests/rebindable/rebindable6.stderr b/testsuite/tests/rebindable/rebindable6.stderr
index 2f1331db86..0497c9fc61 100644
--- a/testsuite/tests/rebindable/rebindable6.stderr
+++ b/testsuite/tests/rebindable/rebindable6.stderr
@@ -1,69 +1,69 @@
 
 rebindable6.hs:109:17: error:
-    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?)
-    Relevant bindings include
-      g :: IO (Maybe b) (bound at rebindable6.hs:107:19)
-      f :: IO a (bound at rebindable6.hs:107:17)
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:107:9)
-    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:55:18
-    In a stmt of a 'do' block: f
-    In the expression:
-      do { f;
-           Just (b :: b) <- g;
-           return b }
-    In an equation for ‘test_do’:
-        test_do f g
-          = do { f;
-                 Just (b :: b) <- g;
-                 return b }
+    • 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?)
+      Relevant bindings include
+        g :: IO (Maybe b) (bound at rebindable6.hs:107:19)
+        f :: IO a (bound at rebindable6.hs:107:17)
+        test_do :: IO a -> IO (Maybe b) -> IO b
+          (bound at rebindable6.hs:107:9)
+      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:55:18
+    • In a stmt of a 'do' block: f
+      In the expression:
+        do { f;
+             Just (b :: b) <- g;
+             return b }
+      In an equation for ‘test_do’:
+          test_do f g
+            = do { f;
+                   Just (b :: b) <- g;
+                   return b }
 
 rebindable6.hs:110:17: error:
-    Ambiguous type variable ‘t1’ arising from a do statement
-                                 with the failable pattern ‘Just (b :: b)’
-    prevents the constraint ‘(HasFail
-                                ([Char] -> t1))’ from being solved.
-      (maybe you haven't applied a function to enough arguments?)
-    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:60:18
-    In a stmt of a 'do' block: Just (b :: b) <- g
-    In the expression:
-      do { f;
-           Just (b :: b) <- g;
-           return b }
-    In an equation for ‘test_do’:
-        test_do f g
-          = do { f;
-                 Just (b :: b) <- g;
-                 return b }
+    • Ambiguous type variable ‘t1’ arising from a do statement
+                                   with the failable pattern ‘Just (b :: b)’
+      prevents the constraint ‘(HasFail
+                                  ([Prelude.Char] -> t1))’ from being solved.
+        (maybe you haven't applied a function to enough arguments?)
+      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:60:18
+    • In a stmt of a 'do' block: Just (b :: b) <- g
+      In the expression:
+        do { f;
+             Just (b :: b) <- g;
+             return b }
+      In an equation for ‘test_do’:
+          test_do f g
+            = do { f;
+                   Just (b :: b) <- g;
+                   return b }
 
 rebindable6.hs:111:17: error:
-    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?)
-    Relevant bindings include
-      b :: b (bound at rebindable6.hs:110:23)
-      g :: IO (Maybe b) (bound at rebindable6.hs:107:19)
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:107:9)
-    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:45:18
-    In a stmt of a 'do' block: return b
-    In the expression:
-      do { f;
-           Just (b :: b) <- g;
-           return b }
-    In an equation for ‘test_do’:
-        test_do f g
-          = do { f;
-                 Just (b :: b) <- g;
-                 return b }
+    • 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?)
+      Relevant bindings include
+        b :: b (bound at rebindable6.hs:110:23)
+        g :: IO (Maybe b) (bound at rebindable6.hs:107:19)
+        test_do :: IO a -> IO (Maybe b) -> IO b
+          (bound at rebindable6.hs:107:9)
+      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:45:18
+    • In a stmt of a 'do' block: return b
+      In the expression:
+        do { f;
+             Just (b :: b) <- g;
+             return b }
+      In an equation for ‘test_do’:
+          test_do f g
+            = do { f;
+                   Just (b :: b) <- g;
+                   return b }
diff --git a/testsuite/tests/rename/should_fail/RnStaticPointersFail02.stderr b/testsuite/tests/rename/should_fail/RnStaticPointersFail02.stderr
index de145e789a..e596a51fb3 100644
--- a/testsuite/tests/rename/should_fail/RnStaticPointersFail02.stderr
+++ b/testsuite/tests/rename/should_fail/RnStaticPointersFail02.stderr
@@ -1,8 +1,9 @@
-

-RnStaticPointersFail02.hs:5:5: error:

-    No instance for (Typeable t0) arising from a static form

-    In the expression: static T

-    In an equation for ‘f’: f = static T

-

-RnStaticPointersFail02.hs:5:12: error:

-    Data constructor not in scope: T

+
+RnStaticPointersFail02.hs:5:5: error:
+    • No instance for (Data.Typeable.Internal.Typeable t0)
+        arising from a static form
+    • In the expression: static T
+      In an equation for ‘f’: f = static T
+
+RnStaticPointersFail02.hs:5:12: error:
+    Data constructor not in scope: T
diff --git a/testsuite/tests/roles/should_compile/Roles1.stderr b/testsuite/tests/roles/should_compile/Roles1.stderr
index 1759bab776..581b043286 100644
--- a/testsuite/tests/roles/should_compile/Roles1.stderr
+++ b/testsuite/tests/roles/should_compile/Roles1.stderr
@@ -25,19 +25,49 @@ Dependent packages: [base-4.9.0.0, ghc-prim-0.5.0.0,
                      integer-gmp-1.0.0.0]
 
 ==================== Typechecker ====================
-Roles1.$tcT7 = TyCon 0## 0## Roles1.$trModule (TrNameS "T7"#)
-Roles1.$tc'K7 = TyCon 0## 0## Roles1.$trModule (TrNameS "'K7"#)
-Roles1.$tcT6 = TyCon 0## 0## Roles1.$trModule (TrNameS "T6"#)
-Roles1.$tc'K6 = TyCon 0## 0## Roles1.$trModule (TrNameS "'K6"#)
-Roles1.$tcT5 = TyCon 0## 0## Roles1.$trModule (TrNameS "T5"#)
-Roles1.$tc'K5 = TyCon 0## 0## Roles1.$trModule (TrNameS "'K5"#)
-Roles1.$tcT4 = TyCon 0## 0## Roles1.$trModule (TrNameS "T4"#)
-Roles1.$tc'K4 = TyCon 0## 0## Roles1.$trModule (TrNameS "'K4"#)
-Roles1.$tcT3 = TyCon 0## 0## Roles1.$trModule (TrNameS "T3"#)
-Roles1.$tc'K3 = TyCon 0## 0## Roles1.$trModule (TrNameS "'K3"#)
-Roles1.$tcT2 = TyCon 0## 0## Roles1.$trModule (TrNameS "T2"#)
-Roles1.$tc'K2 = TyCon 0## 0## Roles1.$trModule (TrNameS "'K2"#)
-Roles1.$tcT1 = TyCon 0## 0## Roles1.$trModule (TrNameS "T1"#)
-Roles1.$tc'K1 = TyCon 0## 0## Roles1.$trModule (TrNameS "'K1"#)
-Roles1.$trModule = Module (TrNameS "main"#) (TrNameS "Roles1"#)
+Roles1.$tcT7
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "T7"#)
+Roles1.$tc'K7
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "'K7"#)
+Roles1.$tcT6
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "T6"#)
+Roles1.$tc'K6
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "'K6"#)
+Roles1.$tcT5
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "T5"#)
+Roles1.$tc'K5
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "'K5"#)
+Roles1.$tcT4
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "T4"#)
+Roles1.$tc'K4
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "'K4"#)
+Roles1.$tcT3
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "T3"#)
+Roles1.$tc'K3
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "'K3"#)
+Roles1.$tcT2
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "T2"#)
+Roles1.$tc'K2
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "'K2"#)
+Roles1.$tcT1
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "T1"#)
+Roles1.$tc'K1
+  = GHC.Types.TyCon
+      0## 0## Roles1.$trModule (GHC.Types.TrNameS "'K1"#)
+Roles1.$trModule
+  = GHC.Types.Module
+      (GHC.Types.TrNameS "main"#) (GHC.Types.TrNameS "Roles1"#)
 
diff --git a/testsuite/tests/roles/should_compile/Roles13.stderr b/testsuite/tests/roles/should_compile/Roles13.stderr
index 0af9862d2d..8b7a2c8ce8 100644
--- a/testsuite/tests/roles/should_compile/Roles13.stderr
+++ b/testsuite/tests/roles/should_compile/Roles13.stderr
@@ -3,59 +3,59 @@
 Result size of Tidy Core = {terms: 51, types: 20, coercions: 5}
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a :: TrName
+a :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a = TrNameS "main"#
+a = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a1 :: TrName
+a1 :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a1 = TrNameS "Roles13"#
+a1 = GHC.Types.TrNameS "Roles13"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
-Roles13.$trModule :: Module
+Roles13.$trModule :: GHC.Types.Module
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-Roles13.$trModule = Module a a1
+Roles13.$trModule = GHC.Types.Module a a1
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a2 :: TrName
+a2 :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a2 = TrNameS "'MkAge"#
+a2 = GHC.Types.TrNameS "'MkAge"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-Roles13.$tc'MkAge :: TyCon
+Roles13.$tc'MkAge :: GHC.Types.TyCon
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-Roles13.$tc'MkAge = TyCon 0## 0## Roles13.$trModule a2
+Roles13.$tc'MkAge = GHC.Types.TyCon 0## 0## Roles13.$trModule a2
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a3 :: TrName
+a3 :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a3 = TrNameS "Age"#
+a3 = GHC.Types.TrNameS "Age"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-Roles13.$tcAge :: TyCon
+Roles13.$tcAge :: GHC.Types.TyCon
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-Roles13.$tcAge = TyCon 0## 0## Roles13.$trModule a3
+Roles13.$tcAge = GHC.Types.TyCon 0## 0## Roles13.$trModule a3
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a4 :: TrName
+a4 :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a4 = TrNameS "'MkWrap"#
+a4 = GHC.Types.TrNameS "'MkWrap"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-Roles13.$tc'MkWrap :: TyCon
+Roles13.$tc'MkWrap :: GHC.Types.TyCon
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-Roles13.$tc'MkWrap = TyCon 0## 0## Roles13.$trModule a4
+Roles13.$tc'MkWrap = GHC.Types.TyCon 0## 0## Roles13.$trModule a4
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-a5 :: TrName
+a5 :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a5 = TrNameS "Wrap"#
+a5 = GHC.Types.TrNameS "Wrap"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-Roles13.$tcWrap :: TyCon
+Roles13.$tcWrap :: GHC.Types.TyCon
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-Roles13.$tcWrap = TyCon 0## 0## Roles13.$trModule a5
+Roles13.$tcWrap = GHC.Types.TyCon 0## 0## Roles13.$trModule a5
 
 -- RHS size: {terms: 2, types: 2, coercions: 0}
 a6 :: Wrap Age -> Wrap Age
diff --git a/testsuite/tests/roles/should_compile/Roles14.stderr b/testsuite/tests/roles/should_compile/Roles14.stderr
index 52333753da..aeff4498ba 100644
--- a/testsuite/tests/roles/should_compile/Roles14.stderr
+++ b/testsuite/tests/roles/should_compile/Roles14.stderr
@@ -11,8 +11,13 @@ Dependent packages: [base-4.9.0.0, ghc-prim-0.5.0.0,
                      integer-gmp-1.0.0.0]
 
 ==================== Typechecker ====================
-Roles12.$tcC2 = TyCon 0## 0## Roles12.$trModule (TrNameS "C2"#)
+Roles12.$tcC2
+  = GHC.Types.TyCon
+      0## 0## Roles12.$trModule (GHC.Types.TrNameS "C2"#)
 Roles12.$tc'D:C2
-  = TyCon 0## 0## Roles12.$trModule (TrNameS "'D:C2"#)
-Roles12.$trModule = Module (TrNameS "main"#) (TrNameS "Roles12"#)
+  = GHC.Types.TyCon
+      0## 0## Roles12.$trModule (GHC.Types.TrNameS "'D:C2"#)
+Roles12.$trModule
+  = GHC.Types.Module
+      (GHC.Types.TrNameS "main"#) (GHC.Types.TrNameS "Roles12"#)
 
diff --git a/testsuite/tests/roles/should_compile/Roles2.stderr b/testsuite/tests/roles/should_compile/Roles2.stderr
index 0b8a8e0336..14d24b0150 100644
--- a/testsuite/tests/roles/should_compile/Roles2.stderr
+++ b/testsuite/tests/roles/should_compile/Roles2.stderr
@@ -11,9 +11,19 @@ Dependent packages: [base-4.9.0.0, ghc-prim-0.5.0.0,
                      integer-gmp-1.0.0.0]
 
 ==================== Typechecker ====================
-Roles2.$tcT2 = TyCon 0## 0## Roles2.$trModule (TrNameS "T2"#)
-Roles2.$tc'K2 = TyCon 0## 0## Roles2.$trModule (TrNameS "'K2"#)
-Roles2.$tcT1 = TyCon 0## 0## Roles2.$trModule (TrNameS "T1"#)
-Roles2.$tc'K1 = TyCon 0## 0## Roles2.$trModule (TrNameS "'K1"#)
-Roles2.$trModule = Module (TrNameS "main"#) (TrNameS "Roles2"#)
+Roles2.$tcT2
+  = GHC.Types.TyCon
+      0## 0## Roles2.$trModule (GHC.Types.TrNameS "T2"#)
+Roles2.$tc'K2
+  = GHC.Types.TyCon
+      0## 0## Roles2.$trModule (GHC.Types.TrNameS "'K2"#)
+Roles2.$tcT1
+  = GHC.Types.TyCon
+      0## 0## Roles2.$trModule (GHC.Types.TrNameS "T1"#)
+Roles2.$tc'K1
+  = GHC.Types.TyCon
+      0## 0## Roles2.$trModule (GHC.Types.TrNameS "'K1"#)
+Roles2.$trModule
+  = GHC.Types.Module
+      (GHC.Types.TrNameS "main"#) (GHC.Types.TrNameS "Roles2"#)
 
diff --git a/testsuite/tests/roles/should_compile/Roles3.stderr b/testsuite/tests/roles/should_compile/Roles3.stderr
index e2f304dc56..bf6dd003e9 100644
--- a/testsuite/tests/roles/should_compile/Roles3.stderr
+++ b/testsuite/tests/roles/should_compile/Roles3.stderr
@@ -31,13 +31,31 @@ Dependent packages: [base-4.9.0.0, ghc-prim-0.5.0.0,
                      integer-gmp-1.0.0.0]
 
 ==================== Typechecker ====================
-Roles3.$tcC4 = TyCon 0## 0## Roles3.$trModule (TrNameS "C4"#)
-Roles3.$tc'D:C4 = TyCon 0## 0## Roles3.$trModule (TrNameS "'D:C4"#)
-Roles3.$tcC3 = TyCon 0## 0## Roles3.$trModule (TrNameS "C3"#)
-Roles3.$tc'D:C3 = TyCon 0## 0## Roles3.$trModule (TrNameS "'D:C3"#)
-Roles3.$tcC2 = TyCon 0## 0## Roles3.$trModule (TrNameS "C2"#)
-Roles3.$tc'D:C2 = TyCon 0## 0## Roles3.$trModule (TrNameS "'D:C2"#)
-Roles3.$tcC1 = TyCon 0## 0## Roles3.$trModule (TrNameS "C1"#)
-Roles3.$tc'D:C1 = TyCon 0## 0## Roles3.$trModule (TrNameS "'D:C1"#)
-Roles3.$trModule = Module (TrNameS "main"#) (TrNameS "Roles3"#)
+Roles3.$tcC4
+  = GHC.Types.TyCon
+      0## 0## Roles3.$trModule (GHC.Types.TrNameS "C4"#)
+Roles3.$tc'D:C4
+  = GHC.Types.TyCon
+      0## 0## Roles3.$trModule (GHC.Types.TrNameS "'D:C4"#)
+Roles3.$tcC3
+  = GHC.Types.TyCon
+      0## 0## Roles3.$trModule (GHC.Types.TrNameS "C3"#)
+Roles3.$tc'D:C3
+  = GHC.Types.TyCon
+      0## 0## Roles3.$trModule (GHC.Types.TrNameS "'D:C3"#)
+Roles3.$tcC2
+  = GHC.Types.TyCon
+      0## 0## Roles3.$trModule (GHC.Types.TrNameS "C2"#)
+Roles3.$tc'D:C2
+  = GHC.Types.TyCon
+      0## 0## Roles3.$trModule (GHC.Types.TrNameS "'D:C2"#)
+Roles3.$tcC1
+  = GHC.Types.TyCon
+      0## 0## Roles3.$trModule (GHC.Types.TrNameS "C1"#)
+Roles3.$tc'D:C1
+  = GHC.Types.TyCon
+      0## 0## Roles3.$trModule (GHC.Types.TrNameS "'D:C1"#)
+Roles3.$trModule
+  = GHC.Types.Module
+      (GHC.Types.TrNameS "main"#) (GHC.Types.TrNameS "Roles3"#)
 
diff --git a/testsuite/tests/roles/should_compile/Roles4.stderr b/testsuite/tests/roles/should_compile/Roles4.stderr
index fb6e88a597..7253f93507 100644
--- a/testsuite/tests/roles/should_compile/Roles4.stderr
+++ b/testsuite/tests/roles/should_compile/Roles4.stderr
@@ -16,9 +16,19 @@ Dependent packages: [base-4.9.0.0, ghc-prim-0.5.0.0,
                      integer-gmp-1.0.0.0]
 
 ==================== Typechecker ====================
-Roles4.$tcC3 = TyCon 0## 0## Roles4.$trModule (TrNameS "C3"#)
-Roles4.$tc'D:C3 = TyCon 0## 0## Roles4.$trModule (TrNameS "'D:C3"#)
-Roles4.$tcC1 = TyCon 0## 0## Roles4.$trModule (TrNameS "C1"#)
-Roles4.$tc'D:C1 = TyCon 0## 0## Roles4.$trModule (TrNameS "'D:C1"#)
-Roles4.$trModule = Module (TrNameS "main"#) (TrNameS "Roles4"#)
+Roles4.$tcC3
+  = GHC.Types.TyCon
+      0## 0## Roles4.$trModule (GHC.Types.TrNameS "C3"#)
+Roles4.$tc'D:C3
+  = GHC.Types.TyCon
+      0## 0## Roles4.$trModule (GHC.Types.TrNameS "'D:C3"#)
+Roles4.$tcC1
+  = GHC.Types.TyCon
+      0## 0## Roles4.$trModule (GHC.Types.TrNameS "C1"#)
+Roles4.$tc'D:C1
+  = GHC.Types.TyCon
+      0## 0## Roles4.$trModule (GHC.Types.TrNameS "'D:C1"#)
+Roles4.$trModule
+  = GHC.Types.Module
+      (GHC.Types.TrNameS "main"#) (GHC.Types.TrNameS "Roles4"#)
 
diff --git a/testsuite/tests/roles/should_compile/T8958.stderr b/testsuite/tests/roles/should_compile/T8958.stderr
index 9ffe72ad16..fd5461821f 100644
--- a/testsuite/tests/roles/should_compile/T8958.stderr
+++ b/testsuite/tests/roles/should_compile/T8958.stderr
@@ -21,17 +21,27 @@ Dependent packages: [base-4.9.0.0, ghc-prim-0.5.0.0,
                      integer-gmp-1.0.0.0]
 
 ==================== Typechecker ====================
-T8958.$tcMap = TyCon 0## 0## T8958.$trModule (TrNameS "Map"#)
-T8958.$tc'MkMap = TyCon 0## 0## T8958.$trModule (TrNameS "'MkMap"#)
+T8958.$tcMap
+  = GHC.Types.TyCon
+      0## 0## T8958.$trModule (GHC.Types.TrNameS "Map"#)
+T8958.$tc'MkMap
+  = GHC.Types.TyCon
+      0## 0## T8958.$trModule (GHC.Types.TrNameS "'MkMap"#)
 T8958.$tcRepresentational
-  = TyCon 0## 0## T8958.$trModule (TrNameS "Representational"#)
+  = GHC.Types.TyCon
+      0## 0## T8958.$trModule (GHC.Types.TrNameS "Representational"#)
 T8958.$tc'D:Representational
-  = TyCon 0## 0## T8958.$trModule (TrNameS "'D:Representational"#)
+  = GHC.Types.TyCon
+      0## 0## T8958.$trModule (GHC.Types.TrNameS "'D:Representational"#)
 T8958.$tcNominal
-  = TyCon 0## 0## T8958.$trModule (TrNameS "Nominal"#)
+  = GHC.Types.TyCon
+      0## 0## T8958.$trModule (GHC.Types.TrNameS "Nominal"#)
 T8958.$tc'D:Nominal
-  = TyCon 0## 0## T8958.$trModule (TrNameS "'D:Nominal"#)
-T8958.$trModule = Module (TrNameS "main"#) (TrNameS "T8958"#)
+  = GHC.Types.TyCon
+      0## 0## T8958.$trModule (GHC.Types.TrNameS "'D:Nominal"#)
+T8958.$trModule
+  = GHC.Types.Module
+      (GHC.Types.TrNameS "main"#) (GHC.Types.TrNameS "T8958"#)
 AbsBinds [a] []
   {Exports: [T8958.$fRepresentationala <= $dRepresentational
                <>]
diff --git a/testsuite/tests/simplCore/should_compile/T3717.stderr b/testsuite/tests/simplCore/should_compile/T3717.stderr
index f7fa084ef0..cdfc5f5069 100644
--- a/testsuite/tests/simplCore/should_compile/T3717.stderr
+++ b/testsuite/tests/simplCore/should_compile/T3717.stderr
@@ -3,40 +3,42 @@
 Result size of Tidy Core = {terms: 32, types: 13, coercions: 0}
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T3717.$trModule2 :: TrName
+T3717.$trModule2 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 20}]
-T3717.$trModule2 = TrNameS "main"#
+T3717.$trModule2 = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T3717.$trModule1 :: TrName
+T3717.$trModule1 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T3717.$trModule1 = TrNameS "T3717"#
+T3717.$trModule1 = GHC.Types.TrNameS "T3717"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
-T3717.$trModule :: Module
+T3717.$trModule :: GHC.Types.Module
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
-T3717.$trModule = Module T3717.$trModule2 T3717.$trModule1
+T3717.$trModule =
+  GHC.Types.Module T3717.$trModule2 T3717.$trModule1
 
 Rec {
 -- RHS size: {terms: 10, types: 2, coercions: 0}
-T3717.$wfoo [InlPrag=[0], Occ=LoopBreaker] :: Int# -> Int#
+T3717.$wfoo [InlPrag=[0], Occ=LoopBreaker]
+  :: GHC.Prim.Int# -> GHC.Prim.Int#
 [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <S,1*U>]
 T3717.$wfoo =
-  \ (ww :: Int#) ->
+  \ (ww :: GHC.Prim.Int#) ->
     case ww of ds {
-      __DEFAULT -> T3717.$wfoo (-# ds 1#);
+      __DEFAULT -> T3717.$wfoo (GHC.Prim.-# ds 1#);
       0# -> 0#
     }
 end Rec }
@@ -51,13 +53,13 @@ foo [InlPrag=INLINE[0]] :: Int -> Int
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
          Tmpl= \ (w [Occ=Once!] :: Int) ->
-                 case w of _ [Occ=Dead] { I# ww1 [Occ=Once] ->
-                 case T3717.$wfoo ww1 of ww2 { __DEFAULT -> I# ww2 }
+                 case w of _ [Occ=Dead] { GHC.Types.I# ww1 [Occ=Once] ->
+                 case T3717.$wfoo ww1 of ww2 { __DEFAULT -> GHC.Types.I# ww2 }
                  }}]
 foo =
   \ (w :: Int) ->
-    case w of _ [Occ=Dead] { I# ww1 ->
-    case T3717.$wfoo ww1 of ww2 { __DEFAULT -> I# ww2 }
+    case w of _ [Occ=Dead] { GHC.Types.I# ww1 ->
+    case T3717.$wfoo ww1 of ww2 { __DEFAULT -> GHC.Types.I# ww2 }
     }
 
 
diff --git a/testsuite/tests/simplCore/should_compile/T3772.stdout b/testsuite/tests/simplCore/should_compile/T3772.stdout
index 1ef8c79002..130ee076e1 100644
--- a/testsuite/tests/simplCore/should_compile/T3772.stdout
+++ b/testsuite/tests/simplCore/should_compile/T3772.stdout
@@ -4,13 +4,13 @@ Result size of Tidy Core = {terms: 36, types: 14, coercions: 0}
 
 Rec {
 -- RHS size: {terms: 10, types: 2, coercions: 0}
-$wxs :: Int# -> ()
+$wxs :: GHC.Prim.Int# -> ()
 [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <S,1*U>]
 $wxs =
-  \ (ww :: Int#) ->
+  \ (ww :: GHC.Prim.Int#) ->
     case ww of ds1 {
-      __DEFAULT -> $wxs (-# ds1 1#);
-      1# -> ()
+      __DEFAULT -> $wxs (GHC.Prim.-# ds1 1#);
+      1# -> GHC.Tuple.()
     }
 end Rec }
 
@@ -19,39 +19,41 @@ foo [InlPrag=NOINLINE] :: Int -> ()
 [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <S,1*U(U)>]
 foo =
   \ (n :: Int) ->
-    case n of _ [Occ=Dead] { I# y ->
-    case tagToEnum# @ Bool (<# 0# y) of _ [Occ=Dead] {
-      False -> ();
+    case n of _ [Occ=Dead] { GHC.Types.I# y ->
+    case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# 0# y)
+    of _ [Occ=Dead] {
+      False -> GHC.Tuple.();
       True -> $wxs y
     }
     }
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T3772.$trModule1 :: TrName
+T3772.$trModule1 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T3772.$trModule1 = TrNameS "T3772"#
+T3772.$trModule1 = GHC.Types.TrNameS "T3772"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T3772.$trModule2 :: TrName
+T3772.$trModule2 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 20}]
-T3772.$trModule2 = TrNameS "main"#
+T3772.$trModule2 = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
-T3772.$trModule :: Module
+T3772.$trModule :: GHC.Types.Module
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
-T3772.$trModule = Module T3772.$trModule2 T3772.$trModule1
+T3772.$trModule =
+  GHC.Types.Module T3772.$trModule2 T3772.$trModule1
 
 
 
diff --git a/testsuite/tests/simplCore/should_compile/T4908.stderr b/testsuite/tests/simplCore/should_compile/T4908.stderr
index 878bd18cce..bb0b08f53e 100644
--- a/testsuite/tests/simplCore/should_compile/T4908.stderr
+++ b/testsuite/tests/simplCore/should_compile/T4908.stderr
@@ -9,7 +9,7 @@ T4908.$trModule2 :: TrName
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 20}]
-T4908.$trModule2 = TrNameS "main"#
+T4908.$trModule2 = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
 T4908.$trModule1 :: TrName
@@ -18,7 +18,7 @@ T4908.$trModule1 :: TrName
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T4908.$trModule1 = TrNameS "T4908"#
+T4908.$trModule1 = GHC.Types.TrNameS "T4908"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
 T4908.$trModule :: Module
@@ -27,7 +27,8 @@ T4908.$trModule :: Module
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
-T4908.$trModule = Module T4908.$trModule2 T4908.$trModule1
+T4908.$trModule =
+  GHC.Types.Module T4908.$trModule2 T4908.$trModule1
 
 Rec {
 -- RHS size: {terms: 19, types: 5, coercions: 0}
@@ -39,9 +40,9 @@ T4908.f_$s$wf =
       __DEFAULT ->
         case sc1 of ds1 {
           __DEFAULT -> T4908.f_$s$wf sc ds1 (-# ds 1#);
-          0# -> True
+          0# -> GHC.Types.True
         };
-      0# -> True
+      0# -> GHC.Types.True
     }
 end Rec }
 
@@ -61,11 +62,11 @@ T4908.$wf =
         case b of _ [Occ=Dead] { I# ds1 ->
         case ds1 of ds2 {
           __DEFAULT -> T4908.f_$s$wf a ds2 (-# ds 1#);
-          0# -> True
+          0# -> GHC.Types.True
         }
         }
         };
-      0# -> True
+      0# -> GHC.Types.True
     }
 
 -- RHS size: {terms: 8, types: 6, coercions: 0}
@@ -87,7 +88,7 @@ f =
 ------ Local rules for imported ids --------
 "SC:$wf0" [0]
     forall (sc :: Int) (sc1 :: Int#) (sc2 :: Int#).
-      T4908.$wf sc2 (sc, I# sc1)
+      T4908.$wf sc2 (sc, GHC.Types.I# sc1)
       = T4908.f_$s$wf sc sc1 sc2
 
 
diff --git a/testsuite/tests/simplCore/should_compile/T4930.stderr b/testsuite/tests/simplCore/should_compile/T4930.stderr
index 9f71161d14..c145cad6e8 100644
--- a/testsuite/tests/simplCore/should_compile/T4930.stderr
+++ b/testsuite/tests/simplCore/should_compile/T4930.stderr
@@ -3,44 +3,48 @@
 Result size of Tidy Core = {terms: 45, types: 17, coercions: 0}
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T4930.$trModule2 :: TrName
+T4930.$trModule2 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 20}]
-T4930.$trModule2 = TrNameS "main"#
+T4930.$trModule2 = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T4930.$trModule1 :: TrName
+T4930.$trModule1 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T4930.$trModule1 = TrNameS "T4930"#
+T4930.$trModule1 = GHC.Types.TrNameS "T4930"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
-T4930.$trModule :: Module
+T4930.$trModule :: GHC.Types.Module
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
-T4930.$trModule = Module T4930.$trModule2 T4930.$trModule1
+T4930.$trModule =
+  GHC.Types.Module T4930.$trModule2 T4930.$trModule1
 
 Rec {
 -- RHS size: {terms: 23, types: 6, coercions: 0}
-T4930.$wfoo [InlPrag=[0], Occ=LoopBreaker] :: Int# -> Int#
+T4930.$wfoo [InlPrag=[0], Occ=LoopBreaker]
+  :: GHC.Prim.Int# -> GHC.Prim.Int#
 [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <L,U>]
 T4930.$wfoo =
-  \ (ww :: Int#) ->
-    case case tagToEnum# @ Bool (<# ww 5#) of _ [Occ=Dead] {
-           False -> I# (+# ww 2#);
-           True -> case T4930.$wfoo ww of ww1 { __DEFAULT -> I# ww1 }
+  \ (ww :: GHC.Prim.Int#) ->
+    case case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# ww 5#)
+         of _ [Occ=Dead] {
+           False -> GHC.Types.I# (GHC.Prim.+# ww 2#);
+           True ->
+             case T4930.$wfoo ww of ww1 { __DEFAULT -> GHC.Types.I# ww1 }
          }
-    of _ [Occ=Dead] { I# ipv ->
-    +# ww 5#
+    of _ [Occ=Dead] { GHC.Types.I# ipv ->
+    GHC.Prim.+# ww 5#
     }
 end Rec }
 
@@ -54,13 +58,13 @@ foo [InlPrag=INLINE[0]] :: Int -> Int
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
          Tmpl= \ (w [Occ=Once!] :: Int) ->
-                 case w of _ [Occ=Dead] { I# ww1 [Occ=Once] ->
-                 case T4930.$wfoo ww1 of ww2 { __DEFAULT -> I# ww2 }
+                 case w of _ [Occ=Dead] { GHC.Types.I# ww1 [Occ=Once] ->
+                 case T4930.$wfoo ww1 of ww2 { __DEFAULT -> GHC.Types.I# ww2 }
                  }}]
 foo =
   \ (w :: Int) ->
-    case w of _ [Occ=Dead] { I# ww1 ->
-    case T4930.$wfoo ww1 of ww2 { __DEFAULT -> I# ww2 }
+    case w of _ [Occ=Dead] { GHC.Types.I# ww1 ->
+    case T4930.$wfoo ww1 of ww2 { __DEFAULT -> GHC.Types.I# ww2 }
     }
 
 
diff --git a/testsuite/tests/simplCore/should_compile/T5366.stdout b/testsuite/tests/simplCore/should_compile/T5366.stdout
index 1c8efbb821..df0f9ba05d 100644
--- a/testsuite/tests/simplCore/should_compile/T5366.stdout
+++ b/testsuite/tests/simplCore/should_compile/T5366.stdout
@@ -1 +1 @@
-  \ (ds :: Bar) -> case ds of _ [Occ=Dead] { Bar dt dt1 -> I# dt }
+    case ds of _ [Occ=Dead] { Bar dt dt1 -> GHC.Types.I# dt }
diff --git a/testsuite/tests/simplCore/should_compile/T7360.stderr b/testsuite/tests/simplCore/should_compile/T7360.stderr
index cc8c5a9056..9ded9c1349 100644
--- a/testsuite/tests/simplCore/should_compile/T7360.stderr
+++ b/testsuite/tests/simplCore/should_compile/T7360.stderr
@@ -12,114 +12,125 @@ T7360.$WFoo3 [InlPrag=INLINE] :: Int -> Foo
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=False,boring_ok=False)
          Tmpl= \ (dt [Occ=Once!] :: Int) ->
-                 case dt of _ [Occ=Dead] { I# dt [Occ=Once] -> T7360.Foo3 dt }}]
+                 case dt of _ [Occ=Dead] { GHC.Types.I# dt [Occ=Once] ->
+                 T7360.Foo3 dt
+                 }}]
 T7360.$WFoo3 =
   \ (dt [Occ=Once!] :: Int) ->
-    case dt of _ [Occ=Dead] { I# dt [Occ=Once] -> T7360.Foo3 dt }
+    case dt of _ [Occ=Dead] { GHC.Types.I# dt [Occ=Once] ->
+    T7360.Foo3 dt
+    }
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T7360.$trModule2 :: TrName
+T7360.$trModule2 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 20}]
-T7360.$trModule2 = TrNameS "main"#
+T7360.$trModule2 = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T7360.$trModule1 :: TrName
+T7360.$trModule1 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T7360.$trModule1 = TrNameS "T7360"#
+T7360.$trModule1 = GHC.Types.TrNameS "T7360"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
-T7360.$trModule :: Module
+T7360.$trModule :: GHC.Types.Module
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
-T7360.$trModule = Module T7360.$trModule2 T7360.$trModule1
+T7360.$trModule =
+  GHC.Types.Module T7360.$trModule2 T7360.$trModule1
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T7360.$tc'Foo6 :: TrName
+T7360.$tc'Foo6 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T7360.$tc'Foo6 = TrNameS "'Foo3"#
+T7360.$tc'Foo6 = GHC.Types.TrNameS "'Foo3"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-T7360.$tc'Foo3 :: TyCon
+T7360.$tc'Foo3 :: GHC.Types.TyCon
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 50}]
-T7360.$tc'Foo3 = TyCon 0## 0## T7360.$trModule T7360.$tc'Foo6
+T7360.$tc'Foo3 =
+  GHC.Types.TyCon 0## 0## T7360.$trModule T7360.$tc'Foo6
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T7360.$tc'Foo5 :: TrName
+T7360.$tc'Foo5 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T7360.$tc'Foo5 = TrNameS "'Foo2"#
+T7360.$tc'Foo5 = GHC.Types.TrNameS "'Foo2"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-T7360.$tc'Foo2 :: TyCon
+T7360.$tc'Foo2 :: GHC.Types.TyCon
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 50}]
-T7360.$tc'Foo2 = TyCon 0## 0## T7360.$trModule T7360.$tc'Foo5
+T7360.$tc'Foo2 =
+  GHC.Types.TyCon 0## 0## T7360.$trModule T7360.$tc'Foo5
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T7360.$tc'Foo4 :: TrName
+T7360.$tc'Foo4 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-T7360.$tc'Foo4 = TrNameS "'Foo1"#
+T7360.$tc'Foo4 = GHC.Types.TrNameS "'Foo1"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-T7360.$tc'Foo1 :: TyCon
+T7360.$tc'Foo1 :: GHC.Types.TyCon
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 50}]
-T7360.$tc'Foo1 = TyCon 0## 0## T7360.$trModule T7360.$tc'Foo4
+T7360.$tc'Foo1 =
+  GHC.Types.TyCon 0## 0## T7360.$trModule T7360.$tc'Foo4
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-T7360.$tcFoo1 :: TrName
+T7360.$tcFoo1 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 20}]
-T7360.$tcFoo1 = TrNameS "Foo"#
+T7360.$tcFoo1 = GHC.Types.TrNameS "Foo"#
 
 -- RHS size: {terms: 5, types: 0, coercions: 0}
-T7360.$tcFoo :: TyCon
+T7360.$tcFoo :: GHC.Types.TyCon
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 50}]
-T7360.$tcFoo = TyCon 0## 0## T7360.$trModule T7360.$tcFoo1
+T7360.$tcFoo =
+  GHC.Types.TyCon 0## 0## T7360.$trModule T7360.$tcFoo1
 
 -- RHS size: {terms: 5, types: 2, coercions: 0}
 fun1 [InlPrag=NOINLINE] :: Foo -> ()
 [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <S,1*U>]
-fun1 = \ (x :: Foo) -> case x of _ [Occ=Dead] { __DEFAULT -> () }
+fun1 =
+  \ (x :: Foo) ->
+    case x of _ [Occ=Dead] { __DEFAULT -> GHC.Tuple.() }
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
 T7360.fun5 :: ()
@@ -136,7 +147,7 @@ T7360.fun4 :: Int
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
-T7360.fun4 = I# 0#
+T7360.fun4 = GHC.Types.I# 0#
 
 -- RHS size: {terms: 16, types: 13, coercions: 0}
 fun2 :: forall a. [a] -> ((), Int)
@@ -151,7 +162,9 @@ fun2 :: forall a. [a] -> ((), Int)
                   case x of wild {
                     [] -> T7360.fun4;
                     : _ [Occ=Dead] _ [Occ=Dead] ->
-                      case GHC.List.$wlenAcc @ a wild 0# of ww2 { __DEFAULT -> I# ww2 }
+                      case GHC.List.$wlenAcc @ a wild 0# of ww2 { __DEFAULT ->
+                      GHC.Types.I# ww2
+                      }
                   })}]
 fun2 =
   \ (@ a) (x :: [a]) ->
@@ -159,7 +172,9 @@ fun2 =
      case x of wild {
        [] -> T7360.fun4;
        : ds ds1 ->
-         case GHC.List.$wlenAcc @ a wild 0# of ww2 { __DEFAULT -> I# ww2 }
+         case GHC.List.$wlenAcc @ a wild 0# of ww2 { __DEFAULT ->
+         GHC.Types.I# ww2
+         }
      })
 
 
diff --git a/testsuite/tests/simplCore/should_compile/T7865.stdout b/testsuite/tests/simplCore/should_compile/T7865.stdout
index b4252a9cdc..b06e47d4b9 100644
--- a/testsuite/tests/simplCore/should_compile/T7865.stdout
+++ b/testsuite/tests/simplCore/should_compile/T7865.stdout
@@ -1,4 +1,4 @@
 expensive [InlPrag=NOINLINE] :: Int -> Int
 expensive =
-        case expensive sc1 of _ [Occ=Dead] { I# x -> I# (*# x 2#) } } in
-                (case expensive x of _ [Occ=Dead] { I# x1 -> I# (*# x1 2#) }, x)
+        case expensive sc1 of _ [Occ=Dead] { GHC.Types.I# x ->
+                (case expensive x of _ [Occ=Dead] { GHC.Types.I# x1 ->
diff --git a/testsuite/tests/simplCore/should_compile/T8274.stdout b/testsuite/tests/simplCore/should_compile/T8274.stdout
index 8d4236b282..269f4e73f6 100644
--- a/testsuite/tests/simplCore/should_compile/T8274.stdout
+++ b/testsuite/tests/simplCore/should_compile/T8274.stdout
@@ -1,12 +1,12 @@
-T8274.$trModule2 = TrNameS "main"#
-T8274.$trModule1 = TrNameS "T8274"#
-T8274.$tc'Positives1 = TrNameS "'Positives"#
-  TyCon 0## 0## T8274.$trModule T8274.$tc'Positives1
-T8274.$tcP1 = TrNameS "P"#
-T8274.$tcP = TyCon 0## 0## T8274.$trModule T8274.$tcP1
-T8274.$tc'Negatives1 = TrNameS "'Negatives"#
-  TyCon 0## 0## T8274.$trModule T8274.$tc'Negatives1
-T8274.$tcN1 = TrNameS "N"#
-T8274.$tcN = TyCon 0## 0## T8274.$trModule T8274.$tcN1
+T8274.$trModule2 = GHC.Types.TrNameS "main"#
+T8274.$trModule1 = GHC.Types.TrNameS "T8274"#
+T8274.$tc'Positives1 = GHC.Types.TrNameS "'Positives"#
+  GHC.Types.TyCon 0## 0## T8274.$trModule T8274.$tc'Positives1
+T8274.$tcP1 = GHC.Types.TrNameS "P"#
+T8274.$tcP = GHC.Types.TyCon 0## 0## T8274.$trModule T8274.$tcP1
+T8274.$tc'Negatives1 = GHC.Types.TrNameS "'Negatives"#
+  GHC.Types.TyCon 0## 0## T8274.$trModule T8274.$tc'Negatives1
+T8274.$tcN1 = GHC.Types.TrNameS "N"#
+T8274.$tcN = GHC.Types.TyCon 0## 0## T8274.$trModule T8274.$tcN1
 p = T8274.Positives 42# 4.23# 4.23## '4'# 4##
 n = T8274.Negatives -4# -4.0# -4.0##
diff --git a/testsuite/tests/simplCore/should_compile/T8832.stdout b/testsuite/tests/simplCore/should_compile/T8832.stdout
index a351735cd0..3e23710089 100644
--- a/testsuite/tests/simplCore/should_compile/T8832.stdout
+++ b/testsuite/tests/simplCore/should_compile/T8832.stdout
@@ -1,11 +1,11 @@
-i = I# 0#
-i8 = I8# 0#
-i16 = I16# 0#
-i32 = I32# 0#
-i64 = I64# 0#
-w = W# 0##
-w8 = W8# 0##
-w16 = W16# 0##
-w32 = W32# 0##
-w64 = W64# 0##
+i = GHC.Types.I# 0#
+i8 = GHC.Int.I8# 0#
+i16 = GHC.Int.I16# 0#
+i32 = GHC.Int.I32# 0#
+i64 = GHC.Int.I64# 0#
+w = GHC.Types.W# 0##
+w8 = GHC.Word.W8# 0##
+w16 = GHC.Word.W16# 0##
+w32 = GHC.Word.W32# 0##
+w64 = GHC.Word.W64# 0##
 z = 0
diff --git a/testsuite/tests/simplCore/should_compile/T8832.stdout-ws-32 b/testsuite/tests/simplCore/should_compile/T8832.stdout-ws-32
index 8978c6c846..3186412561 100644
--- a/testsuite/tests/simplCore/should_compile/T8832.stdout-ws-32
+++ b/testsuite/tests/simplCore/should_compile/T8832.stdout-ws-32
@@ -1,9 +1,9 @@
-i = I# 0#
-i8 = I8# 0#
-i16 = I16# 0#
-i32 = I32# 0#
-w = W# 0##
-w8 = W8# 0##
-w16 = W16# 0##
-w32 = W32# 0##
+i = GHC.Types.I# 0#
+i8 = GHC.Int.I8# 0#
+i16 = GHC.Int.I16# 0#
+i32 = GHC.Int.I32# 0#
+w = GHC.Types.W# 0##
+w8 = GHC.Word.W8# 0##
+w16 = GHC.Word.W16# 0##
+w32 = GHC.Word.W32# 0##
 z = 0
diff --git a/testsuite/tests/simplCore/should_compile/T9400.stderr b/testsuite/tests/simplCore/should_compile/T9400.stderr
index cdf770b3f9..8fdcf39711 100644
--- a/testsuite/tests/simplCore/should_compile/T9400.stderr
+++ b/testsuite/tests/simplCore/should_compile/T9400.stderr
@@ -5,17 +5,17 @@ Result size of Tidy Core = {terms: 33, types: 20, coercions: 0}
 -- RHS size: {terms: 2, types: 0, coercions: 0}
 a :: TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a = TrNameS "main"#
+a = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
 a1 :: TrName
 [GblId, Caf=NoCafRefs, Str=DmdType]
-a1 = TrNameS "T9400"#
+a1 = GHC.Types.TrNameS "T9400"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
 T9400.$trModule :: Module
 [GblId[ReflectionId], Caf=NoCafRefs, Str=DmdType]
-T9400.$trModule = Module a a1
+T9400.$trModule = GHC.Types.Module a a1
 
 -- RHS size: {terms: 22, types: 15, coercions: 0}
 main :: IO ()
@@ -45,7 +45,8 @@ main =
              @ ()
              @ ()
              (putStrLn (unpackCString# "efg"#))
-             (patError @ 'Lifted @ (IO ()) "T9400.hs:(17,5)-(18,29)|case"#))))
+             (Control.Exception.Base.patError
+                @ 'Lifted @ (IO ()) "T9400.hs:(17,5)-(18,29)|case"#))))
 
 
 
diff --git a/testsuite/tests/simplCore/should_compile/spec-inline.stderr b/testsuite/tests/simplCore/should_compile/spec-inline.stderr
index 09ae2f3ecb..27981eebd4 100644
--- a/testsuite/tests/simplCore/should_compile/spec-inline.stderr
+++ b/testsuite/tests/simplCore/should_compile/spec-inline.stderr
@@ -3,65 +3,78 @@
 Result size of Tidy Core = {terms: 172, types: 65, coercions: 0}
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-Roman.$trModule2 :: TrName
+Roman.$trModule2 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 20}]
-Roman.$trModule2 = TrNameS "main"#
+Roman.$trModule2 = GHC.Types.TrNameS "main"#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
-Roman.$trModule1 :: TrName
+Roman.$trModule1 :: GHC.Types.TrName
 [GblId,
  Caf=NoCafRefs,
  Str=DmdType m1,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 20}]
-Roman.$trModule1 = TrNameS "Roman"#
+Roman.$trModule1 = GHC.Types.TrNameS "Roman"#
 
 -- RHS size: {terms: 3, types: 0, coercions: 0}
-Roman.$trModule :: Module
+Roman.$trModule :: GHC.Types.Module
 [GblId[ReflectionId],
  Caf=NoCafRefs,
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
-Roman.$trModule = Module Roman.$trModule2 Roman.$trModule1
+Roman.$trModule =
+  GHC.Types.Module Roman.$trModule2 Roman.$trModule1
 
 -- RHS size: {terms: 2, types: 2, coercions: 0}
 Roman.foo3 :: Int
 [GblId, Str=DmdType b]
 Roman.foo3 =
-  patError
-    @ 'Lifted @ Int "spec-inline.hs:(19,5)-(29,25)|function go"#
+  Control.Exception.Base.patError
+    @ 'GHC.Types.Lifted
+    @ Int
+    "spec-inline.hs:(19,5)-(29,25)|function go"#
 
 Rec {
 -- RHS size: {terms: 55, types: 9, coercions: 0}
-Roman.foo_$s$wgo [Occ=LoopBreaker] :: Int# -> Int# -> Int#
+Roman.foo_$s$wgo [Occ=LoopBreaker]
+  :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
 [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType <L,U><L,U>]
 Roman.foo_$s$wgo =
-  \ (sc :: Int#) (sc1 :: Int#) ->
+  \ (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#) ->
     let {
-      a :: Int#
+      a :: GHC.Prim.Int#
       [LclId, Str=DmdType]
-      a = +# (+# (+# (+# (+# (+# sc sc) sc) sc) sc) sc) sc } in
-    case tagToEnum# @ Bool (<=# sc1 0#) of _ [Occ=Dead] {
+      a =
+        GHC.Prim.+#
+          (GHC.Prim.+#
+             (GHC.Prim.+#
+                (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# sc sc) sc) sc) sc)
+             sc)
+          sc } in
+    case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# sc1 0#)
+    of _ [Occ=Dead] {
       False ->
-        case tagToEnum# @ Bool (<# sc1 100#) of _ [Occ=Dead] {
+        case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# sc1 100#)
+        of _ [Occ=Dead] {
           False ->
-            case tagToEnum# @ Bool (<# sc1 500#) of _ [Occ=Dead] {
-              False -> Roman.foo_$s$wgo (+# a a) (-# sc1 1#);
-              True -> Roman.foo_$s$wgo a (-# sc1 3#)
+            case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# sc1 500#)
+            of _ [Occ=Dead] {
+              False -> Roman.foo_$s$wgo (GHC.Prim.+# a a) (GHC.Prim.-# sc1 1#);
+              True -> Roman.foo_$s$wgo a (GHC.Prim.-# sc1 3#)
             };
-          True -> Roman.foo_$s$wgo sc (-# sc1 2#)
+          True -> Roman.foo_$s$wgo sc (GHC.Prim.-# sc1 2#)
         };
       True -> 0#
     }
 end Rec }
 
 -- RHS size: {terms: 74, types: 22, coercions: 0}
-Roman.$wgo [InlPrag=[0]] :: Maybe Int -> Maybe Int -> Int#
+Roman.$wgo [InlPrag=[0]] :: Maybe Int -> Maybe Int -> GHC.Prim.Int#
 [GblId,
  Arity=2,
  Str=DmdType <S,1*U><S,1*U>,
@@ -72,24 +85,33 @@ Roman.$wgo =
     case w1 of _ [Occ=Dead] {
       Nothing -> case Roman.foo3 of wild1 { };
       Just x ->
-        case x of _ [Occ=Dead] { I# ipv ->
+        case x of _ [Occ=Dead] { GHC.Types.I# ipv ->
         let {
-          a :: Int#
+          a :: GHC.Prim.Int#
           [LclId, Str=DmdType]
-          a = +# (+# (+# (+# (+# (+# ipv ipv) ipv) ipv) ipv) ipv) ipv } in
+          a =
+            GHC.Prim.+#
+              (GHC.Prim.+#
+                 (GHC.Prim.+#
+                    (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# ipv ipv) ipv) ipv) ipv)
+                 ipv)
+              ipv } in
         case w of _ [Occ=Dead] {
           Nothing -> Roman.foo_$s$wgo a 10#;
           Just n ->
-            case n of _ [Occ=Dead] { I# x2 ->
-            case tagToEnum# @ Bool (<=# x2 0#) of _ [Occ=Dead] {
+            case n of _ [Occ=Dead] { GHC.Types.I# x2 ->
+            case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# x2 0#)
+            of _ [Occ=Dead] {
               False ->
-                case tagToEnum# @ Bool (<# x2 100#) of _ [Occ=Dead] {
+                case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# x2 100#)
+                of _ [Occ=Dead] {
                   False ->
-                    case tagToEnum# @ Bool (<# x2 500#) of _ [Occ=Dead] {
-                      False -> Roman.foo_$s$wgo (+# a a) (-# x2 1#);
-                      True -> Roman.foo_$s$wgo a (-# x2 3#)
+                    case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# x2 500#)
+                    of _ [Occ=Dead] {
+                      False -> Roman.foo_$s$wgo (GHC.Prim.+# a a) (GHC.Prim.-# x2 1#);
+                      True -> Roman.foo_$s$wgo a (GHC.Prim.-# x2 3#)
                     };
-                  True -> Roman.foo_$s$wgo ipv (-# x2 2#)
+                  True -> Roman.foo_$s$wgo ipv (GHC.Prim.-# x2 2#)
                 };
               True -> 0#
             }
@@ -107,10 +129,10 @@ Roman.foo_go [InlPrag=INLINE[0]] :: Maybe Int -> Maybe Int -> Int
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
          Tmpl= \ (w [Occ=Once] :: Maybe Int) (w1 [Occ=Once] :: Maybe Int) ->
-                 case Roman.$wgo w w1 of ww { __DEFAULT -> I# ww }}]
+                 case Roman.$wgo w w1 of ww { __DEFAULT -> GHC.Types.I# ww }}]
 Roman.foo_go =
   \ (w :: Maybe Int) (w1 :: Maybe Int) ->
-    case Roman.$wgo w w1 of ww { __DEFAULT -> I# ww }
+    case Roman.$wgo w w1 of ww { __DEFAULT -> GHC.Types.I# ww }
 
 -- RHS size: {terms: 2, types: 0, coercions: 0}
 Roman.foo2 :: Int
@@ -119,7 +141,7 @@ Roman.foo2 :: Int
  Str=DmdType m,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
-Roman.foo2 = I# 6#
+Roman.foo2 = GHC.Types.I# 6#
 
 -- RHS size: {terms: 2, types: 1, coercions: 0}
 Roman.foo1 :: Maybe Int
@@ -128,7 +150,7 @@ Roman.foo1 :: Maybe Int
  Str=DmdType m2,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
-Roman.foo1 = Just @ Int Roman.foo2
+Roman.foo1 = GHC.Base.Just @ Int Roman.foo2
 
 -- RHS size: {terms: 11, types: 4, coercions: 0}
 foo :: Int -> Int
@@ -140,20 +162,21 @@ foo :: Int -> Int
          WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
          Tmpl= \ (n [Occ=Once!] :: Int) ->
-                 case n of n1 { I# _ [Occ=Dead] ->
-                 Roman.foo_go (Just @ Int n1) Roman.foo1
+                 case n of n1 { GHC.Types.I# _ [Occ=Dead] ->
+                 Roman.foo_go (GHC.Base.Just @ Int n1) Roman.foo1
                  }}]
 foo =
   \ (n :: Int) ->
-    case n of _ [Occ=Dead] { I# ipv ->
-    case Roman.foo_$s$wgo 6# ipv of ww { __DEFAULT -> I# ww }
+    case n of _ [Occ=Dead] { GHC.Types.I# ipv ->
+    case Roman.foo_$s$wgo 6# ipv of ww { __DEFAULT -> GHC.Types.I# ww }
     }
 
 
 ------ Local rules for imported ids --------
 "SC:$wgo0" [0]
-    forall (sc :: Int#) (sc1 :: Int#).
-      Roman.$wgo (Just @ Int (I# sc1)) (Just @ Int (I# sc))
+    forall (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#).
+      Roman.$wgo (GHC.Base.Just @ Int (GHC.Types.I# sc1))
+                 (GHC.Base.Just @ Int (GHC.Types.I# sc))
       = Roman.foo_$s$wgo sc sc1
 
 
diff --git a/testsuite/tests/stranal/should_compile/Makefile b/testsuite/tests/stranal/should_compile/Makefile
index c187ddcdc4..c7ef4304ae 100644
--- a/testsuite/tests/stranal/should_compile/Makefile
+++ b/testsuite/tests/stranal/should_compile/Makefile
@@ -8,11 +8,13 @@ include $(TOP)/mk/test.mk
 #   with two unboxed args.  See Trac #10482 for background
 T10482:
 	$(RM) -f T10482.o T10482.hi
-	'$(TEST_HC)' $(TEST_HC_OPTS) -O -c -ddump-simpl T10482.hs | grep 'T10482.*wfoo.*Int'
+	# Set -dppr-cols to ensure output doesn't wrap
+	'$(TEST_HC)' $(TEST_HC_OPTS) -dppr-cols=200 -O -c -ddump-simpl T10482.hs | grep 'T10482.*wfoo.*Int'
 
 T10482a:
 	$(RM) -f T10482a.o T10482a.hi
-	'$(TEST_HC)' $(TEST_HC_OPTS) -O -c -ddump-simpl T10482a.hs | grep 'wf.*Int'
+	# Set -dppr-cols to ensure output doesn't wrap
+	'$(TEST_HC)' $(TEST_HC_OPTS) -dppr-cols=200 -O -c -ddump-simpl T10482a.hs | grep 'wf.*Int'
 
 T10694:
 	$(RM) -f T10694.o
diff --git a/testsuite/tests/stranal/should_compile/T10482.stdout b/testsuite/tests/stranal/should_compile/T10482.stdout
index 010cb4c60e..7f8789d5f4 100644
--- a/testsuite/tests/stranal/should_compile/T10482.stdout
+++ b/testsuite/tests/stranal/should_compile/T10482.stdout
@@ -1 +1 @@
-T10482.$wfoo [InlPrag=[0], Occ=LoopBreaker] :: Int# -> Int# -> Int#
+T10482.$wfoo [InlPrag=[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
diff --git a/testsuite/tests/stranal/should_compile/T10482a.stdout b/testsuite/tests/stranal/should_compile/T10482a.stdout
index 80ec26d661..d26b45fe1a 100644
--- a/testsuite/tests/stranal/should_compile/T10482a.stdout
+++ b/testsuite/tests/stranal/should_compile/T10482a.stdout
@@ -1,4 +1,4 @@
-Foo.$wf4 [InlPrag=[0], Occ=LoopBreaker] :: Int# -> Int# -> Int#
-Foo.$wf2 [InlPrag=[0], Occ=LoopBreaker] :: Int# -> Int# -> Int#
-Foo.$wf1 [InlPrag=[0], Occ=LoopBreaker] :: Int# -> Int#
-Foo.$wf3 [InlPrag=[0], Occ=LoopBreaker] :: Int# -> Int# -> Int#
+Foo.$wf4 [InlPrag=[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
+Foo.$wf2 [InlPrag=[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
+Foo.$wf1 [InlPrag=[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int#
+Foo.$wf3 [InlPrag=[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
diff --git a/testsuite/tests/th/T3319.stderr b/testsuite/tests/th/T3319.stderr
index 4406c438fc..87ba3f54c7 100644
--- a/testsuite/tests/th/T3319.stderr
+++ b/testsuite/tests/th/T3319.stderr
@@ -4,4 +4,4 @@ T3319.hs:8:3-93: Splicing declarations
          (ImportF
             CCall Unsafe "&" (mkName "foo") (AppT (ConT ''Ptr) (ConT ''())))]
   ======>
-    foreign import ccall unsafe "static &foo" foo :: Ptr ()
+    foreign import ccall unsafe "static &foo" foo :: Ptr GHC.Tuple.()
diff --git a/testsuite/tests/th/T5700.stderr b/testsuite/tests/th/T5700.stderr
index 3564b8cb2a..729a36604f 100644
--- a/testsuite/tests/th/T5700.stderr
+++ b/testsuite/tests/th/T5700.stderr
@@ -3,4 +3,4 @@ T5700.hs:8:3-9: Splicing declarations
   ======>
     instance C D where
       {-# INLINE inlinable #-}
-      inlinable _ = ()
+      inlinable _ = GHC.Tuple.()
diff --git a/testsuite/tests/th/T7276.stderr b/testsuite/tests/th/T7276.stderr
index 1386045774..93c9a0c835 100644
--- a/testsuite/tests/th/T7276.stderr
+++ b/testsuite/tests/th/T7276.stderr
@@ -1,7 +1,8 @@
 
-T7276.hs:6:8:
-    Couldn't match type ‘[Dec]’ with ‘Exp’
-    Expected type: ExpQ
-      Actual type: DecsQ
-    In the expression: [d| y = 3 |]
-    In the untyped splice: $([d| y = 3 |])
+T7276.hs:6:8: error:
+    • Couldn't match type ‘[Language.Haskell.TH.Syntax.Dec]’
+                     with ‘Language.Haskell.TH.Syntax.Exp’
+      Expected type: Language.Haskell.TH.Lib.ExpQ
+        Actual type: Language.Haskell.TH.Lib.DecsQ
+    • In the expression: [d| y = 3 |]
+      In the untyped splice: $([d| y = 3 |])
diff --git a/testsuite/tests/th/TH_Roles2.stderr b/testsuite/tests/th/TH_Roles2.stderr
index fc264b12dd..e4a9a47858 100644
--- a/testsuite/tests/th/TH_Roles2.stderr
+++ b/testsuite/tests/th/TH_Roles2.stderr
@@ -5,17 +5,18 @@ TYPE CONSTRUCTORS
     Kind: forall k1. k1 -> *
 COERCION AXIOMS
 Dependent modules: []
-Dependent packages: [array-0.5.1.0, base-4.9.0.0, deepseq-1.4.1.1,
+Dependent packages: [array-0.5.1.0, base-4.9.0.0, deepseq-1.4.2.0,
                      ghc-boot-0.0.0.0, ghc-prim-0.5.0.0, integer-gmp-1.0.0.0,
                      pretty-1.1.2.0, template-haskell-2.11.0.0]
 
 ==================== Typechecker ====================
 TH_Roles2.$tcT
-  = TyCon
+  = GHC.Types.TyCon
       6325001754388382679##
       4656387726417942748##
       TH_Roles2.$trModule
-      (TrNameS "T"#)
+      (GHC.Types.TrNameS "T"#)
 TH_Roles2.$trModule
-  = Module (TrNameS "main"#) (TrNameS "TH_Roles2"#)
+  = GHC.Types.Module
+      (GHC.Types.TrNameS "main"#) (GHC.Types.TrNameS "TH_Roles2"#)
 
diff --git a/testsuite/tests/th/TH_foreignInterruptible.stderr b/testsuite/tests/th/TH_foreignInterruptible.stderr
index a11ec36daf..9cbf34ac87 100644
--- a/testsuite/tests/th/TH_foreignInterruptible.stderr
+++ b/testsuite/tests/th/TH_foreignInterruptible.stderr
@@ -8,4 +8,5 @@ TH_foreignInterruptible.hs:8:3-100: Splicing declarations
             (mkName "foo")
             (AppT (ConT ''Ptr) (ConT ''())))]
   ======>
-    foreign import ccall interruptible "static &foo" foo :: Ptr ()
+    foreign import ccall interruptible "static &foo" foo
+      :: Ptr GHC.Tuple.()
diff --git a/testsuite/tests/typecheck/should_compile/holes2.stderr b/testsuite/tests/typecheck/should_compile/holes2.stderr
index 869cd2d970..5541689c83 100644
--- a/testsuite/tests/typecheck/should_compile/holes2.stderr
+++ b/testsuite/tests/typecheck/should_compile/holes2.stderr
@@ -1,21 +1,22 @@
 
 holes2.hs:3:5: warning:
-    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 Module -- Defined in ‘GHC.Show’
-      instance Show Ordering -- Defined in ‘GHC.Show’
-      instance Show TrName -- Defined in ‘GHC.Show’
-      ...plus 25 others
-      (use -fprint-potential-instances to see them all)
-    In the expression: show _
-    In an equation for ‘f’: f = show _
+    • 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’
+        ...plus 22 others
+        ...plus three instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: show _
+      In an equation for ‘f’: f = show _
 
 holes2.hs:3:10: warning:
-    Found hole: _ :: a0
-    Where: ‘a0’ is an ambiguous type variable
-    In the first argument of ‘show’, namely ‘_’
-    In the expression: show _
-    In an equation for ‘f’: f = show _
-    Relevant bindings include f :: String (bound at holes2.hs:3:1)
+    • Found hole: _ :: a0
+      Where: ‘a0’ is an ambiguous type variable
+    • In the first argument of ‘show’, namely ‘_’
+      In the expression: show _
+      In an equation for ‘f’: f = show _
+    • Relevant bindings include f :: String (bound at holes2.hs:3:1)
diff --git a/testsuite/tests/typecheck/should_fail/T10971b.stderr b/testsuite/tests/typecheck/should_fail/T10971b.stderr
index 546a9d88ee..8d7b2d392f 100644
--- a/testsuite/tests/typecheck/should_fail/T10971b.stderr
+++ b/testsuite/tests/typecheck/should_fail/T10971b.stderr
@@ -1,68 +1,72 @@
 
 T10971b.hs:4:11: error:
-    Ambiguous type variable ‘t2’ arising from a use of ‘length’
-    prevents the constraint ‘(Foldable t2)’ from being solved.
-    Relevant bindings include
-      x :: t2 a (bound at T10971b.hs:4:6)
-      f :: t2 a -> Int (bound at T10971b.hs:4:1)
-    Probable fix: use a type annotation to specify what ‘t2’ should be.
-    These potential instances exist:
-      instance Foldable (Const m) -- Defined in ‘Control.Applicative’
-      instance Foldable ZipList -- Defined in ‘Control.Applicative’
-      instance Foldable (Either a) -- Defined in ‘Data.Foldable’
-      ...plus 10 others
-      (use -fprint-potential-instances to see them all)
-    In the expression: length x
-    In the expression: \ x -> length x
-    In an equation for ‘f’: f = \ x -> length x
+    • Ambiguous type variable ‘t2’ arising from a use of ‘length’
+      prevents the constraint ‘(Foldable t2)’ from being solved.
+      Relevant bindings include
+        x :: t2 a (bound at T10971b.hs:4:6)
+        f :: t2 a -> Int (bound at T10971b.hs:4:1)
+      Probable fix: use a type annotation to specify what ‘t2’ should be.
+      These potential instances exist:
+        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
+        instance Foldable Maybe -- Defined in ‘Data.Foldable’
+        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
+        ...plus one other
+        ...plus 9 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: length x
+      In the expression: \ x -> length x
+      In an equation for ‘f’: f = \ x -> length x
 
 T10971b.hs:5:13: error:
-    Ambiguous type variable ‘t1’ arising from a use of ‘fmapDefault’
-    prevents the constraint ‘(Traversable t1)’ from being solved.
-    Relevant bindings include
-      x :: t1 a (bound at T10971b.hs:5:8)
-      g :: (a -> b) -> t1 a -> t1 b (bound at T10971b.hs:5:1)
-    Probable fix: use a type annotation to specify what ‘t1’ should be.
-    These potential instances exist:
-      instance Traversable (Const m) -- Defined in ‘Data.Traversable’
-      instance Traversable ZipList -- Defined in ‘Data.Traversable’
-      instance Traversable (Either a) -- Defined in ‘Data.Traversable’
-      ...plus 10 others
-      (use -fprint-potential-instances to see them all)
-    In the expression: fmapDefault f x
-    In the expression: \ f x -> fmapDefault f x
-    In an equation for ‘g’: g = \ f x -> fmapDefault f x
+    • Ambiguous type variable ‘t1’ arising from a use of ‘fmapDefault’
+      prevents the constraint ‘(Traversable t1)’ from being solved.
+      Relevant bindings include
+        x :: t1 a (bound at T10971b.hs:5:8)
+        g :: (a -> b) -> t1 a -> t1 b (bound at T10971b.hs:5:1)
+      Probable fix: use a type annotation to specify what ‘t1’ should be.
+      These potential instances exist:
+        instance Traversable (Either a) -- Defined in ‘Data.Traversable’
+        instance Traversable Maybe -- Defined in ‘Data.Traversable’
+        instance Traversable ((,) a) -- Defined in ‘Data.Traversable’
+        ...plus one other
+        ...plus 9 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: fmapDefault f x
+      In the expression: \ f x -> fmapDefault f x
+      In an equation for ‘g’: g = \ f x -> fmapDefault f x
 
 T10971b.hs:6:14: error:
-    Ambiguous type variable ‘t0’ arising from a use of ‘fmapDefault’
-    prevents the constraint ‘(Traversable t0)’ from being solved.
-    Relevant bindings include
-      x :: t0 a (bound at T10971b.hs:6:8)
-      h :: (a -> b) -> t0 a -> (t0 b, Int) (bound at T10971b.hs:6:1)
-    Probable fix: use a type annotation to specify what ‘t0’ should be.
-    These potential instances exist:
-      instance Traversable (Const m) -- Defined in ‘Data.Traversable’
-      instance Traversable ZipList -- Defined in ‘Data.Traversable’
-      instance Traversable (Either a) -- Defined in ‘Data.Traversable’
-      ...plus 10 others
-      (use -fprint-potential-instances to see them all)
-    In the expression: fmapDefault f x
-    In the expression: (fmapDefault f x, length x)
-    In the expression: \ f x -> (fmapDefault f x, length x)
+    • Ambiguous type variable ‘t0’ arising from a use of ‘fmapDefault’
+      prevents the constraint ‘(Traversable t0)’ from being solved.
+      Relevant bindings include
+        x :: t0 a (bound at T10971b.hs:6:8)
+        h :: (a -> b) -> t0 a -> (t0 b, Int) (bound at T10971b.hs:6:1)
+      Probable fix: use a type annotation to specify what ‘t0’ should be.
+      These potential instances exist:
+        instance Traversable (Either a) -- Defined in ‘Data.Traversable’
+        instance Traversable Maybe -- Defined in ‘Data.Traversable’
+        instance Traversable ((,) a) -- Defined in ‘Data.Traversable’
+        ...plus one other
+        ...plus 9 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: fmapDefault f x
+      In the expression: (fmapDefault f x, length x)
+      In the expression: \ f x -> (fmapDefault f x, length x)
 
 T10971b.hs:6:31: error:
-    Ambiguous type variable ‘t0’ arising from a use of ‘length’
-    prevents the constraint ‘(Foldable t0)’ from being solved.
-    Relevant bindings include
-      x :: t0 a (bound at T10971b.hs:6:8)
-      h :: (a -> b) -> t0 a -> (t0 b, Int) (bound at T10971b.hs:6:1)
-    Probable fix: use a type annotation to specify what ‘t0’ should be.
-    These potential instances exist:
-      instance Foldable (Const m) -- Defined in ‘Control.Applicative’
-      instance Foldable ZipList -- Defined in ‘Control.Applicative’
-      instance Foldable (Either a) -- Defined in ‘Data.Foldable’
-      ...plus 10 others
-      (use -fprint-potential-instances to see them all)
-    In the expression: length x
-    In the expression: (fmapDefault f x, length x)
-    In the expression: \ f x -> (fmapDefault f x, length x)
+    • Ambiguous type variable ‘t0’ arising from a use of ‘length’
+      prevents the constraint ‘(Foldable t0)’ from being solved.
+      Relevant bindings include
+        x :: t0 a (bound at T10971b.hs:6:8)
+        h :: (a -> b) -> t0 a -> (t0 b, Int) (bound at T10971b.hs:6:1)
+      Probable fix: use a type annotation to specify what ‘t0’ should be.
+      These potential instances exist:
+        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
+        instance Foldable Maybe -- Defined in ‘Data.Foldable’
+        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
+        ...plus one other
+        ...plus 9 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: length x
+      In the expression: (fmapDefault f x, length x)
+      In the expression: \ f x -> (fmapDefault f x, length x)
diff --git a/testsuite/tests/typecheck/should_fail/T5095.stderr b/testsuite/tests/typecheck/should_fail/T5095.stderr
index a854b7ea75..cc338e7afa 100644
--- a/testsuite/tests/typecheck/should_fail/T5095.stderr
+++ b/testsuite/tests/typecheck/should_fail/T5095.stderr
@@ -1,16 +1,16 @@
 
 T5095.hs:9:11: error:
-    Overlapping instances for Eq a arising from a use of ‘==’
-    Matching instances:
-      instance [overlappable] Show a => Eq a -- Defined at T5095.hs:5:31
-      instance (Eq a, Eq b) => Eq (Either a b)
-        -- Defined in ‘Data.Either’
-      instance Eq All -- Defined in ‘Data.Monoid’
-      ...plus 36 others
-      ...plus one instance involving out-of-scope types
-      (use -fprint-potential-instances to see them all)
-    (The choice depends on the instantiation of ‘a’
-     To pick the first instance above, use IncoherentInstances
-     when compiling the other instance declarations)
-    In the expression: x == y
-    In an equation for ‘f’: f x y = x == y
+    • Overlapping instances for Eq a arising from a use of ‘==’
+      Matching instances:
+        instance [overlappable] Show a => Eq a -- Defined at T5095.hs:5:31
+        instance (Eq a, Eq b) => Eq (Either a b)
+          -- Defined in ‘Data.Either’
+        instance Eq Ordering -- Defined in ‘GHC.Classes’
+        ...plus 24 others
+        ...plus 13 instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+      (The choice depends on the instantiation of ‘a’
+       To pick the first instance above, use IncoherentInstances
+       when compiling the other instance declarations)
+    • In the expression: x == y
+      In an equation for ‘f’: f x y = x == y
diff --git a/testsuite/tests/typecheck/should_fail/T8262.stderr b/testsuite/tests/typecheck/should_fail/T8262.stderr
index 45e201cc76..d52ee31a31 100644
--- a/testsuite/tests/typecheck/should_fail/T8262.stderr
+++ b/testsuite/tests/typecheck/should_fail/T8262.stderr
@@ -1,7 +1,7 @@
 
 T8262.hs:5:15: error:
     • Couldn't match a lifted type with an unlifted type
-      When matching the kind of ‘Int#’
+      When matching the kind of ‘GHC.Prim.Int#’
     • In the first argument of ‘Just’, namely ‘(1#)’
       In the expression: Just (1#)
       In an equation for ‘foo’: foo x = Just (1#)
diff --git a/testsuite/tests/typecheck/should_fail/TcCoercibleFail.stderr b/testsuite/tests/typecheck/should_fail/TcCoercibleFail.stderr
index 8141caf5b5..1767e8e976 100644
--- a/testsuite/tests/typecheck/should_fail/TcCoercibleFail.stderr
+++ b/testsuite/tests/typecheck/should_fail/TcCoercibleFail.stderr
@@ -29,7 +29,8 @@ TcCoercibleFail.hs:18:8: error:
     • Couldn't match representation of type ‘Int’
                                with that of ‘Down Int’
         arising from a use of ‘coerce’
-      The data constructor ‘Down’ of newtype ‘Down’ is not in scope
+      The data constructor ‘Data.Ord.Down’
+        of newtype ‘Down’ is not in scope
     • In the expression: coerce
       In the expression: coerce $ one :: Down Int
       In an equation for ‘foo4’: foo4 = coerce $ one :: Down Int
diff --git a/testsuite/tests/typecheck/should_fail/TcStaticPointersFail02.stderr b/testsuite/tests/typecheck/should_fail/TcStaticPointersFail02.stderr
index f63fb47789..e6e637cfeb 100644
--- a/testsuite/tests/typecheck/should_fail/TcStaticPointersFail02.stderr
+++ b/testsuite/tests/typecheck/should_fail/TcStaticPointersFail02.stderr
@@ -1,13 +1,15 @@
 
 TcStaticPointersFail02.hs:9:6: error:
-    No instance for (Typeable b) arising from a static form
-    In the expression: static (undefined :: (forall a. a -> a) -> b)
-    In an equation for ‘f1’:
-        f1 = static (undefined :: (forall a. a -> a) -> b)
+    • No instance for (Data.Typeable.Internal.Typeable b)
+        arising from a static form
+    • In the expression: static (undefined :: (forall a. a -> a) -> b)
+      In an equation for ‘f1’:
+          f1 = static (undefined :: (forall a. a -> a) -> b)
 
 TcStaticPointersFail02.hs:12:6: error:
-    No instance for (Typeable (Monad m => a -> m a))
-      arising from a static form
-      (maybe you haven't applied a function to enough arguments?)
-    In the expression: static return
-    In an equation for ‘f2’: f2 = static return
+    • No instance for (Data.Typeable.Internal.Typeable
+                         (Monad m => a -> m a))
+        arising from a static form
+        (maybe you haven't applied a function to enough arguments?)
+    • In the expression: static return
+      In an equation for ‘f2’: f2 = static return
diff --git a/testsuite/tests/typecheck/should_fail/tcfail068.stderr b/testsuite/tests/typecheck/should_fail/tcfail068.stderr
index f80a2cf1bb..5ca47f52ed 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail068.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail068.stderr
@@ -3,7 +3,7 @@ tcfail068.hs:14:9: error:
     • Couldn't match type ‘s1’ with ‘s’
       ‘s1’ is a rigid type variable bound by
         a type expected by the context:
-          forall s1. ST s1 (IndTree s a)
+          forall s1. GHC.ST.ST s1 (IndTree s a)
         at tcfail068.hs:13:9
       ‘s’ is a rigid type variable bound by
         the type signature for:
@@ -11,8 +11,8 @@ tcfail068.hs:14:9: error:
                    Constructed a =>
                    (Int, Int) -> a -> IndTree s a
         at tcfail068.hs:11:10
-      Expected type: ST s1 (IndTree s a)
-        Actual type: ST s1 (STArray s1 (Int, Int) a)
+      Expected type: GHC.ST.ST s1 (IndTree s a)
+        Actual type: GHC.ST.ST s1 (STArray s1 (Int, Int) a)
     • In the first argument of ‘runST’, namely
         ‘(newSTArray ((1, 1), n) x)’
       In the expression: runST (newSTArray ((1, 1), n) x)
@@ -30,7 +30,7 @@ tcfail068.hs:19:21: error:
         at tcfail068.hs:16:10
       ‘s1’ is a rigid type variable bound by
         a type expected by the context:
-          forall s1. ST s1 (IndTree s a)
+          forall s1. GHC.ST.ST s1 (IndTree s a)
         at tcfail068.hs:18:9
       Expected type: STArray s1 (Int, Int) a
         Actual type: IndTree s a
@@ -51,16 +51,16 @@ tcfail068.hs:24:36: error:
         at tcfail068.hs:23:10
       ‘s1’ is a rigid type variable bound by
         a type expected by the context:
-          forall s1. ST s1 (IndTree s a)
+          forall s1. GHC.ST.ST s1 (IndTree s a)
         at tcfail068.hs:24:29
-      Expected type: ST s1 (IndTree s a)
-        Actual type: ST s (IndTree s a)
+      Expected type: GHC.ST.ST s1 (IndTree s a)
+        Actual type: GHC.ST.ST s (IndTree s a)
     • In the first argument of ‘runST’, namely ‘(itrap' i k)’
       In the expression: runST (itrap' i k)
     • Relevant bindings include
-        itrap' :: Int -> Int -> ST s (IndTree s a)
+        itrap' :: Int -> Int -> GHC.ST.ST s (IndTree s a)
           (bound at tcfail068.hs:26:9)
-        itrapsnd :: Int -> Int -> ST s (IndTree s a)
+        itrapsnd :: Int -> Int -> GHC.ST.ST s (IndTree s a)
           (bound at tcfail068.hs:29:9)
         arr :: IndTree s a (bound at tcfail068.hs:24:23)
         itrap :: ((Int, Int), (Int, Int))
@@ -83,16 +83,16 @@ tcfail068.hs:36:46: error:
         at tcfail068.hs:34:15
       ‘s1’ is a rigid type variable bound by
         a type expected by the context:
-          forall s1. ST s1 (c, IndTree s b)
+          forall s1. GHC.ST.ST s1 (c, IndTree s b)
         at tcfail068.hs:36:40
-      Expected type: ST s1 (c, IndTree s b)
-        Actual type: ST s (c, IndTree s b)
+      Expected type: GHC.ST.ST s1 (c, IndTree s b)
+        Actual type: GHC.ST.ST s (c, IndTree s b)
     • In the first argument of ‘runST’, namely ‘(itrapstate' i k s)’
       In the expression: runST (itrapstate' i k s)
     • Relevant bindings include
-        itrapstate' :: Int -> Int -> c -> ST s (c, IndTree s b)
+        itrapstate' :: Int -> Int -> c -> GHC.ST.ST s (c, IndTree s b)
           (bound at tcfail068.hs:38:9)
-        itrapstatesnd :: Int -> Int -> c -> ST s (c, IndTree s b)
+        itrapstatesnd :: Int -> Int -> c -> GHC.ST.ST s (c, IndTree s b)
           (bound at tcfail068.hs:41:9)
         arr :: IndTree s b (bound at tcfail068.hs:36:34)
         itrapstate :: ((Int, Int), (Int, Int))
diff --git a/testsuite/tests/typecheck/should_fail/tcfail072.stderr b/testsuite/tests/typecheck/should_fail/tcfail072.stderr
index fa6752b37b..200b7f0d6d 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail072.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail072.stderr
@@ -1,18 +1,18 @@
 
 tcfail072.hs:23:13: error:
-    Could not deduce (Ord p0) arising from a use of ‘g’
-    from the context: (Ord p, Ord q)
-      bound by the type signature for:
-                 g :: (Ord p, Ord q) => AB p q -> Bool
-      at tcfail072.hs:22:1-38
-    The type variable ‘p0’ is ambiguous
-    These potential instances exist:
-      instance Ord Ordering -- Defined in ‘GHC.Classes’
-      instance Ord TyCon -- Defined in ‘GHC.Classes’
-      instance Ord Integer
-        -- Defined in ‘integer-gmp-1.0.0.0:GHC.Integer.Type’
-      ...plus 23 others
-      ...plus one instance involving out-of-scope types
-      (use -fprint-potential-instances to see them all)
-    In the expression: g A
-    In an equation for ‘g’: g (B _ _) = g A
+    • Could not deduce (Ord p0) arising from a use of ‘g’
+      from the context: (Ord p, Ord q)
+        bound by the type signature for:
+                   g :: (Ord p, Ord q) => AB p q -> Bool
+        at tcfail072.hs:22:1-38
+      The type variable ‘p0’ is ambiguous
+      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’
+        instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Base’
+        ...plus 22 others
+        ...plus two instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: g A
+      In an equation for ‘g’: g (B _ _) = g A
diff --git a/testsuite/tests/typecheck/should_fail/tcfail123.stderr b/testsuite/tests/typecheck/should_fail/tcfail123.stderr
index 00b8bbdd10..8f5f0a0afe 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail123.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail123.stderr
@@ -1,7 +1,7 @@
 
 tcfail123.hs:11:9: error:
-    Couldn't match a lifted type with an unlifted type
-    When matching the kind of ‘Int#’
-    In the first argument of ‘f’, namely ‘3#’
-    In the expression: f 3#
-    In an equation for ‘h’: h v = f 3#
+    • Couldn't match a lifted type with an unlifted type
+      When matching the kind of ‘GHC.Prim.Int#’
+    • In the first argument of ‘f’, namely ‘3#’
+      In the expression: f 3#
+      In an equation for ‘h’: h v = f 3#
diff --git a/testsuite/tests/typecheck/should_fail/tcfail128.stderr b/testsuite/tests/typecheck/should_fail/tcfail128.stderr
index 1aab117592..63e314d80c 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail128.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail128.stderr
@@ -1,22 +1,22 @@
 
 tcfail128.hs:18:16: error:
-    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
-    In the expression:
-      do { let sL = ...
-               dim = length sL
-               ....;
-           v <- thaw tmp;
-           return () }
-    In an equation for ‘main’:
-        main
-          = do { let sL = ...
-                     ....;
-                 v <- thaw tmp;
-                 return () }
+    • 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:
+        one instance involving out-of-scope types
+        (use -fprint-potential-instances to see them all)
+    • In a stmt of a 'do' block: v <- thaw tmp
+      In the expression:
+        do { let sL = ...
+                 dim = length sL
+                 ....;
+             v <- thaw tmp;
+             return () }
+      In an equation for ‘main’:
+          main
+            = do { let sL = ...
+                       ....;
+                   v <- thaw tmp;
+                   return () }
diff --git a/testsuite/tests/typecheck/should_fail/tcfail133.stderr b/testsuite/tests/typecheck/should_fail/tcfail133.stderr
index f629ea0140..ac85d0be71 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail133.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail133.stderr
@@ -3,25 +3,27 @@ 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:
-    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 Module -- Defined in ‘GHC.Show’
-      instance Show Ordering -- Defined in ‘GHC.Show’
-      instance Show TrName -- Defined in ‘GHC.Show’
-      ...plus 28 others
-      (use -fprint-potential-instances to see them all)
-    In the expression: show
-    In the expression: show $ add (One :@ Zero) (One :@ One)
-    In an equation for ‘foo’:
-        foo = show $ add (One :@ Zero) (One :@ One)
+    • 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 b, Number a, Digit b) => Show (a :@ b)
+          -- Defined at tcfail133.hs:11:54
+        ...plus 25 others
+        ...plus three instance involving out-of-scope typess
+        (use -fprint-potential-instances to see them all)
+    • In the expression: show
+      In the expression: show $ add (One :@ Zero) (One :@ One)
+      In an equation for ‘foo’:
+          foo = show $ add (One :@ Zero) (One :@ One)
 
 tcfail133.hs:68:14: error:
-    No instance for (AddDigit (Zero :@ (One :@ One)) One a0)
-      arising from a use of ‘add’
-    In the second argument of ‘($)’, namely
-      ‘add (One :@ Zero) (One :@ One)’
-    In the expression: show $ add (One :@ Zero) (One :@ One)
-    In an equation for ‘foo’:
-        foo = show $ add (One :@ Zero) (One :@ One)
+    • No instance for (AddDigit (Zero :@ (One :@ One)) One a0)
+        arising from a use of ‘add’
+    • In the second argument of ‘($)’, namely
+        ‘add (One :@ Zero) (One :@ One)’
+      In the expression: show $ add (One :@ Zero) (One :@ One)
+      In an equation for ‘foo’:
+          foo = show $ add (One :@ Zero) (One :@ One)
diff --git a/testsuite/tests/typecheck/should_fail/tcfail200.stderr b/testsuite/tests/typecheck/should_fail/tcfail200.stderr
index c8a6fa94f2..407265ee9d 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail200.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail200.stderr
@@ -1,7 +1,7 @@
 
 tcfail200.hs:5:15: error:
     • Couldn't match a lifted type with an unlifted type
-      When matching the kind of ‘Int#’
+      When matching the kind of ‘GHC.Prim.Int#’
     • In the expression: 1#
       In the expression: (1#, 'c')
       In an equation for ‘x’: x = (1#, 'c')
diff --git a/testsuite/tests/typecheck/should_fail/tcfail220.stderr b/testsuite/tests/typecheck/should_fail/tcfail220.stderr
index d78fa6d83e..6228bfa984 100644
--- a/testsuite/tests/typecheck/should_fail/tcfail220.stderr
+++ b/testsuite/tests/typecheck/should_fail/tcfail220.stderr
@@ -3,7 +3,7 @@
 tcfail220.hsig:4:1: error:
     Type constructor ‘Either’ has conflicting definitions in the module
     and its hsig file
-    Main module: data Either a b = Left a | Right b
+    Main module: data Either a b = Left a | Data.Either.Right b
     Hsig file:  type role Either representational phantom phantom
                 data Either a b c = Left a
     The types have different kinds
diff --git a/testsuite/tests/typecheck/should_run/T8119.stdout b/testsuite/tests/typecheck/should_run/T8119.stdout
index e796b66d24..7e9d9e1558 100644
--- a/testsuite/tests/typecheck/should_run/T8119.stdout
+++ b/testsuite/tests/typecheck/should_run/T8119.stdout
@@ -1,3 +1,3 @@
 test `asTypeOf` (undefined :: a -> b)
-  :: (?callStack::CallStack) => Int -> Int
+  :: (?callStack::GHC.Stack.Types.CallStack) => Int -> Int
 \x -> test x :: Int -> Int
diff --git a/testsuite/tests/wcompat-warnings/WCompatWarningsOn.stderr b/testsuite/tests/wcompat-warnings/WCompatWarningsOn.stderr
index 5de8745544..ee2ded8516 100644
--- a/testsuite/tests/wcompat-warnings/WCompatWarningsOn.stderr
+++ b/testsuite/tests/wcompat-warnings/WCompatWarningsOn.stderr
@@ -1,6 +1,6 @@
 
 WCompatWarningsOn.hs:13:5: warning:
-    • Could not deduce (MonadFail m)
+    • Could not deduce (Control.Monad.Fail.MonadFail m)
         arising from the failable pattern ‘Just _’
         (this will become an error a future GHC release)
       from the context: Monad m
@@ -8,7 +8,7 @@ WCompatWarningsOn.hs:13:5: warning:
                    monadFail :: Monad m => m a
         at WCompatWarningsOn.hs:11:1-27
       Possible fix:
-        add (MonadFail m) to the context of
+        add (Control.Monad.Fail.MonadFail m) to the context of
           the type signature for:
             monadFail :: Monad m => m a
     • In a stmt of a 'do' block: Just _ <- undefined
@@ -26,7 +26,7 @@ WCompatWarningsOn.hs:16:1: warning:
 
 WCompatWarningsOn.hs:22:3: warning:
     Noncanonical ‘(<>) = mappend’ definition detected
-    in the instance declaration for ‘Semigroup S’.
+    in the instance declaration for ‘Semi.Semigroup S’.
     Move definition from ‘mappend’ to ‘(<>)’
 
 WCompatWarningsOn.hs:25:3: warning: