summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--compiler/GHC/Builtin/Names.hs36
-rw-r--r--compiler/GHC/Builtin/PrimOps.hs2
-rw-r--r--compiler/GHC/Builtin/Types.hs2
-rw-r--r--compiler/GHC/Builtin/Types/Prim.hs14
-rw-r--r--compiler/GHC/Core/Lint.hs14
-rw-r--r--compiler/GHC/Core/Opt/Simplify.hs8
-rw-r--r--compiler/GHC/Core/Opt/Specialise.hs2
-rw-r--r--compiler/GHC/Core/Opt/WorkWrap/Utils.hs2
-rw-r--r--compiler/GHC/Core/Type.hs8
-rw-r--r--compiler/GHC/Core/Utils.hs2
-rw-r--r--compiler/GHC/Driver/Flags.hs4
-rw-r--r--compiler/GHC/HsToCore/Errors/Ppr.hs2
-rw-r--r--compiler/GHC/HsToCore/Expr.hs2
-rw-r--r--compiler/GHC/HsToCore/Utils.hs2
-rw-r--r--compiler/GHC/Tc/Gen/Head.hs2
-rw-r--r--compiler/GHC/Types/Id/Make.hs2
-rw-r--r--compiler/GHC/Types/Literal.hs2
-rw-r--r--compiler/GHC/Utils/Ppr.hs2
-rw-r--r--docs/users_guide/exts/linear_types.rst1
-rw-r--r--docs/users_guide/using-warnings.rst4
-rw-r--r--libraries/base/Data/Dynamic.hs8
-rw-r--r--testsuite/tests/codeGen/should_compile/T13233.hs12
-rw-r--r--testsuite/tests/linear/should_fail/LinearPolyType.stderr4
-rw-r--r--testsuite/tests/printer/RdrNames.hs6
-rw-r--r--testsuite/tests/typecheck/should_compile/T12427a.hs2
-rw-r--r--testsuite/tests/typecheck/should_compile/holes.stderr4
-rw-r--r--testsuite/tests/typecheck/should_compile/holes3.stderr4
27 files changed, 44 insertions, 109 deletions
diff --git a/compiler/GHC/Builtin/Names.hs b/compiler/GHC/Builtin/Names.hs
index 80d5e4f48f..ddb7074690 100644
--- a/compiler/GHC/Builtin/Names.hs
+++ b/compiler/GHC/Builtin/Names.hs
@@ -345,10 +345,9 @@ basicKnownKeyNames
-- Others
otherwiseIdName, inlineIdName,
- eqStringName, assertName, breakpointName, breakpointCondName,
- opaqueTyConName,
+ eqStringName, assertName,
assertErrorName, traceName,
- printName, fstName, sndName,
+ printName,
dollarName,
-- ghc-bignum
@@ -1136,11 +1135,10 @@ groupWithName, considerAccessibleName :: Name
groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
considerAccessibleName = varQual gHC_EXTS (fsLit "considerAccessible") considerAccessibleIdKey
--- Random PrelBase functions
+-- Random GHC.Base functions
fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
mapName, appendName, assertName,
- breakpointName, breakpointCondName,
- opaqueTyConName, dollarName :: Name
+ dollarName :: Name
dollarName = varQual gHC_BASE (fsLit "$") dollarIdKey
otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
@@ -1149,16 +1147,8 @@ augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
mapName = varQual gHC_BASE (fsLit "map") mapIdKey
appendName = varQual gHC_BASE (fsLit "++") appendIdKey
assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
-breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
-breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
-opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
fromStringName = varQual dATA_STRING (fsLit "fromString") fromStringClassOpKey
--- PrelTup
-fstName, sndName :: Name
-fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
-sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
-
-- Module GHC.Num
numClassName, fromIntegerName, minusName, negateName :: Name
numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
@@ -1363,7 +1353,7 @@ fromIntegralName = varQual gHC_REAL (fsLit "fromIntegral")fromIntegralIdKey
realToFracName = varQual gHC_REAL (fsLit "realToFrac") realToFracIdKey
mkRationalBase2Name = varQual gHC_REAL (fsLit "mkRationalBase2") mkRationalBase2IdKey
mkRationalBase10Name = varQual gHC_REAL (fsLit "mkRationalBase10") mkRationalBase10IdKey
--- PrelFloat classes
+-- GHC.Float classes
floatingClassName, realFloatClassName :: Name
floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
@@ -1956,14 +1946,6 @@ pluginTyConKey, frontendPluginTyConKey :: Unique
pluginTyConKey = mkPreludeTyConUnique 102
frontendPluginTyConKey = mkPreludeTyConUnique 103
-unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
- opaqueTyConKey :: Unique
-unknownTyConKey = mkPreludeTyConUnique 129
-unknown1TyConKey = mkPreludeTyConUnique 130
-unknown2TyConKey = mkPreludeTyConUnique 131
-unknown3TyConKey = mkPreludeTyConUnique 132
-opaqueTyConKey = mkPreludeTyConUnique 133
-
-- Generics (Unique keys)
v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
@@ -2343,7 +2325,7 @@ raiseDivZeroIdKey = mkPreludeMiscIdUnique 29
concatIdKey, filterIdKey, zipIdKey,
bindIOIdKey, returnIOIdKey, newStablePtrIdKey,
printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
- fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey :: Unique
+ otherwiseIdKey, assertIdKey :: Unique
concatIdKey = mkPreludeMiscIdUnique 31
filterIdKey = mkPreludeMiscIdUnique 32
zipIdKey = mkPreludeMiscIdUnique 33
@@ -2354,8 +2336,6 @@ printIdKey = mkPreludeMiscIdUnique 37
failIOIdKey = mkPreludeMiscIdUnique 38
nullAddrIdKey = mkPreludeMiscIdUnique 39
voidArgIdKey = mkPreludeMiscIdUnique 40
-fstIdKey = mkPreludeMiscIdUnique 41
-sndIdKey = mkPreludeMiscIdUnique 42
otherwiseIdKey = mkPreludeMiscIdUnique 43
assertIdKey = mkPreludeMiscIdUnique 44
@@ -2377,10 +2357,6 @@ runRWKey = mkPreludeMiscIdUnique 107
traceKey :: Unique
traceKey = mkPreludeMiscIdUnique 108
-breakpointIdKey, breakpointCondIdKey :: Unique
-breakpointIdKey = mkPreludeMiscIdUnique 110
-breakpointCondIdKey = mkPreludeMiscIdUnique 111
-
inlineIdKey, noinlineIdKey :: Unique
inlineIdKey = mkPreludeMiscIdUnique 120
-- see below
diff --git a/compiler/GHC/Builtin/PrimOps.hs b/compiler/GHC/Builtin/PrimOps.hs
index 45e570d34c..1fa8b02bb7 100644
--- a/compiler/GHC/Builtin/PrimOps.hs
+++ b/compiler/GHC/Builtin/PrimOps.hs
@@ -636,7 +636,7 @@ have:
plusInt# a b = P.plusInt# a b
The Id for the wrapper of a primop can be found using
-'GHC.Builtin.PrimOp.primOpWrapperId'. However, GHCi does not use this mechanism
+'GHC.Builtin.PrimOps.primOpWrapperId'. However, GHCi does not use this mechanism
to link primops; it rather does a rather hacky symbol lookup (see
GHC.ByteCode.Linker.primopToCLabel). TODO: Perhaps this should be changed?
diff --git a/compiler/GHC/Builtin/Types.hs b/compiler/GHC/Builtin/Types.hs
index 880aec299c..3339842471 100644
--- a/compiler/GHC/Builtin/Types.hs
+++ b/compiler/GHC/Builtin/Types.hs
@@ -1135,7 +1135,7 @@ mk_tuple Unboxed arity = (tycon, tuple_con)
UnboxedTuple flavour
-- See Note [Unboxed tuple RuntimeRep vars] in GHC.Core.TyCon
- -- Kind: forall (k1:RuntimeRep) (k2:RuntimeRep). TYPE k1 -> TYPE k2 -> #
+ -- Kind: forall (k1:RuntimeRep) (k2:RuntimeRep). TYPE k1 -> TYPE k2 -> TYPE (TupleRep [k1, k2])
tc_binders = mkTemplateTyConBinders (replicate arity runtimeRepTy)
(\ks -> map tYPE ks)
diff --git a/compiler/GHC/Builtin/Types/Prim.hs b/compiler/GHC/Builtin/Types/Prim.hs
index 1125655398..c339125e9a 100644
--- a/compiler/GHC/Builtin/Types/Prim.hs
+++ b/compiler/GHC/Builtin/Types/Prim.hs
@@ -785,7 +785,7 @@ error messages, and (~R#) is rendered as Coercible.
Let's take these one at a time:
--------------------------
- (~#) :: forall k1 k2. k1 -> k2 -> #
+ (~#) :: forall k1 k2. k1 -> k2 -> TYPE (TupleRep '[])
--------------------------
This is The Type Of Equality in GHC. It classifies nominal coercions.
This type is used in the solver for recording equality constraints.
@@ -865,7 +865,7 @@ They are not defined within GHC at all.
--------------------------
- (~R#) :: forall k1 k2. k1 -> k2 -> #
+ (~R#) :: forall k1 k2. k1 -> k2 -> TYPE (TupleRep '[])
--------------------------
The is the representational analogue of ~#. This is the type of representational
equalities that the solver works on. All wanted constraints of this type are
@@ -900,7 +900,7 @@ within GHC at all.
--------------------------
- (~P#) :: forall k1 k2. k1 -> k2 -> #
+ (~P#) :: forall k1 k2. k1 -> k2 -> TYPE (TupleRep '[])
--------------------------
This is the phantom analogue of ~# and it is barely used at all.
(The solver has no idea about this one.) Here is the motivation:
@@ -960,7 +960,7 @@ mkProxyPrimTy k ty = TyConApp proxyPrimTyCon [k, ty]
proxyPrimTyCon :: TyCon
proxyPrimTyCon = mkPrimTyCon proxyPrimTyConName binders res_kind [Nominal,Phantom]
where
- -- Kind: forall k. k -> TYPE (Tuple '[])
+ -- Kind: forall k. k -> TYPE (TupleRep '[])
binders = mkTemplateTyConBinders [liftedTypeKind] id
res_kind = unboxedTupleKind []
@@ -976,7 +976,7 @@ eqPrimTyCon :: TyCon -- The representation type for equality predicates
-- See Note [The equality types story]
eqPrimTyCon = mkPrimTyCon eqPrimTyConName binders res_kind roles
where
- -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])
+ -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (TupleRep '[])
binders = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id
res_kind = unboxedTupleKind []
roles = [Nominal, Nominal, Nominal, Nominal]
@@ -987,7 +987,7 @@ eqPrimTyCon = mkPrimTyCon eqPrimTyConName binders res_kind roles
eqReprPrimTyCon :: TyCon -- See Note [The equality types story]
eqReprPrimTyCon = mkPrimTyCon eqReprPrimTyConName binders res_kind roles
where
- -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])
+ -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (TupleRep '[])
binders = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id
res_kind = unboxedTupleKind []
roles = [Nominal, Nominal, Representational, Representational]
@@ -998,7 +998,7 @@ eqReprPrimTyCon = mkPrimTyCon eqReprPrimTyConName binders res_kind roles
eqPhantPrimTyCon :: TyCon
eqPhantPrimTyCon = mkPrimTyCon eqPhantPrimTyConName binders res_kind roles
where
- -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])
+ -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (TupleRep '[])
binders = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id
res_kind = unboxedTupleKind []
roles = [Nominal, Nominal, Phantom, Phantom]
diff --git a/compiler/GHC/Core/Lint.hs b/compiler/GHC/Core/Lint.hs
index 43935d1efe..fa780fb320 100644
--- a/compiler/GHC/Core/Lint.hs
+++ b/compiler/GHC/Core/Lint.hs
@@ -161,16 +161,6 @@ We check for
If we have done specialisation the we check that there are
(a) No top-level bindings of primitive (unboxed type)
-Outstanding issues:
-
- -- Things are *not* OK if:
- --
- -- * Unsaturated type app before specialisation has been done;
- --
- -- * Oversaturated type app after specialisation (eta reduction
- -- may well be happening...);
-
-
Note [Linting function types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
As described in Note [Representation of function types], all saturated
@@ -1746,11 +1736,11 @@ lintTySynFamApp report_unsat ty tc tys
; return (TyConApp tc tys') }
-----------------
--- Confirms that a type is really *, #, Constraint etc
+-- Confirms that a type is really TYPE r or Constraint
checkValueType :: LintedType -> SDoc -> LintM ()
checkValueType ty doc
= lintL (classifiesTypeWithValues kind)
- (text "Non-*-like kind when *-like expected:" <+> ppr kind $$
+ (text "Non-Type-like kind when Type-like expected:" <+> ppr kind $$
text "when checking" <+> doc)
where
kind = typeKind ty
diff --git a/compiler/GHC/Core/Opt/Simplify.hs b/compiler/GHC/Core/Opt/Simplify.hs
index cb5264f4ba..d1ca3e3f9c 100644
--- a/compiler/GHC/Core/Opt/Simplify.hs
+++ b/compiler/GHC/Core/Opt/Simplify.hs
@@ -1722,8 +1722,8 @@ simplRecE env pairs body cont
In `simplNonRecE`, the call to `isStrictId` will fail if the binder
has a representation-polymorphic type, of kind (TYPE r). So we are careful to
call `isStrictId` on the OutId, not the InId, in case we have
- ((\(r::RuntimeRep) \(x::Type r). blah) Lifted arg)
-That will lead to `simplNonRecE env (x::Type r) arg`, and we can't tell
+ ((\(r::RuntimeRep) \(x::TYPE r). blah) Lifted arg)
+That will lead to `simplNonRecE env (x::TYPE r) arg`, and we can't tell
if x is lifted or unlifted from that.
We only get such redexes from the compulsory inlining of a wired-in,
@@ -3166,11 +3166,11 @@ even though it'll be over-ridden in every case alternative with a more
informative unfolding. Why? Because suppose a later, less clever, pass
simply replaces all occurrences of the case binder with the binder itself;
then Lint may complain about the let/app invariant. Example
- case e of b { DEFAULT -> let v = reallyUnsafePtrEq# b y in ....
+ case e of b { DEFAULT -> let v = reallyUnsafePtrEquality# b y in ....
; K -> blah }
The let/app invariant requires that y is evaluated in the call to
-reallyUnsafePtrEq#, which it is. But we still want that to be true if we
+reallyUnsafePtrEquality#, which it is. But we still want that to be true if we
propagate binders to occurrences.
This showed up in #13027.
diff --git a/compiler/GHC/Core/Opt/Specialise.hs b/compiler/GHC/Core/Opt/Specialise.hs
index 88f5d408de..20f78f94bc 100644
--- a/compiler/GHC/Core/Opt/Specialise.hs
+++ b/compiler/GHC/Core/Opt/Specialise.hs
@@ -1762,7 +1762,7 @@ Wrinkles
unfolding of the specialised function: this is the last field in specHeader's
big result tuple.
- The right thing to do is to produce a RubbishLit; it should rapidly
+ The right thing to do is to produce a LitRubbish; it should rapidly
disappear. Rather like GHC.Core.Opt.WorkWrap.Utils.mk_absent_let.
Note [Zap occ info in rule binders]
diff --git a/compiler/GHC/Core/Opt/WorkWrap/Utils.hs b/compiler/GHC/Core/Opt/WorkWrap/Utils.hs
index 3eb4b31c52..61de975bf0 100644
--- a/compiler/GHC/Core/Opt/WorkWrap/Utils.hs
+++ b/compiler/GHC/Core/Opt/WorkWrap/Utils.hs
@@ -1213,7 +1213,7 @@ Needless to say, there are some wrinkles:
cardinality 'C_10' (say, the arg to a bottoming function) where we could've
used an error-thunk, but that's a small price to pay for simplicity.
- 3. We can only emit a RubbishLit if the arg's type @arg_ty@ is mono-rep, e.g.
+ 3. We can only emit a LitRubbish if the arg's type @arg_ty@ is mono-rep, e.g.
of the form @TYPE rep@ where @rep@ is not (and doesn't contain) a variable.
Why? Because if we don't know its representation (e.g. size in memory,
register class), we don't know what or how much rubbish to emit in codegen.
diff --git a/compiler/GHC/Core/Type.hs b/compiler/GHC/Core/Type.hs
index 8a5dc691ec..6b88262ff5 100644
--- a/compiler/GHC/Core/Type.hs
+++ b/compiler/GHC/Core/Type.hs
@@ -3301,14 +3301,8 @@ isKindLevPoly k = assertPpr (isLiftedTypeKind k || _is_type) (ppr k) $
_is_type = classifiesTypeWithValues k
-----------------------------------------
--- Subkinding
--- The tc variants are used during type-checking, where ConstraintKind
--- is distinct from all other kinds
--- After type-checking (in core), Constraint and liftedTypeKind are
--- indistinguishable
-
-- | Does this classify a type allowed to have values? Responds True to things
--- like *, #, TYPE Lifted, TYPE v, Constraint.
+-- like *, TYPE Lifted, TYPE IntRep, TYPE v, Constraint.
classifiesTypeWithValues :: Kind -> Bool
-- ^ True of any sub-kind of OpenTypeKind
classifiesTypeWithValues k = isJust (kindRep_maybe k)
diff --git a/compiler/GHC/Core/Utils.hs b/compiler/GHC/Core/Utils.hs
index 969ede72bc..a9a8769259 100644
--- a/compiler/GHC/Core/Utils.hs
+++ b/compiler/GHC/Core/Utils.hs
@@ -1786,7 +1786,7 @@ points do the job nicely.
Note [Primops with lifted arguments]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Is this ok-for-speculation (see #13027)?
- reallyUnsafePtrEq# a b
+ reallyUnsafePtrEquality# a b
Well, yes. The primop accepts lifted arguments and does not
evaluate them. Indeed, in general primops are, well, primitive
and do not perform evaluation.
diff --git a/compiler/GHC/Driver/Flags.hs b/compiler/GHC/Driver/Flags.hs
index dc9c19a52e..9643579ce8 100644
--- a/compiler/GHC/Driver/Flags.hs
+++ b/compiler/GHC/Driver/Flags.hs
@@ -522,13 +522,13 @@ data WarningFlag =
| Opt_WarnImplicitKindVars -- Since 8.6
| Opt_WarnSpaceAfterBang
| Opt_WarnMissingDerivingStrategies -- Since 8.8
- | Opt_WarnPrepositiveQualifiedModule -- Since TBD
+ | Opt_WarnPrepositiveQualifiedModule -- Since 8.10
| Opt_WarnUnusedPackages -- Since 8.10
| Opt_WarnInferredSafeImports -- Since 8.10
| Opt_WarnMissingSafeHaskellMode -- Since 8.10
| Opt_WarnCompatUnqualifiedImports -- Since 8.10
| Opt_WarnDerivingDefaults
- | Opt_WarnInvalidHaddock -- Since 8.12
+ | Opt_WarnInvalidHaddock -- Since 9.0
| Opt_WarnOperatorWhitespaceExtConflict -- Since 9.2
| Opt_WarnOperatorWhitespace -- Since 9.2
| Opt_WarnAmbiguousFields -- Since 9.2
diff --git a/compiler/GHC/HsToCore/Errors/Ppr.hs b/compiler/GHC/HsToCore/Errors/Ppr.hs
index 0d8dbcc9a9..b0d2b16409 100644
--- a/compiler/GHC/HsToCore/Errors/Ppr.hs
+++ b/compiler/GHC/HsToCore/Errors/Ppr.hs
@@ -88,7 +88,7 @@ instance Diagnostic DsMessage where
-> mkSimpleDecorated $
text "Ignoring useless SPECIALISE pragma for NOINLINE function:" <+> quotes (ppr poly_id)
DsMultiplicityCoercionsNotSupported
- -> mkSimpleDecorated $ text "Multiplicity coercions are currently not supported"
+ -> mkSimpleDecorated $ text "Multiplicity coercions are currently not supported (see GHC #19517)"
DsOrphanRule rule
-> mkSimpleDecorated $ text "Orphan rule:" <+> ppr rule
DsRuleLhsTooComplicated orig_lhs lhs2
diff --git a/compiler/GHC/HsToCore/Expr.hs b/compiler/GHC/HsToCore/Expr.hs
index 6bf900da89..b79f5862b9 100644
--- a/compiler/GHC/HsToCore/Expr.hs
+++ b/compiler/GHC/HsToCore/Expr.hs
@@ -1130,7 +1130,7 @@ is what dsHsWrapped does. Because we might have an HsVar without a
wrapper, we check in dsHsVar as well. typecheck/should_fail/T17021
triggers this case.
-Note that if `f :: forall r (a :: Type r). blah`, then
+Note that if `f :: forall r (a :: TYPE r). blah`, then
const True f
is absolutely fine. Here `f` is a function, represented by a
pointer, and we can pass it to `const` (or anything else). (See
diff --git a/compiler/GHC/HsToCore/Utils.hs b/compiler/GHC/HsToCore/Utils.hs
index 020775c91c..b68cf061a0 100644
--- a/compiler/GHC/HsToCore/Utils.hs
+++ b/compiler/GHC/HsToCore/Utils.hs
@@ -529,7 +529,7 @@ There are a few subtleties in the desugaring of `seq`:
3. (as described in #2409)
- The isLocalId ensures that we don't turn
+ The isInternalName ensures that we don't turn
True `seq` e
into
case True of True { ... }
diff --git a/compiler/GHC/Tc/Gen/Head.hs b/compiler/GHC/Tc/Gen/Head.hs
index 4164bd26b0..f71b424ffa 100644
--- a/compiler/GHC/Tc/Gen/Head.hs
+++ b/compiler/GHC/Tc/Gen/Head.hs
@@ -809,7 +809,7 @@ mostly in tcInferDataCon:
2. We are going to return a ConLikeTc, thus:
XExpr (ConLikeTc K [r,a] [Scaled p a])
- :: forall (r :: RuntimeRep) (a :: Type r). a %p -> T r a
+ :: forall (r :: RuntimeRep) (a :: TYPE r). a %p -> T r a
where 'p' is a fresh multiplicity unification variable.
To get the returned ConLikeTc, we allocate a fresh multiplicity
diff --git a/compiler/GHC/Types/Id/Make.hs b/compiler/GHC/Types/Id/Make.hs
index 581e8a83dd..4c2f028360 100644
--- a/compiler/GHC/Types/Id/Make.hs
+++ b/compiler/GHC/Types/Id/Make.hs
@@ -1542,7 +1542,7 @@ does not linger for long.
-- See Note [Left and right sections] in GHC.Rename.Expr
-- See Note [Wired-in Ids for rebindable syntax]
--- leftSection :: forall r1 r2 n (a:Type r1) (b:TYPE r2).
+-- leftSection :: forall r1 r2 n (a:TYPE r1) (b:TYPE r2).
-- (a %n-> b) -> a %n-> b
-- leftSection f x = f x
-- Important that it is eta-expanded, so that (leftSection undefined `seq` ())
diff --git a/compiler/GHC/Types/Literal.hs b/compiler/GHC/Types/Literal.hs
index 6160a450bb..9d079f8a85 100644
--- a/compiler/GHC/Types/Literal.hs
+++ b/compiler/GHC/Types/Literal.hs
@@ -1007,7 +1007,7 @@ c) Literal is in Ord, because (and only because) we use Ord on AltCon when
Moreover, rubbish literals should not appear in patterns anyway.
d) Why not lower LitRubbish in CoreToStg? Because it enables us to use
- RubbishLit when unarising unboxed sums in the future, and it allows
+ LitRubbish when unarising unboxed sums in the future, and it allows
rubbish values of e.g. VecRep, for which we can't cough up dummy
values in STG.
diff --git a/compiler/GHC/Utils/Ppr.hs b/compiler/GHC/Utils/Ppr.hs
index e64c6e61f1..9b5b55658f 100644
--- a/compiler/GHC/Utils/Ppr.hs
+++ b/compiler/GHC/Utils/Ppr.hs
@@ -446,7 +446,7 @@ Relevant discussions:
* Phabricator: https://phabricator.haskell.org/D4465
* GHC Trac: https://gitlab.haskell.org/ghc/ghc/issues/14872
-There is a flag `-dword-hex-literals` that causes literals of
+There is a flag `-dhex-word-literals` that causes literals of
type `Word#` or `Word64#` to be displayed in hexadecimal instead
of decimal when dumping GHC core. It also affects the presentation
of these in GHC's error messages. Additionally, the hexadecimal
diff --git a/docs/users_guide/exts/linear_types.rst b/docs/users_guide/exts/linear_types.rst
index 8029d0ad2f..5ed710d1c5 100644
--- a/docs/users_guide/exts/linear_types.rst
+++ b/docs/users_guide/exts/linear_types.rst
@@ -111,6 +111,7 @@ is no restriction on ``x``.
It is also possible to define a multiplicity-polymorphic field:
::
+
data T3 a m where
MkT3 :: a %m -> T3 a m
diff --git a/docs/users_guide/using-warnings.rst b/docs/users_guide/using-warnings.rst
index 840c66eef6..108928f210 100644
--- a/docs/users_guide/using-warnings.rst
+++ b/docs/users_guide/using-warnings.rst
@@ -844,11 +844,11 @@ of ``-W(no-)*``.
:since: 9.2
Template Haskell quotes referring to local variables bound outside
- of the quote are implicitly converted to use ``lift`. For example,
+ of the quote are implicitly converted to use ``lift``. For example,
``f x = [| reverse x |]`` becomes ``f x = [| reverse $(lift x) |])``.
This flag issues a warning for every such implicit addition of ``lift``.
This can be useful when debugging more complex staged programs,
- where an implicit `lift`` can accidentally conceal a variable
+ where an implicit ``lift`` can accidentally conceal a variable
used at a wrong stage.
.. ghc-flag:: -Wimplicit-prelude
diff --git a/libraries/base/Data/Dynamic.hs b/libraries/base/Data/Dynamic.hs
index 8345e16854..89aaaa33a6 100644
--- a/libraries/base/Data/Dynamic.hs
+++ b/libraries/base/Data/Dynamic.hs
@@ -84,14 +84,6 @@ instance Show Dynamic where
-- | @since 4.0.0.0
instance Exception Dynamic
- -- Use GHC's primitive 'Any' type to hold the dynamically typed value.
- --
- -- In GHC's new eval/apply execution model this type must not look
- -- like a data type. If it did, GHC would use the constructor convention
- -- when evaluating it, and this will go wrong if the object is really a
- -- function. Using Any forces GHC to use
- -- a fallback convention for evaluating it that works for all types.
-
-- | Converts an arbitrary value into an object of type 'Dynamic'.
--
-- The type of the object must be an instance of 'Typeable', which
diff --git a/testsuite/tests/codeGen/should_compile/T13233.hs b/testsuite/tests/codeGen/should_compile/T13233.hs
deleted file mode 100644
index bb79856d3b..0000000000
--- a/testsuite/tests/codeGen/should_compile/T13233.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeInType #-}
-{-# LANGUAGE UnboxedTuples #-}
-module Bug where
-
-import GHC.Exts (TYPE)
-
-class Foo (a :: TYPE rep) where
- bar :: forall (b :: TYPE rep2). (a -> a -> b) -> a -> a -> b
-
-baz :: forall (a :: TYPE rep). Foo a => a -> a -> (# a, a #)
-baz = bar (#,#)
diff --git a/testsuite/tests/linear/should_fail/LinearPolyType.stderr b/testsuite/tests/linear/should_fail/LinearPolyType.stderr
index 884b8991fb..c2d8b7d452 100644
--- a/testsuite/tests/linear/should_fail/LinearPolyType.stderr
+++ b/testsuite/tests/linear/should_fail/LinearPolyType.stderr
@@ -1,6 +1,6 @@
LinearPolyType.hs:15:1: error:
- Multiplicity coercions are currently not supported
+ Multiplicity coercions are currently not supported (see GHC #19517)
LinearPolyType.hs:15:1: error:
- Multiplicity coercions are currently not supported
+ Multiplicity coercions are currently not supported (see GHC #19517)
diff --git a/testsuite/tests/printer/RdrNames.hs b/testsuite/tests/printer/RdrNames.hs
index 5124bcccde..1bdf4f2fb3 100644
--- a/testsuite/tests/printer/RdrNames.hs
+++ b/testsuite/tests/printer/RdrNames.hs
@@ -97,12 +97,6 @@ lt = undefined
-- ---------------------------------------------------------------------
--- | '[:' ':]' {% ams (sLL $1 $> $ parrTyCon_RDR) [mo $1,mc $2] }
-
--- GHC source indicates this constuctor is only available in PrelPArr
--- ltp :: [::] a
--- ltp = undefined
-
-- ---------------------------------------------------------------------
-- | '(' '~#' ')' {% ams (sLL $1 $> $ getRdrName eqPrimTyCon)
diff --git a/testsuite/tests/typecheck/should_compile/T12427a.hs b/testsuite/tests/typecheck/should_compile/T12427a.hs
index 56c7513012..933939164c 100644
--- a/testsuite/tests/typecheck/should_compile/T12427a.hs
+++ b/testsuite/tests/typecheck/should_compile/T12427a.hs
@@ -36,6 +36,6 @@ h2 y = case y of T1 _ v -> v
-- Fails in 7.10 (head exploded)
-- Fails in 8.0.1 (ditto)
-- Succeeds in 8.2
--- Fails in 8.12 (simple subsumption)
+-- Fails in 9.0 (simple subsumption)
x3 :: (forall a. a->a) -> Int
T1 _ x3 = undefined
diff --git a/testsuite/tests/typecheck/should_compile/holes.stderr b/testsuite/tests/typecheck/should_compile/holes.stderr
index ddaae57d07..1e19fa85ba 100644
--- a/testsuite/tests/typecheck/should_compile/holes.stderr
+++ b/testsuite/tests/typecheck/should_compile/holes.stderr
@@ -166,13 +166,13 @@ holes.hs:11:15: warning: [-Wtyped-holes (in -Wdefault)]
quotRem :: forall a. Integral a => a -> a -> (a, a)
rem :: forall a. Integral a => a -> a -> a
zip :: forall a b. [a] -> [b] -> [(a, b)]
- fst :: forall a b. (a, b) -> a
- snd :: forall a b. (a, b) -> b
map :: forall a b. (a -> b) -> [a] -> [b]
realToFrac :: forall a b. (Real a, Fractional b) => a -> b
Left :: forall a b. a -> Either a b
Right :: forall a b. b -> Either a b
maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
+ fst :: forall a b. (a, b) -> a
+ snd :: forall a b. (a, b) -> b
const :: forall a b. a -> b -> a
scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
scanr :: forall a b. (a -> b -> b) -> b -> [a] -> [b]
diff --git a/testsuite/tests/typecheck/should_compile/holes3.stderr b/testsuite/tests/typecheck/should_compile/holes3.stderr
index 52cf8db18f..448f89009e 100644
--- a/testsuite/tests/typecheck/should_compile/holes3.stderr
+++ b/testsuite/tests/typecheck/should_compile/holes3.stderr
@@ -169,13 +169,13 @@ holes3.hs:11:15: error:
quotRem :: forall a. Integral a => a -> a -> (a, a)
rem :: forall a. Integral a => a -> a -> a
zip :: forall a b. [a] -> [b] -> [(a, b)]
- fst :: forall a b. (a, b) -> a
- snd :: forall a b. (a, b) -> b
map :: forall a b. (a -> b) -> [a] -> [b]
realToFrac :: forall a b. (Real a, Fractional b) => a -> b
Left :: forall a b. a -> Either a b
Right :: forall a b. b -> Either a b
maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
+ fst :: forall a b. (a, b) -> a
+ snd :: forall a b. (a, b) -> b
const :: forall a b. a -> b -> a
scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
scanr :: forall a b. (a -> b -> b) -> b -> [a] -> [b]