diff options
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] |