Adjust test suite to new Language Pragma warnigns

(this is related to #3647)

testsuite/tests/deriving/should_fail/Roles5.stderr

 
 Roles5.hs:3:8:
     Illegal role annotation
-    Perhaps you intended to use -XRoleAnnotations
+    Perhaps you intended to use RoleAnnotations
     In the data type declaration for ‛T’
 
 Roles5.hs:4:9:
     Illegal role annotation
-    Perhaps you intended to use -XRoleAnnotations
+    Perhaps you intended to use RoleAnnotations
     In the declaration for class C
 
 Roles5.hs:5:8:
     Illegal role annotation
-    Perhaps you intended to use -XRoleAnnotations
+    Perhaps you intended to use RoleAnnotations
     In the declaration for type synonym ‛S’

testsuite/tests/deriving/should_fail/T1133A.stderr

@@ -3,5 +3,5 @@ T1133A.hs:6:28:
     Can't make a derived instance of ‛Enum X’:
       ‛X’ must be an enumeration type
       (an enumeration consists of one or more nullary, non-GADT constructors)
-      Try -XGeneralizedNewtypeDeriving for GHC's newtype-deriving extension
+      Try GeneralizedNewtypeDeriving for GHC's newtype-deriving extension
     In the newtype declaration for ‛X’

testsuite/tests/deriving/should_fail/T2604.stderr

 
 T2604.hs:7:35:
     Can't make a derived instance of ‛Typeable * (DList a)’:
-      You need -XDeriveDataTypeable to derive an instance for this class
+      You need DeriveDataTypeable to derive an instance for this class
     In the data declaration for ‛DList’
 
 T2604.hs:9:38:
     Can't make a derived instance of ‛Typeable * (NList a)’:
-      You need -XDeriveDataTypeable to derive an instance for this class
+      You need DeriveDataTypeable to derive an instance for this class
     In the newtype declaration for ‛NList’

testsuite/tests/deriving/should_fail/T3833.stderr

@@ -2,5 +2,5 @@
 T3833.hs:9:1:
     Can't make a derived instance of ‛Monoid (DecodeMap e)’:
       ‛Monoid’ is not a derivable class
-      Try -XGeneralizedNewtypeDeriving for GHC's newtype-deriving extension
+      Try GeneralizedNewtypeDeriving for GHC's newtype-deriving extension
     In the stand-alone deriving instance for ‛Monoid (DecodeMap e)’

testsuite/tests/deriving/should_fail/T3834.stderr

@@ -2,5 +2,5 @@
 T3834.hs:8:1:
     Can't make a derived instance of ‛C T’:
       ‛C’ is not a derivable class
-      Try -XGeneralizedNewtypeDeriving for GHC's newtype-deriving extension
+      Try GeneralizedNewtypeDeriving for GHC's newtype-deriving extension
     In the stand-alone deriving instance for ‛C T’

testsuite/tests/deriving/should_fail/drvfail-functor1.stderr

 
 drvfail-functor1.hs:6:14:
     Can't make a derived instance of ‛Functor List’:
-      You need -XDeriveFunctor to derive an instance for this class
+      You need DeriveFunctor to derive an instance for this class
     In the data declaration for ‛List’

testsuite/tests/deriving/should_fail/drvfail015.stderr

@@ -3,7 +3,7 @@ drvfail015.hs:10:19:
     Illegal instance declaration for ‛Eq T’
       (All instance types must be of the form (T t1 ... tn)
        where T is not a synonym.
-       Use -XTypeSynonymInstances if you want to disable this.)
+       Use TypeSynonymInstances if you want to disable this.)
     In the stand-alone deriving instance for ‛Eq T’
 
 drvfail015.hs:13:1:

testsuite/tests/gadt/gadtSyntaxFail001.stderr

@@ -2,6 +2,6 @@
 gadtSyntaxFail001.hs:8:5:
     Data constructor ‛C2’ has existential type variables, a context, or a specialised result type
       C2 :: forall a. a -> Char -> Foo a Int
-      (Use -XExistentialQuantification or -XGADTs to allow this)
+      (Use ExistentialQuantification or GADTs to allow this)
     In the definition of data constructor ‛C2’
     In the data declaration for ‛Foo’

testsuite/tests/gadt/gadtSyntaxFail002.stderr

@@ -2,6 +2,6 @@
 gadtSyntaxFail002.hs:8:5:
     Data constructor ‛C2’ has existential type variables, a context, or a specialised result type
       C2 :: forall a. a -> Char -> Foo a a
-      (Use -XExistentialQuantification or -XGADTs to allow this)
+      (Use ExistentialQuantification or GADTs to allow this)
     In the definition of data constructor ‛C2’
     In the data declaration for ‛Foo’

testsuite/tests/gadt/gadtSyntaxFail003.stderr

@@ -2,6 +2,6 @@
 gadtSyntaxFail003.hs:7:5:
     Data constructor ‛C1’ has existential type variables, a context, or a specialised result type
       C1 :: forall b a c. a -> Int -> c -> Foo b a
-      (Use -XExistentialQuantification or -XGADTs to allow this)
+      (Use ExistentialQuantification or GADTs to allow this)
     In the definition of data constructor ‛C1’
     In the data declaration for ‛Foo’

testsuite/tests/generics/GenShouldFail0.stderr

 
 GenShouldFail0.hs:9:1:
     Can't make a derived instance of ‛Generic X’:
-      You need -XDeriveGeneric to derive an instance for this class
+      You need DeriveGeneric to derive an instance for this class
     In the stand-alone deriving instance for ‛Generic X’

testsuite/tests/generics/GenShouldFail1_0.stderr

 
 GenShouldFail1_0.hs:9:1:
     Can't make a derived instance of ‛Generic1 X’:
-      You need -XDeriveGeneric to derive an instance for this class
+      You need DeriveGeneric to derive an instance for this class
     In the stand-alone deriving instance for ‛Generic1 X’

testsuite/tests/ghci/prog006/prog006.stderr

 
 Boot.hs:5:13:
     Not a data constructor: ‛forall’
-    Perhaps you intended to use -XExistentialQuantification
+    Perhaps you intended to use ExistentialQuantification

testsuite/tests/ghci/scripts/ghci044.stderr

@@ -4,7 +4,7 @@
       (All instance types must be of the form (T a1 ... an)
        where a1 ... an are *distinct type variables*,
        and each type variable appears at most once in the instance head.
-       Use -XFlexibleInstances if you want to disable this.)
+       Use FlexibleInstances if you want to disable this.)
     In the instance declaration for ‛C [Int]’
 
 <interactive>:7:10:

testsuite/tests/ghci/scripts/ghci057.stderr

 
 <interactive>:5:1:
     Illegal generalised algebraic data declaration for ‛T’
-      (Use -XGADTs to allow GADTs)
+      (Use GADTs to allow GADTs)
     In the data declaration for ‛T’
 
 ghci057.hs:3:3:
     Data constructor ‛C’ has existential type variables, a context, or a specialised result type
       C :: T Int
-      (Use -XExistentialQuantification or -XGADTs to allow this)
+      (Use ExistentialQuantification or GADTs to allow this)
     In the definition of data constructor ‛C’
     In the data declaration for ‛T’
 
 ghci057.hs:3:3:
     Data constructor ‛C’ has existential type variables, a context, or a specialised result type
       C :: T Int
-      (Use -XExistentialQuantification or -XGADTs to allow this)
+      (Use ExistentialQuantification or GADTs to allow this)
     In the definition of data constructor ‛C’
     In the data declaration for ‛T’

testsuite/tests/indexed-types/should_fail/NotRelaxedExamples.stderr

@@ -2,17 +2,17 @@
 NotRelaxedExamples.hs:9:15:
     Nested type family application
       in the type family application: F1 (F1 Char)
-    (Use -XUndecidableInstances to permit this)
+    (Use UndecidableInstances to permit this)
     In the type instance declaration for ‛F1’
 
 NotRelaxedExamples.hs:10:15:
     Application is no smaller than the instance head
       in the type family application: F2 [x]
-    (Use -XUndecidableInstances to permit this)
+    (Use UndecidableInstances to permit this)
     In the type instance declaration for ‛F2’
 
 NotRelaxedExamples.hs:11:15:
     Application is no smaller than the instance head
       in the type family application: F3 [Char]
-    (Use -XUndecidableInstances to permit this)
+    (Use UndecidableInstances to permit this)
     In the type instance declaration for ‛F3’

testsuite/tests/indexed-types/should_fail/SimpleFail15.stderr

 
 SimpleFail15.hs:5:8:
     Illegal polymorphic or qualified type: a ~ b => t
-    Perhaps you intended to use -XRankNTypes or -XRank2Types
+    Perhaps you intended to use RankNTypes or Rank2Types
     In the type signature for ‛foo’:
       foo :: (a, b) -> (a ~ b => t) -> (a, b)

testsuite/tests/indexed-types/should_fail/T4485.stderr

@@ -11,7 +11,7 @@ T4485.hs:47:15:
                               (IdentityT IO) (XMLGenT Identity ())
         -- Defined at T4485.hs:42:10
     (The choice depends on the instantiation of ‛m0’
-     To pick the first instance above, use -XIncoherentInstances
+     To pick the first instance above, use IncoherentInstances
      when compiling the other instance declarations)
     In the expression: asChild
     In the expression: asChild $ (genElement "foo")

testsuite/tests/indexed-types/should_fail/T5934.stderr

@@ -2,6 +2,6 @@
 T5934.hs:12:7:
     Cannot instantiate unification variable ‛a0’
     with a type involving foralls: (forall s. GenST s) -> Int
-      Perhaps you want -XImpredicativeTypes
+      Perhaps you want ImpredicativeTypes
     In the expression: 0
     In an equation for ‛run’: run = 0

testsuite/tests/indexed-types/should_fail/TyFamUndec.stderr

@@ -2,17 +2,17 @@
 TyFamUndec.hs:6:15:
     Variable ‛b’ occurs more often than in the instance head
       in the type family application: T (b, b)
-    (Use -XUndecidableInstances to permit this)
+    (Use UndecidableInstances to permit this)
     In the type instance declaration for ‛T’
 
 TyFamUndec.hs:7:15:
     Application is no smaller than the instance head
       in the type family application: T (a, Maybe b)
-    (Use -XUndecidableInstances to permit this)
+    (Use UndecidableInstances to permit this)
     In the type instance declaration for ‛T’
 
 TyFamUndec.hs:8:15:
     Nested type family application
       in the type family application: T (a, T b)
-    (Use -XUndecidableInstances to permit this)
+    (Use UndecidableInstances to permit this)
     In the type instance declaration for ‛T’

testsuite/tests/module/mod41.stderr

@@ -4,5 +4,5 @@ mod41.hs:3:18:
       (All instance types must be of the form (T a1 ... an)
        where a1 ... an are *distinct type variables*,
        and each type variable appears at most once in the instance head.
-       Use -XFlexibleInstances if you want to disable this.)
+       Use FlexibleInstances if you want to disable this.)
     In the instance declaration for ‛Eq (Either a a)’

testsuite/tests/module/mod42.stderr

@@ -4,5 +4,5 @@ mod42.hs:3:10:
       (All instance types must be of the form (T a1 ... an)
        where a1 ... an are *distinct type variables*,
        and each type variable appears at most once in the instance head.
-       Use -XFlexibleInstances if you want to disable this.)
+       Use FlexibleInstances if you want to disable this.)
     In the instance declaration for ‛Eq a’

testsuite/tests/module/mod43.stderr

@@ -3,5 +3,5 @@ mod43.hs:3:10:
     Illegal instance declaration for ‛Eq String’
       (All instance types must be of the form (T t1 ... tn)
        where T is not a synonym.
-       Use -XTypeSynonymInstances if you want to disable this.)
+       Use TypeSynonymInstances if you want to disable this.)
     In the instance declaration for ‛Eq String’

testsuite/tests/module/mod45.stderr

@@ -2,5 +2,5 @@
 mod45.hs:5:11:
     Illegal type signature in instance declaration:
       (==) :: T -> T -> Bool
-    (Use -XInstanceSigs to allow this)
+    (Use InstanceSigs to allow this)
     In the instance declaration for ‛Eq T’

testsuite/tests/parser/should_fail/NoDoAndIfThenElse.stderr

@@ -2,4 +2,4 @@
 NoDoAndIfThenElse.hs:7:13:
     Unexpected semi-colons in conditional:
         if True; then return (); else return ()
-    Perhaps you meant to use -XDoAndIfThenElse?
+    Perhaps you meant to use DoAndIfThenElse?

testsuite/tests/parser/should_fail/ParserNoForallUnicode.stderr

 
 ParserNoForallUnicode.hs:5:8:
     Illegal symbol '∀' in type
-    Perhaps you intended -XRankNTypes or similar flag
-    to enable explicit-forall syntax: ∀ <tvs>. <type>
+    Perhaps you intended to use RankNTypes or a similar language
+    extension to enable explicit-forall syntax: ∀ <tvs>. <type>

testsuite/tests/parser/should_fail/ParserNoMultiWayIf.stderr

 
 ParserNoMultiWayIf.hs:4:5:
-    Multi-way if-expressions need -XMultiWayIf turned on
+    Multi-way if-expressions need MultiWayIf turned on

testsuite/tests/parser/should_fail/T3095.stderr

 
 T3095.hs:5:21:
     Illegal symbol '.' in type
-    Perhaps you intended -XRankNTypes or similar flag
-    to enable explicit-forall syntax: forall <tvs>. <type>
+    Perhaps you intended to use RankNTypes or a similar language
+    extension to enable explicit-forall syntax: forall <tvs>. <type>

testsuite/tests/parser/should_fail/T3811e.stderr

 
 T3811e.hs:6:6:
-    Illegal datatype context (use -XDatatypeContexts): (Show a,
-                                                        Read a) =>
-
+    Illegal datatype context (use DatatypeContexts): (Show a,
+                                                      Read a) =>

testsuite/tests/parser/should_fail/readFail001.stderr

@@ -4,11 +4,11 @@ readFail001.hs:25:11:
 
 readFail001.hs:38:32:
     Not in scope: type constructor or class ‛Leaf’
-    A data constructor of that name is in scope; did you mean -XDataKinds?
+    A data constructor of that name is in scope; did you mean DataKinds?
 
 readFail001.hs:38:41:
     Not in scope: type constructor or class ‛Leaf’
-    A data constructor of that name is in scope; did you mean -XDataKinds?
+    A data constructor of that name is in scope; did you mean DataKinds?
 
 readFail001.hs:87:11: Not in scope: ‛x’
 

testsuite/tests/parser/should_fail/readFail035.stderr

 
 readFail035.hs:6:1:
-    ‛Foo’ has no constructors (-XEmptyDataDecls permits this)
+    ‛Foo’ has no constructors (EmptyDataDecls permits this)
     In the data declaration for ‛Foo’

testsuite/tests/parser/should_fail/readFail036.stderr

 
 readFail036.hs:4:16:
     Illegal kind signature: ‛*’
-      Perhaps you intended to use -XKindSignatures
+      Perhaps you intended to use KindSignatures
     In the data type declaration for ‛Foo’

testsuite/tests/parser/should_fail/readFail037.stderr

 
 readFail037.hs:4:1:
     Too many parameters for class ‛Foo’
-    (Use -XMultiParamTypeClasses to allow multi-parameter classes)
+    (Use MultiParamTypeClasses to allow multi-parameter classes)
     In the class declaration for ‛Foo’

testsuite/tests/parser/should_fail/readFail038.stderr

 
 readFail038.hs:6:7:
     Unexpected parallel statement in a list comprehension
-    Use -XParallelListComp
+    Use ParallelListComp

testsuite/tests/parser/should_fail/readFail039.stderr

@@ -2,5 +2,5 @@
 readFail039.hs:8:14:
     Can't make a derived instance of ‛C Foo’:
       ‛C’ is not a derivable class
-      Try -XGeneralizedNewtypeDeriving for GHC's newtype-deriving extension
+      Try GeneralizedNewtypeDeriving for GHC's newtype-deriving extension
     In the newtype declaration for ‛Foo’

testsuite/tests/parser/should_fail/readFail041.stderr

 
 readFail041.hs:6:1:
     Fundeps in class ‛Foo’
-    (Use -XFunctionalDependencies to allow fundeps)
+    (Use FunctionalDependencies to allow fundeps)
     In the class declaration for ‛Foo’

testsuite/tests/parser/should_fail/readFail042.stderr

 
 readFail042.hs:10:9:
     Unexpected transform statement in a list comprehension
-    Use -XTransformListComp
+    Use TransformListComp
 
 readFail042.hs:11:9:
     Unexpected transform statement in a list comprehension
-    Use -XTransformListComp
+    Use TransformListComp
 
 readFail042.hs:11:23: Not in scope: ‛by’
 

testsuite/tests/parser/should_fail/readFail043.stderr

 
 readFail043.hs:10:9:
     Unexpected transform statement in a list comprehension
-    Use -XTransformListComp
+    Use TransformListComp
 
 readFail043.hs:10:20: Not in scope: ‛by’
 
@@ -11,7 +11,7 @@ readFail043.hs:10:25: Not in scope: ‛using’
 
 readFail043.hs:11:9:
     Unexpected transform statement in a list comprehension
-    Use -XTransformListComp
+    Use TransformListComp
 
 readFail043.hs:11:20: Not in scope: ‛by’
 
@@ -21,6 +21,6 @@ readFail043.hs:11:25: Not in scope: ‛using’
 
 readFail043.hs:12:9:
     Unexpected transform statement in a list comprehension
-    Use -XTransformListComp
+    Use TransformListComp
 
 readFail043.hs:12:20: Not in scope: ‛using’

testsuite/tests/parser/should_fail/readFailTraditionalRecords1.stderr

 
 readFailTraditionalRecords1.hs:6:16:
-    Illegal record syntax (use -XTraditionalRecordSyntax): {i :: Int}
+    Illegal record syntax (use TraditionalRecordSyntax): {i :: Int}

testsuite/tests/parser/should_fail/readFailTraditionalRecords2.stderr

 
 readFailTraditionalRecords2.hs:6:4:
-    Illegal record syntax (use -XTraditionalRecordSyntax): Foo {i = j}
+    Illegal record syntax (use TraditionalRecordSyntax): Foo {i = j}

testsuite/tests/parser/should_fail/readFailTraditionalRecords3.stderr

 
 readFailTraditionalRecords3.hs:6:7:
-    Illegal record syntax (use -XTraditionalRecordSyntax): x {i = 3}
+    Illegal record syntax (use TraditionalRecordSyntax): x {i = 3}

testsuite/tests/polykinds/T7151.stderr

 
 T7151.hs:3:12:
     Illegal type: ‛'[Int, String]’
-      Perhaps you intended to use -XDataKinds
+      Perhaps you intended to use DataKinds

testsuite/tests/polykinds/T7433.stderr

 
 T7433.hs:2:10:
     Data constructor ‛Z’ cannot be used here
-      (Perhaps you intended to use -XDataKinds)
+      (Perhaps you intended to use DataKinds)
     In the type ‛Z’
     In the type declaration for ‛T’

testsuite/tests/rename/should_compile/rn049.stderr

 
-rn049.hs:12:6:
-    Warning: accepting non-standard pattern guards (use -XPatternGuards to suppress this message)
-		 x <- 1 * 2 + 3 * 4
+rn049.hs:12:6: Warning:
+    accepting non-standard pattern guards (use PatternGuards to suppress this message)
+        x <- 1 * 2 + 3 * 4

testsuite/tests/rename/should_fail/T3265.stderr

 
 T3265.hs:7:8:
     Illegal declaration of a type or class operator ‛:+:’
-      Use -XTypeOperators to declare operators in type and declarations
+      Use TypeOperators to declare operators in type and declarations
 
 T3265.hs:9:9:
     Illegal declaration of a type or class operator ‛:*:’
-      Use -XTypeOperators to declare operators in type and declarations
+      Use TypeOperators to declare operators in type and declarations

testsuite/tests/rename/should_fail/rnfail052.stderr

 
 rnfail052.hs:6:14:
     Illegal symbol '.' in type
-    Perhaps you intended -XRankNTypes or similar flag
-    to enable explicit-forall syntax: forall <tvs>. <type>
+    Perhaps you intended to use RankNTypes or a similar language
+    extension to enable explicit-forall syntax: forall <tvs>. <type>

testsuite/tests/rename/should_fail/rnfail053.stderr

 
 rnfail053.hs:5:10:
     Not a data constructor: ‛forall’
-    Perhaps you intended to use -XExistentialQuantification
+    Perhaps you intended to use ExistentialQuantification

testsuite/tests/rename/should_fail/rnfail056.stderr

 
-rnfail056.hs:6:7: Illegal tuple section: use -XTupleSections
+rnfail056.hs:6:7: Illegal tuple section: use TupleSections
 
-rnfail056.hs:8:7: Illegal tuple section: use -XTupleSections
+rnfail056.hs:8:7: Illegal tuple section: use TupleSections

testsuite/tests/safeHaskell/ghci/p16.stderr

@@ -5,7 +5,7 @@
 <interactive>:16:29:
     Can't make a derived instance of ‛Op T2’:
       ‛Op’ is not a derivable class
-      Try -XGeneralizedNewtypeDeriving for GHC's newtype-deriving extension
+      Try GeneralizedNewtypeDeriving for GHC's newtype-deriving extension
     In the newtype declaration for ‛T2’
 
 <interactive>:19:9:

testsuite/tests/safeHaskell/safeInfered/Mixed01.stderr

 
 Mixed01.hs:5:1:
     safe import can't be used as Safe Haskell isn't on!
-    please enable Safe Haskell through either-XSafe, -XTruswrothy or -XUnsafe
+    please enable Safe Haskell through eitherSafe, Trustwrothy or Unsafe

testsuite/tests/safeHaskell/safeLanguage/SafeLang12.stderr

 
-SafeLang12.hs:2:14:
-    Warning: -XTemplateHaskell is not allowed in Safe Haskell; ignoring -XTemplateHaskell
+SafeLang12.hs:2:14: Warning:
+    -XTemplateHaskell is not allowed in Safe Haskell; ignoring -XTemplateHaskell
 
-SafeLang12_B.hs:2:14:
-    Warning: -XTemplateHaskell is not allowed in Safe Haskell; ignoring -XTemplateHaskell
+SafeLang12_B.hs:2:14: Warning:
+    -XTemplateHaskell is not allowed in Safe Haskell; ignoring -XTemplateHaskell
 [1 of 3] Compiling SafeLang12_B     ( SafeLang12_B.hs, SafeLang12_B.o )
 
 SafeLang12_B.hs:14:67:
     Syntax error on ''Class
-    Perhaps you intended to use -XTemplateHaskell
+    Perhaps you intended to use TemplateHaskell

testsuite/tests/th/TH_Roles1.stderr

 
 TH_Roles1.hs:7:4:
     Illegal role annotation
-    Perhaps you intended to use -XRoleAnnotations
+    Perhaps you intended to use RoleAnnotations
     In the data type declaration for ‛T’

testsuite/tests/typecheck/should_fail/T2538.stderr

 
 T2538.hs:6:6:
     Illegal polymorphic or qualified type: Eq a => a -> a
-    Perhaps you intended to use -XRankNTypes or -XRank2Types
+    Perhaps you intended to use RankNTypes or Rank2Types
     In the type signature for ‛f’: f :: (Eq a => a -> a) -> Int
 
 T2538.hs:9:6:
     Illegal polymorphic or qualified type: Eq a => a -> a
-    Perhaps you intended to use -XImpredicativeTypes
+    Perhaps you intended to use ImpredicativeTypes
     In the type signature for ‛g’: g :: [Eq a => a -> a] -> Int
 
 T2538.hs:12:6:

testsuite/tests/typecheck/should_fail/T3155.stderr

 
 T3155.hs:13:18:
     Illegal symbol '.' in type
-    Perhaps you intended -XRankNTypes or similar flag
-    to enable explicit-forall syntax: forall <tvs>. <type>
+    Perhaps you intended to use RankNTypes or a similar language
+    extension to enable explicit-forall syntax: forall <tvs>. <type>

testsuite/tests/typecheck/should_fail/T5051.stderr

@@ -5,7 +5,7 @@ T5051.hs:11:11:
       instance Eq a => Eq [a] -- Defined in ‛GHC.Classes’
       instance [overlap ok] Eq [T] -- Defined at T5051.hs:8:10
     (The choice depends on the instantiation of ‛a’
-     To pick the first instance above, use -XIncoherentInstances
+     To pick the first instance above, use IncoherentInstances
      when compiling the other instance declarations)
     In the expression: x >= x
     In an equation for ‛foo’: foo x = x >= x

testsuite/tests/typecheck/should_fail/T5095.stderr

@@ -60,7 +60,7 @@ T5095.hs:9:11:
         -- Defined in ‛Control.Applicative’
       instance Eq Integer -- Defined in ‛integer-gmp:GHC.Integer.Type’
     (The choice depends on the instantiation of ‛a’
-     To pick the first instance above, use -XIncoherentInstances
+     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

testsuite/tests/typecheck/should_fail/T5957.stderr

 
 T5957.hs:3:9:
     Illegal polymorphic or qualified type: Show a => a -> String
-    Perhaps you intended to use -XRankNTypes or -XRank2Types
+    Perhaps you intended to use RankNTypes or Rank2Types
     In the type signature for ‛flex’:
       flex :: Int -> Show a => a -> String

testsuite/tests/typecheck/should_fail/T7220.stderr

@@ -2,7 +2,7 @@
 T7220.hs:24:6:
     Cannot instantiate unification variable ‛b0’
     with a type involving foralls: forall b. (C A b, TF b ~ Y) => b
-      Perhaps you want -XImpredicativeTypes
+      Perhaps you want ImpredicativeTypes
     In the expression: f :: (forall b. (C A b, TF b ~ Y) => b) -> X
     In the expression: (f :: (forall b. (C A b, TF b ~ Y) => b) -> X) u
     In an equation for ‛v’:

testsuite/tests/typecheck/should_fail/T7809.stderr

 
 T7809.hs:8:8:
     Illegal polymorphic or qualified type: PolyId
-    Perhaps you intended to use -XImpredicativeTypes
+    Perhaps you intended to use ImpredicativeTypes
     In the type signature for ‛foo’: foo :: F PolyId

testsuite/tests/typecheck/should_fail/TcNoNullaryTC.stderr

 
 TcNoNullaryTC.hs:3:1:
     No parameters for class ‛A’
-    (Use -XNullaryTypeClasses to allow no-parameter classes)
+    (Use NullaryTypeClasses to allow no-parameter classes)
     In the class declaration for ‛A’

testsuite/tests/typecheck/should_fail/fd-loop.stderr

@@ -2,11 +2,11 @@
 fd-loop.hs:12:10:
     Variable ‛b’ occurs more often than in the instance head
       in the constraint: C a b