ghc-lib-parser 9.8.1.20231121 → 9.8.2.20240223

raw patch · 49 files changed

+760/−424 lines, 49 filesdep ~base

Dependency ranges changed: base

Files

• compiler/CodeGen.Platform.h +33/−0
• compiler/GHC/Cmm.hs +2/−3
• compiler/GHC/Core.hs +34/−21
• compiler/GHC/Core/Class.hs +45/−15
• compiler/GHC/Core/Coercion/Axiom.hs +27/−17
• compiler/GHC/Core/Opt/Simplify/Iteration.hs +85/−61
• compiler/GHC/Core/Opt/Simplify/Utils.hs +4/−3
• compiler/GHC/Core/Predicate.hs +8/−1
• compiler/GHC/Core/Subst.hs +2/−0
• compiler/GHC/Core/Unify.hs +5/−2
• compiler/GHC/Data/Bag.hs +7/−0
• compiler/GHC/Data/Graph/Directed.hs +34/−29
• compiler/GHC/Driver/DynFlags.hs +2/−1
• compiler/GHC/Driver/Flags.hs +6/−1
• compiler/GHC/Driver/Session.hs +125/−122
• compiler/GHC/Iface/Errors/Ppr.hs +4/−3
• compiler/GHC/Iface/Errors/Types.hs +2/−2
• compiler/GHC/Parser/Lexer.x +1/−1
• compiler/GHC/Platform/Wasm32.hs +2/−3
• compiler/GHC/Runtime/Heap/Layout.hs +3/−3
• compiler/GHC/Settings.hs +1/−0
• compiler/GHC/StgToCmm/Config.hs +3/−2
• compiler/GHC/Tc/Errors/Ppr.hs +63/−6
• compiler/GHC/Tc/Errors/Types.hs +44/−3
• compiler/GHC/Types/Avail.hs +1/−1
• compiler/GHC/Types/Error/Codes.hs +1/−0
• compiler/GHC/Types/Hint.hs +3/−0
• compiler/GHC/Types/Hint/Ppr.hs +3/−0
• compiler/GHC/Types/Name/Reader.hs +43/−14
• compiler/GHC/Unit/Finder/Types.hs +1/−1
• compiler/GHC/Unit/Module/ModIface.hs +1/−5
• compiler/GHC/Unit/State.hs +37/−11
• compiler/GHC/Utils/Outputable.hs +10/−0
• compiler/MachRegs.h +8/−1
• compiler/ghc.cabal +4/−4
• ghc-lib-parser.cabal +2/−2
• ghc-lib/stage0/compiler/build/GHC/Settings/Config.hs +1/−1
• ghc-lib/stage0/compiler/build/primop-docs.hs-incl +1/−1
• ghc-lib/stage0/lib/settings +3/−2
• ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs +4/−4
• ghc-lib/stage0/rts/build/include/GhclibDerivedConstants.h +7/−0
• ghc-lib/stage0/rts/build/include/ghcautoconf.h +75/−65
• ghc/ghc-bin.cabal +4/−4
• libraries/ghc-boot-th/ghc-boot-th.cabal +1/−1
• libraries/ghc-boot/ghc-boot.cabal +2/−2
• libraries/ghc-heap/ghc-heap.cabal +1/−1
• libraries/ghci/GHCi/Message.hs +1/−1
• libraries/ghci/ghci.cabal +3/−3
• libraries/template-haskell/template-haskell.cabal +1/−1

@@ -203,6 +203,39 @@ # define d29 61 # define d30 62 # define d31 63++# define q0 32+# define q1 33+# define q2 34+# define q3 35+# define q4 36+# define q5 37+# define q6 38+# define q7 39+# define q8 40+# define q9 41+# define q10 42+# define q11 43+# define q12 44+# define q13 45+# define q14 46+# define q15 47+# define q16 48+# define q17 49+# define q18 50+# define q19 51+# define q20 52+# define q21 53+# define q22 54+# define q23 55+# define q24 56+# define q25 57+# define q26 58+# define q27 59+# define q28 60+# define q29 61+# define q30 62+# define q31 63 #endif  # if defined(MACHREGS_darwin)

@@ -229,16 +229,15 @@         -- place to convey this information from the code generator to         -- where we build the static closures in         -- GHC.Cmm.Info.Build.doSRTs.-    } deriving Eq+    } deriving (Eq, Ord)  instance OutputableP Platform CmmInfoTable where     pdoc = pprInfoTable - data ProfilingInfo   = NoProfilingInfo   | ProfilingInfo ByteString ByteString -- closure_type, closure_desc-  deriving Eq+  deriving (Eq, Ord) ----------------------------------------------------------------------------- --              Static Data -----------------------------------------------------------------------------

@@ -155,7 +155,7 @@ --      f_1 x_2 = let f_3 x_4 = x_4 + 1 --                in f_3 (x_2 - 2) -- @---    But see Note [Shadowing] below.+--    But see Note [Shadowing in Core] below. -- -- 3. The resulting syntax tree undergoes type checking (which also deals with instantiating --    type class arguments) to yield a 'GHC.Hs.Expr.HsExpr' type that has 'GHC.Types.Id.Id' as it's names.@@ -313,26 +313,6 @@   deriving Data  {--Note [Shadowing]-~~~~~~~~~~~~~~~~-While various passes attempt to rename on-the-fly in a manner that-avoids "shadowing" (thereby simplifying downstream optimizations),-neither the simplifier nor any other pass GUARANTEES that shadowing is-avoided. Thus, all passes SHOULD work fine even in the presence of-arbitrary shadowing in their inputs.--In particular, scrutinee variables `x` in expressions of the form-`Case e x t` are often renamed to variables with a prefix-"wild_". These "wild" variables may appear in the body of the-case-expression, and further, may be shadowed within the body.--So the Unique in a Var is not really unique at all.  Still, it's very-useful to give a constant-time equality/ordering for Vars, and to give-a key that can be used to make sets of Vars (VarSet), or mappings from-Vars to other things (VarEnv).   Moreover, if you do want to eliminate-shadowing, you can give a new Unique to an Id without changing its-printable name, which makes debugging easier.- Note [Literal alternatives] ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Literal alternatives (LitAlt lit) are always for *un-lifted* literals.@@ -363,6 +343,39 @@   \(c :: Age~#Int) (d::Int). d |> (sym c) Here 'c' is a CoVar, which is lambda-bound, but it /occurs/ in a Coercion, (sym c).++Note [Shadowing in Core]+~~~~~~~~~~~~~~~~~~~~~~~~+You might wonder if there is an invariant that a Core expression has no+"shadowing".  For example, is this illegal?+     \x. \x. blah     -- x is shadowed+Answer; no!  Core does /not/ have a no-shadowing invariant.++Neither the simplifier nor any other pass GUARANTEES that shadowing is+avoided. Thus, all passes SHOULD work fine even in the presence of+arbitrary shadowing in their inputs.++So the Unique in a Var is not really unique at all.  Still, it's very+useful to give a constant-time equality/ordering for Vars, and to give+a key that can be used to make sets of Vars (VarSet), or mappings from+Vars to other things (VarEnv).   Moreover, if you do want to eliminate+shadowing, you can give a new Unique to an Id without changing its+printable name, which makes debugging easier.++It would in many ways be easier to have a no-shadowing invariant.  And the+Simplifier does its best to clone variables that are shadowed.  But it is+extremely difficult to GUARANTEE it:++* We use `GHC.Types.Id.mkTemplateLocal` to make up local binders, with uniques+  that are locally-unique (enough for the purpose) but not globally unique.+  It is convenient not to have to plumb a unique supply to these functions.++* It is very difficult for the Simplifier to gurantee a no-shadowing result.+  See Note [Shadowing in the Simplifier] in GHC.Core.Opt.Simplify.Iteration.++* See Note [Shadowing in CSE] in GHC.Core.Opt.CSE++* See Note [Shadowing in SpecConstr] in GHC.Core.Opt.SpecContr  Note [Core letrec invariant] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -8,7 +8,7 @@ module GHC.Core.Class (         Class,         ClassOpItem,-        ClassATItem(..), ATValidityInfo(..),+        ClassATItem(..), TyFamEqnValidityInfo(..),         ClassMinimalDef,         DefMethInfo, pprDefMethInfo, @@ -34,6 +34,7 @@ import GHC.Utils.Panic import GHC.Utils.Panic.Plain import GHC.Types.SrcLoc+import GHC.Types.Var.Set import GHC.Utils.Outputable import GHC.Data.BooleanFormula (BooleanFormula, mkTrue) @@ -96,20 +97,44 @@  data ClassATItem   = ATI TyCon         -- See Note [Associated type tyvar names]-        (Maybe (Type, ATValidityInfo))-                      -- Default associated type (if any) from this template-                      -- Note [Associated type defaults]+        (Maybe (Type, TyFamEqnValidityInfo))+          -- ^ Default associated type (if any) from this template.+          --+          -- As per Note [Associated type defaults], the Type has been renamed+          -- to use the class tyvars, while the 'TyFamEqnValidityInfo' uses+          -- the original user-written type variables. --- | Information about an associated type family default implementation. This--- is used solely for validity checking.+-- | Information about a type family equation, used for validity checking+-- of closed type family equations and associated type family default equations.+--+-- This type exists to delay validity-checking after typechecking type declaration+-- groups, to avoid cyclic evaluation inside the typechecking knot.+-- -- See @Note [Type-checking default assoc decls]@ in "GHC.Tc.TyCl".-data ATValidityInfo-  = NoATVI               -- Used for associated type families that are imported-                         -- from another module, for which we don't need to-                         -- perform any validity checking.+data TyFamEqnValidityInfo+  -- | Used for equations which don't need any validity checking,+  -- for example equations imported from another module.+  = NoVI -  | ATVI SrcSpan [Type]  -- Used for locally defined associated type families.-                         -- The [Type] are the LHS patterns.+  -- | Information necessary for validity checking of a type family equation.+  | VI+    { vi_loc :: SrcSpan+    , vi_qtvs :: [TcTyVar]+      -- ^ LHS quantified type variables+    , vi_non_user_tvs :: TyVarSet+      -- ^ non-user-written type variables (for error message reporting)+      --+      -- Example: with -XPolyKinds, typechecking @type instance forall a. F = ()@+      -- introduces the kind variable @k@ for the kind of @a@. See #23734.+    , vi_pats :: [Type]+      -- ^ LHS patterns+    , vi_rhs :: Type+      -- ^ RHS of the equation+      --+      -- NB: for associated type family default declarations, this is the RHS+      -- *before* applying the substitution from+      -- Note [Type-checking default assoc decls] in GHC.Tc.TyCl.+    }  type ClassMinimalDef = BooleanFormula Name -- Required methods @@ -166,9 +191,14 @@  * HOWEVER, in the internal ClassATItem we rename the RHS to match the    tyConTyVars of the family TyCon.  So in the example above we'd get    a ClassATItem of-        ATI F ((x,a) -> b)-   So the tyConTyVars of the family TyCon bind the free vars of-   the default Type rhs++        ATI F (Just ((x,a) -> b, validity_info)++   That is, the type stored in the first component of the pair has been+   renamed to use the class type variables. On the other hand, the+   TyFamEqnValidityInfo, used for validity checking of the type family equation+   (considered as a free-standing equation) uses the original types, e.g.+   involving the type variables 'p', 'q', 'r'.  The @mkClass@ function fills in the indirect superclasses. 

@@ -236,25 +236,35 @@          -- INVARIANT: co_ax_implicit == True implies length co_ax_branches == 1.     } +-- | A branch of a coercion axiom, which provides the evidence for+-- unwrapping a newtype or a type-family reduction step using a single equation. data CoAxBranch   = CoAxBranch-    { cab_loc      :: SrcSpan       -- Location of the defining equation-                                    -- See Note [CoAxiom locations]-    , cab_tvs      :: [TyVar]       -- Bound type variables; not necessarily fresh-                                    -- See Note [CoAxBranch type variables]-    , cab_eta_tvs  :: [TyVar]       -- Eta-reduced tyvars-                                    -- cab_tvs and cab_lhs may be eta-reduced; see-                                    -- Note [Eta reduction for data families]-    , cab_cvs      :: [CoVar]       -- Bound coercion variables-                                    -- Always empty, for now.-                                    -- See Note [Constraints in patterns]-                                    -- in GHC.Tc.TyCl-    , cab_roles    :: [Role]        -- See Note [CoAxBranch roles]-    , cab_lhs      :: [Type]        -- Type patterns to match against-    , cab_rhs      :: Type          -- Right-hand side of the equality-                                    -- See Note [CoAxioms are homogeneous]-    , cab_incomps  :: [CoAxBranch]  -- The previous incompatible branches-                                    -- See Note [Storing compatibility]+    { cab_loc      :: SrcSpan+        -- ^ Location of the defining equation+        -- See Note [CoAxiom locations]+    , cab_tvs      :: [TyVar]+       -- ^ Bound type variables; not necessarily fresh+       -- See Note [CoAxBranch type variables]+    , cab_eta_tvs  :: [TyVar]+       -- ^ Eta-reduced tyvars+       -- cab_tvs and cab_lhs may be eta-reduced; see+       -- Note [Eta reduction for data families]+    , cab_cvs      :: [CoVar]+       -- ^ Bound coercion variables+       -- Always empty, for now.+       -- See Note [Constraints in patterns]+       -- in GHC.Tc.TyCl+    , cab_roles    :: [Role]+       -- ^ See Note [CoAxBranch roles]+    , cab_lhs      :: [Type]+       -- ^ Type patterns to match against+    , cab_rhs      :: Type+       -- ^ Right-hand side of the equality+       -- See Note [CoAxioms are homogeneous]+    , cab_incomps  :: [CoAxBranch]+       -- ^ The previous incompatible branches+       -- See Note [Storing compatibility]     }   deriving Data.Data 

@@ -119,14 +119,6 @@    The returned floats and env both have an in-scope set, and they are    guaranteed to be the same. --Note [Shadowing]-~~~~~~~~~~~~~~~~-The simplifier used to guarantee that the output had no shadowing, but-it does not do so any more.   (Actually, it never did!)  The reason is-documented with simplifyArgs.-- Eta expansion ~~~~~~~~~~~~~~ For eta expansion, we want to catch things like@@ -262,7 +254,7 @@   = do  { (env1, triples) <- mapAccumLM add_rules env0 pairs0         ; let new_bndrs = map sndOf3 triples         ; (rec_floats, env2) <- enterRecGroupRHSs env1 new_bndrs $ \env ->-            go env triples+                                go env triples         ; return (mkRecFloats rec_floats, env2) }   where     add_rules :: SimplEnv -> (InBndr,InExpr) -> SimplM (SimplEnv, (InBndr, OutBndr, InExpr))@@ -303,10 +295,12 @@   | otherwise   = case bind_cxt of       BC_Join is_rec cont -> simplTrace "SimplBind:join" (ppr old_bndr) $-                             simplJoinBind env is_rec cont old_bndr new_bndr rhs env+                             simplJoinBind is_rec cont+                                           (old_bndr,env) (new_bndr,env) (rhs,env)        BC_Let top_lvl is_rec -> simplTrace "SimplBind:normal" (ppr old_bndr) $-                               simplLazyBind env top_lvl is_rec old_bndr new_bndr rhs env+                               simplLazyBind top_lvl is_rec+                                             (old_bndr,env) (new_bndr,env) (rhs,env)  simplTrace :: String -> SDoc -> SimplM a -> SimplM a simplTrace herald doc thing_inside = do@@ -316,19 +310,16 @@     else thing_inside  ---------------------------simplLazyBind :: SimplEnv-              -> TopLevelFlag -> RecFlag-              -> InId -> OutId          -- Binder, both pre-and post simpl-                                        -- Not a JoinId+simplLazyBind :: TopLevelFlag -> RecFlag+              -> (InId, SimplEnv)       -- InBinder, and static env for its unfolding (if any)+              -> (OutId, SimplEnv)      -- OutBinder, and SimplEnv after simplifying that binder                                         -- The OutId has IdInfo (notably RULES),                                         -- except arity, unfolding-                                        -- Ids only, no TyVars-              -> InExpr -> SimplEnv     -- The RHS and its environment+              -> (InExpr, SimplEnv)     -- The RHS and its static environment               -> SimplM (SimplFloats, SimplEnv)--- Precondition: the OutId is already in the InScopeSet of the incoming 'env'--- Precondition: not a JoinId+-- Precondition: Ids only, no TyVars; not a JoinId -- Precondition: rhs obeys the let-can-float invariant-simplLazyBind env top_lvl is_rec bndr bndr1 rhs rhs_se+simplLazyBind top_lvl is_rec (bndr,unf_se) (bndr1,env) (rhs,rhs_se)   = assert (isId bndr )     assertPpr (not (isJoinId bndr)) (ppr bndr) $     -- pprTrace "simplLazyBind" ((ppr bndr <+> ppr bndr1) $$ ppr rhs $$ ppr (seIdSubst rhs_se)) $@@ -379,24 +370,23 @@                         ; let poly_floats = foldl' extendFloats (emptyFloats env) poly_binds                         ; return (poly_floats, body3) } -        ; let env' = env `setInScopeFromF` rhs_floats-        ; rhs' <- rebuildLam env' tvs' body3 rhs_cont-        ; (bind_float, env2) <- completeBind env' (BC_Let top_lvl is_rec) bndr bndr1 rhs'+        ; let env1 = env `setInScopeFromF` rhs_floats+        ; rhs' <- rebuildLam env1 tvs' body3 rhs_cont+        ; (bind_float, env2) <- completeBind (BC_Let top_lvl is_rec) (bndr,unf_se) (bndr1,rhs',env1)         ; return (rhs_floats `addFloats` bind_float, env2) }  ---------------------------simplJoinBind :: SimplEnv-              -> RecFlag+simplJoinBind :: RecFlag               -> SimplCont-              -> InId -> OutId          -- Binder, both pre-and post simpl-                                        -- The OutId has IdInfo, except arity,-                                        --   unfolding-              -> InExpr -> SimplEnv     -- The right hand side and its env+              -> (InId, SimplEnv)       -- InBinder, with static env for its unfolding+              -> (OutId, SimplEnv)      -- OutBinder; SimplEnv has the binder in scope+                                        -- The OutId has IdInfo, except arity, unfolding+              -> (InExpr, SimplEnv)     -- The right hand side and its env               -> SimplM (SimplFloats, SimplEnv)-simplJoinBind env is_rec cont old_bndr new_bndr rhs rhs_se+simplJoinBind is_rec cont (old_bndr, unf_se) (new_bndr, env) (rhs, rhs_se)   = do  { let rhs_env = rhs_se `setInScopeFromE` env         ; rhs' <- simplJoinRhs rhs_env old_bndr rhs cont-        ; completeBind env (BC_Join is_rec cont) old_bndr new_bndr rhs' }+        ; completeBind (BC_Join is_rec cont) (old_bndr, unf_se) (new_bndr, rhs', env) }  -------------------------- simplAuxBind :: SimplEnv@@ -407,7 +397,7 @@ -- auxiliary bindings, notably in knownCon. -- -- The binder comes from a case expression (case binder or alternative)--- and so does not have rules, inline pragmas etc.+-- and so does not have rules, unfolding, inline pragmas etc. -- -- Precondition: rhs satisfies the let-can-float invariant @@ -436,8 +426,8 @@            -- Simplify the binder and complete the binding         ; (env1, new_bndr) <- simplBinder (env `setInScopeFromF` rhs_floats) bndr-        ; (bind_float, env2) <- completeBind env1 (BC_Let NotTopLevel NonRecursive)-                                             bndr new_bndr rhs1+        ; (bind_float, env2) <- completeBind (BC_Let NotTopLevel NonRecursive)+                                             (bndr,env) (new_bndr, rhs1, env1)          ; return (rhs_floats `addFloats` bind_float, env2) } @@ -843,7 +833,7 @@         ; (arity_type, expr2) <- tryEtaExpandRhs env (BC_Let top_lvl NonRecursive) var expr1           -- Technically we should extend the in-scope set in 'env' with           -- the 'floats' from prepareRHS; but they are all fresh, so there is-          -- no danger of introducing name shadowig in eta expansion+          -- no danger of introducing name shadowing in eta expansion          ; unf <- mkLetUnfolding uf_opts top_lvl VanillaSrc var expr2 @@ -917,11 +907,11 @@ Nor does it do the atomic-argument thing -} -completeBind :: SimplEnv-             -> BindContext-             -> InId           -- Old binder-             -> OutId          -- New binder; can be a JoinId-             -> OutExpr        -- New RHS+completeBind :: BindContext+             -> (InId, SimplEnv)           -- Old binder, and the static envt in which to simplify+                                           --   its stable unfolding (if any)+             -> (OutId, OutExpr, SimplEnv) -- New binder and rhs; can be a JoinId.+                                           -- And the SimplEnv with that OutId in scope.              -> SimplM (SimplFloats, SimplEnv) -- completeBind may choose to do its work --      * by extending the substitution (e.g. let x = y in ...)@@ -929,7 +919,7 @@ -- -- Binder /can/ be a JoinId -- Precondition: rhs obeys the let-can-float invariant-completeBind env bind_cxt old_bndr new_bndr new_rhs+completeBind bind_cxt (old_bndr, unf_se) (new_bndr, new_rhs, env)  | isCoVar old_bndr  = case new_rhs of      Coercion co -> return (emptyFloats env, extendCvSubst env old_bndr co)@@ -945,9 +935,10 @@          -- See Note [Eta-expanding at let bindings] in GHC.Core.Opt.Simplify.Utils       ; (new_arity, eta_rhs) <- tryEtaExpandRhs env bind_cxt new_bndr new_rhs -        -- Simplify the unfolding-      ; new_unfolding <- simplLetUnfolding env bind_cxt old_bndr-                         eta_rhs (idType new_bndr) new_arity old_unf+        -- Simplify the unfolding; see Note [Environment for simplLetUnfolding]+      ; new_unfolding <- simplLetUnfolding (unf_se `setInScopeFromE` env)+                            bind_cxt old_bndr+                            eta_rhs (idType new_bndr) new_arity old_unf        ; let new_bndr_w_info = addLetBndrInfo new_bndr new_arity new_unfolding         -- See Note [In-scope set as a substitution]@@ -1064,7 +1055,37 @@ unfolding because it's too big. Hence the belt-and-braces `orElse` in the defn of unf_rhs.  The Nothing case probably never happens. +Note [Environment for simplLetUnfolding]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We need to be rather careful about the static environment in which+we simplify a stable unfolding.  Consider (#24242): +  f x = let y_Xb = ... in+        let step1_Xb {Stable unfolding = ....y_Xb...} = rhs in+         ...++Note that `y_Xb` and `step1_Xb` have the same unique (`Xb`). This can happen;+see Note [Shadowing in Core] in GHC.Core, and Note [Shadowing in the Simplifier].+This is perfectly fine. The `y_Xb` in the stable unfolding of the non-+recursive binding for `step1` refers, of course, to `let y_Xb = ....`.+When simplifying the binder `step1_Xb` we'll give it a new unique, and+extend the static environment with [Xb :-> step1_Xc], say.++But when simplifying step1's stable unfolding, we must use static environment+/before/ simplifying the binder `step1_Xb`; that is, a static envt that maps+[Xb :-> y_Xb], /not/ [Xb :-> step1_Xc].++That is why we pass around a pair `(InId, SimplEnv)` for the binder, keeping+track of the right environment for the unfolding of that InId.  See the type+of `simplLazyBind`, `simplJoinBind`, `completeBind`.++This only matters when we have+  - A non-recursive binding for f+  - has a stable unfolding+  - and that unfolding mentions a variable y+  - that has the same unique as f.+So triggering  a bug here is really hard!+ ************************************************************************ *                                                                      * \subsection[Simplify-simplExpr]{The main function: simplExpr}@@ -1524,7 +1545,7 @@  completeBindX :: SimplEnv               -> FromWhat-              -> InId -> OutExpr   -- Bind this Id to this (simplified) expression+              -> InId -> OutExpr   -- Non-recursively bind this Id to this (simplified) expression                                    -- (the let-can-float invariant may not be satisfied)               -> InExpr            -- In this body               -> SimplCont         -- Consumed by this continuation@@ -1554,14 +1575,14 @@               -- in T9630) to pass 'env' rather than 'env1'.  It's fine to pass 'env',               -- because this is simplNonRecX, so bndr is not in scope in the RHS. -        ; (bind_float, env2) <- completeBind (env2 `setInScopeFromF` rhs_floats)-                                             (BC_Let NotTopLevel NonRecursive)-                                             bndr bndr2 rhs1+        ; let env3 = env2 `setInScopeFromF` rhs_floats+        ; (bind_float, env4) <- completeBind (BC_Let NotTopLevel NonRecursive)+                                             (bndr,env) (bndr2, rhs1, env3)               -- Must pass env1 to completeBind in case simplBinder had to clone,               -- and extended the substitution with [bndr :-> new_bndr]          -- Simplify the body-        ; (body_floats, body') <- simplNonRecBody env2 from_what body cont+        ; (body_floats, body') <- simplNonRecBody env4 from_what body cont          ; let all_floats = rhs_floats `addFloats` bind_float `addFloats` body_floats         ; return ( all_floats, body' ) }@@ -1776,10 +1797,11 @@ ------------------ simplNonRecE :: SimplEnv              -> FromWhat-             -> InId                    -- The binder, always an Id-                                        -- Never a join point-             -> (InExpr, SimplEnv)      -- Rhs of binding (or arg of lambda)-             -> InExpr                  -- Body of the let/lambda+             -> InId               -- The binder, always an Id+                                   -- Never a join point+                                   -- The static env for its unfolding (if any) is the first parameter+             -> (InExpr, SimplEnv) -- Rhs of binding (or arg of lambda)+             -> InExpr             -- Body of the let/lambda              -> SimplCont              -> SimplM (SimplFloats, OutExpr) @@ -1808,8 +1830,8 @@   | otherwise  -- Evaluate RHS lazily   = do { (env1, bndr1)    <- simplNonRecBndr env bndr        ; (env2, bndr2)    <- addBndrRules env1 bndr bndr1 (BC_Let NotTopLevel NonRecursive)-       ; (floats1, env3)  <- simplLazyBind env2 NotTopLevel NonRecursive-                                           bndr bndr2 rhs rhs_se+       ; (floats1, env3)  <- simplLazyBind NotTopLevel NonRecursive+                                           (bndr,env) (bndr2,env2) (rhs,rhs_se)        ; (floats2, expr') <- simplNonRecBody env3 from_what body cont        ; return (floats1 `addFloats` floats2, expr') } @@ -1935,7 +1957,7 @@               res_ty = contResultType cont         ; (env1, bndr1)    <- simplNonRecJoinBndr env bndr mult res_ty         ; (env2, bndr2)    <- addBndrRules env1 bndr bndr1 (BC_Join NonRecursive cont)-        ; (floats1, env3)  <- simplJoinBind env2 NonRecursive cont bndr bndr2 rhs env+        ; (floats1, env3)  <- simplJoinBind NonRecursive cont (bndr,env) (bndr2,env2) (rhs,env)         ; (floats2, body') <- simplExprF env3 body cont         ; return (floats1 `addFloats` floats2, body') } @@ -2275,7 +2297,7 @@                (StrictArg { sc_fun = fun_info, sc_fun_ty = fun_ty                           , sc_dup = Simplified                           , sc_cont = cont })-                -- Note [Shadowing]+                -- Note [Shadowing in the Simplifier]    -- Lazy arguments   | otherwise@@ -2408,10 +2430,10 @@ participate in the rule firing. So we mark them as Simplified to avoid re-simplifying them. -Note [Shadowing]-~~~~~~~~~~~~~~~~-This part of the simplifier may break the no-shadowing invariant-Consider+Note [Shadowing in the Simplifier]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+This part of the simplifier may return an expression that has shadowing.+(See Note [Shadowing in Core] in GHC.Core.hs.) Consider         f (...(\a -> e)...) (case y of (a,b) -> e') where f is strict in its second arg If we simplify the innermost one first we get (...(\a -> e)...)@@ -2431,6 +2453,8 @@ to get the effect that finding (error "foo") in a strict arg position will discard the entire application and replace it with (error "foo").  Getting all this at once is TOO HARD!++See also Note [Shadowing in prepareAlts] in GHC.Core.Opt.Simplify.Utils.  Note [No eta-expansion in runRW#] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -191,10 +191,11 @@   | StrictBind          -- (StrictBind x b K)[e] = let x = e in K[b]                         --       or, equivalently,  = K[ (\x.b) e ]       { sc_dup   :: DupFlag        -- See Note [DupFlag invariants]-      , sc_bndr  :: InId       , sc_from  :: FromWhat+      , sc_bndr  :: InId       , sc_body  :: InExpr-      , sc_env   :: StaticEnv      -- See Note [StaticEnv invariant]+      , sc_env   :: StaticEnv      -- Static env for both sc_bndr (stable unfolding thereof)+                                   -- and sc_body.  Also see Note [StaticEnv invariant]       , sc_cont  :: SimplCont }    | StrictArg           -- (StrictArg (f e1 ..en) K)[e] = K[ f e1 .. en e ]@@ -2279,7 +2280,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Note that we pass case_bndr::InId to prepareAlts; an /InId/, not an /OutId/.  This is vital, because `refineDefaultAlt` uses `tys` to build-a new /InAlt/.  If you pass an OutId, we'll end up appling the+a new /InAlt/.  If you pass an OutId, we'll end up applying the substitution twice: disaster (#23012).  However this does mean that filling in the default alt might be

@@ -99,7 +99,14 @@ mkClassPred clas tys = mkTyConApp (classTyCon clas) tys  isDictTy :: Type -> Bool-isDictTy = isClassPred+-- True of dictionaries (Eq a) and+--         dictionary functions (forall a. Eq a => Eq [a])+-- See Note [Type determines value]+-- See #24370 (and the isDictId call in GHC.HsToCore.Binds.decomposeRuleLhs)+--     for why it's important to catch dictionary bindings+isDictTy ty = isClassPred pred+  where+    (_, pred) = splitInvisPiTys ty  typeDeterminesValue :: Type -> Bool -- See Note [Type determines value]

@@ -590,11 +590,13 @@      = exprFVs fv_expr (const True) emptyVarSet $! acc  ------------------+-- | Drop free vars from the breakpoint if they have a non-variable substitution. substTickish :: Subst -> CoreTickish -> CoreTickish substTickish subst (Breakpoint ext n ids)    = Breakpoint ext n (mapMaybe do_one ids)  where     do_one = getIdFromTrivialExpr_maybe . lookupIdSubst subst+ substTickish _subst other = other  {- Note [Substitute lazily]

@@ -31,6 +31,7 @@ import GHC.Types.Var.Env import GHC.Types.Var.Set import GHC.Types.Name( Name, mkSysTvName, mkSystemVarName )+import GHC.Builtin.Names( tYPETyConKey, cONSTRAINTTyConKey ) import GHC.Core.Type     hiding ( getTvSubstEnv ) import GHC.Core.Coercion hiding ( getCvSubstEnv ) import GHC.Core.TyCon@@ -1150,8 +1151,10 @@   -- TYPE and CONSTRAINT are not Apart   -- See Note [Type and Constraint are not apart] in GHC.Builtin.Types.Prim   -- NB: at this point we know that the two TyCons do not match-  | Just {} <- sORTKind_maybe ty1-  , Just {} <- sORTKind_maybe ty2+  | Just (tc1,_) <- mb_tc_app1, let u1 = tyConUnique tc1+  , Just (tc2,_) <- mb_tc_app2, let u2 = tyConUnique tc2+  , (u1 == tYPETyConKey && u2 == cONSTRAINTTyConKey) ||+    (u2 == tYPETyConKey && u1 == cONSTRAINTTyConKey)   = maybeApart MARTypeVsConstraint     -- We don't bother to look inside; wrinkle (W3) in GHC.Builtin.Types.Prim     -- Note [Type and Constraint are not apart]

@@ -39,6 +39,7 @@ import qualified Data.List.NonEmpty as NE import qualified Data.Semigroup ( (<>) ) import Control.Applicative( Alternative( (<|>) ) )+import Control.DeepSeq  infixr 3 `consBag` infixl 3 `snocBag`@@ -49,6 +50,12 @@   | TwoBags (Bag a) (Bag a) -- INVARIANT: neither branch is empty   | ListBag (NonEmpty a)   deriving (Foldable, Functor, Traversable)++instance NFData a => NFData (Bag a) where+  rnf EmptyBag = ()+  rnf (UnitBag a) = rnf a+  rnf (TwoBags a b) = rnf a `seq` rnf b+  rnf (ListBag a) = rnf a  emptyBag :: Bag a emptyBag = EmptyBag

@@ -46,7 +46,7 @@  import GHC.Prelude -import GHC.Utils.Misc ( minWith, count )+import GHC.Utils.Misc ( sortWith, count ) import GHC.Utils.Outputable import GHC.Utils.Panic import GHC.Data.Maybe ( expectJust )@@ -219,47 +219,52 @@      [payload])         -- Rest of the path;                         --  [a,b,c] means c depends on b, b depends on a --- | Find a reasonably short cycle a->b->c->a, in a strongly--- connected component.  The input nodes are presumed to be--- a SCC, so you can start anywhere.+-- | Find a reasonably short cycle a->b->c->a, in a graph+-- The graph might not necessarily be strongly connected. findCycle :: forall payload key. Ord key           => [Node key payload]     -- The nodes.  The dependencies can                                     -- contain extra keys, which are ignored           -> Maybe [payload]        -- A cycle, starting with node                                     -- so each depends on the next findCycle graph-  = go Set.empty (new_work root_deps []) []+  = goRoots plausible_roots   where     env :: Map.Map key (Node key payload)     env = Map.fromList [ (node_key node, node) | node <- graph ] -    -- Find the node with fewest dependencies among the SCC modules-    -- This is just a heuristic to find some plausible root module-    root :: Node key payload-    root = fst (minWith snd [ (node, count (`Map.member` env)-                                           (node_dependencies node))-                            | node <- graph ])-    DigraphNode root_payload root_key root_deps = root+    goRoots [] = Nothing+    goRoots (root:xs) =+        case go Set.empty (new_work root_deps []) [] of+          Nothing -> goRoots xs+          Just res -> Just res+      where+        DigraphNode root_payload root_key root_deps = root+        -- 'go' implements Dijkstra's algorithm, more or less+        go :: Set.Set key   -- Visited+           -> [WorkItem key payload]        -- Work list, items length n+           -> [WorkItem key payload]        -- Work list, items length n+1+           -> Maybe [payload]               -- Returned cycle+           -- Invariant: in a call (go visited ps qs),+           --            visited = union (map tail (ps ++ qs)) +        go _       [] [] = Nothing  -- No cycles+        go visited [] qs = go visited qs []+        go visited (((DigraphNode payload key deps), path) : ps) qs+           | key == root_key           = Just (root_payload : reverse path)+           | key `Set.member` visited  = go visited ps qs+           | key `Map.notMember` env   = go visited ps qs+           | otherwise                 = go (Set.insert key visited)+                                            ps (new_qs ++ qs)+           where+             new_qs = new_work deps (payload : path) -    -- 'go' implements Dijkstra's algorithm, more or less-    go :: Set.Set key   -- Visited-       -> [WorkItem key payload]        -- Work list, items length n-       -> [WorkItem key payload]        -- Work list, items length n+1-       -> Maybe [payload]               -- Returned cycle-       -- Invariant: in a call (go visited ps qs),-       --            visited = union (map tail (ps ++ qs)) -    go _       [] [] = Nothing  -- No cycles-    go visited [] qs = go visited qs []-    go visited (((DigraphNode payload key deps), path) : ps) qs-       | key == root_key           = Just (root_payload : reverse path)-       | key `Set.member` visited  = go visited ps qs-       | key `Map.notMember` env   = go visited ps qs-       | otherwise                 = go (Set.insert key visited)-                                        ps (new_qs ++ qs)-       where-         new_qs = new_work deps (payload : path)+    -- Find the nodes with fewest dependencies among the SCC modules+    -- This is just a heuristic to find some plausible root module+    plausible_roots :: [Node key payload]+    plausible_roots = map fst (sortWith snd [ (node, count (`Map.member` env) (node_dependencies node))+                                            | node <- graph ])+      new_work :: [key] -> [payload] -> [WorkItem key payload]     new_work deps path = [ (n, path) | Just n <- map (`Map.lookup` env) deps ]

@@ -694,7 +694,8 @@         avx512er = False,         avx512f = False,         avx512pf = False,-        fma = False,+        -- Use FMA by default on AArch64+        fma = (platformArch . sTargetPlatform $ mySettings) == ArchAArch64,         rtldInfo = panic "defaultDynFlags: no rtldInfo",         rtccInfo = panic "defaultDynFlags: no rtccInfo",         rtasmInfo = panic "defaultDynFlags: no rtasmInfo",

@@ -161,6 +161,7 @@    | Opt_D_no_debug_output    | Opt_D_dump_faststrings    | Opt_D_faststring_stats+   | Opt_D_ipe_stats    deriving (Eq, Show, Enum)  -- | Helper function to query whether a given `DumpFlag` is enabled or not.@@ -223,6 +224,8 @@     | Opt_DistinctConstructorTables    | Opt_InfoTableMap+   | Opt_InfoTableMapWithFallback+   | Opt_InfoTableMapWithStack     | Opt_WarnIsError                    -- -Werror; makes warnings fatal    | Opt_ShowWarnGroups                 -- Show the group a warning belongs to@@ -577,6 +580,8 @@      -- Flags that affect debugging information    , Opt_DistinctConstructorTables    , Opt_InfoTableMap+   , Opt_InfoTableMapWithStack+   , Opt_InfoTableMapWithFallback    ]  data WarningFlag =@@ -684,7 +689,7 @@    | Opt_WarnImplicitRhsQuantification               -- Since 9.8    | Opt_WarnIncompleteExportWarnings                -- Since 9.8    | Opt_WarnInconsistentFlags                       -- Since 9.8-   deriving (Eq, Ord, Show, Enum)+   deriving (Eq, Ord, Show, Enum, Bounded)  -- | Return the names of a WarningFlag --

@@ -1567,6 +1567,8 @@         (NoArg (setGeneralFlag Opt_DoTagInferenceChecks))   , make_ord_flag defGhcFlag "dshow-passes"         (NoArg $ forceRecompile >> (setVerbosity $ Just 2))+  , make_ord_flag defGhcFlag "dipe-stats"+        (setDumpFlag Opt_D_ipe_stats)   , make_ord_flag defGhcFlag "dfaststring-stats"         (setDumpFlag Opt_D_faststring_stats)   , make_ord_flag defGhcFlag "dno-llvm-mangler"@@ -1805,10 +1807,6 @@         -- Caller-CC   , make_ord_flag defGhcFlag "fprof-callers"          (HasArg setCallerCcFilters)-  , make_ord_flag defGhcFlag "fdistinct-constructor-tables"-      (NoArg (setGeneralFlag Opt_DistinctConstructorTables))-  , make_ord_flag defGhcFlag "finfo-table-map"-      (NoArg (setGeneralFlag Opt_InfoTableMap))         ------ Compiler flags -----------------------------------------------    , make_ord_flag defGhcFlag "fasm"             (NoArg (setObjBackend ncgBackend))@@ -2171,126 +2169,125 @@ wWarningFlags = map snd (sortBy (comparing fst) wWarningFlagsDeps)  wWarningFlagsDeps :: [(Deprecation, FlagSpec WarningFlag)]-wWarningFlagsDeps = mconcat [+wWarningFlagsDeps = [minBound..maxBound] >>= \x -> case x of -- See Note [Updating flag description in the User's Guide] -- See Note [Supporting CLI completion] -- Please keep the list of flags below sorted alphabetically-  warnSpec    Opt_WarnAlternativeLayoutRuleTransitional,-  warnSpec    Opt_WarnAmbiguousFields,-  depWarnSpec Opt_WarnAutoOrphans-              "it has no effect",-  warnSpec    Opt_WarnCPPUndef,-  warnSpec    Opt_WarnUnbangedStrictPatterns,-  warnSpec    Opt_WarnDeferredTypeErrors,-  warnSpec    Opt_WarnDeferredOutOfScopeVariables,-  warnSpec    Opt_WarnDeprecatedFlags,-  warnSpec    Opt_WarnDerivingDefaults,-  warnSpec    Opt_WarnDerivingTypeable,-  warnSpec    Opt_WarnDodgyExports,-  warnSpec    Opt_WarnDodgyForeignImports,-  warnSpec    Opt_WarnDodgyImports,-  warnSpec    Opt_WarnEmptyEnumerations,-  subWarnSpec "duplicate-constraints"-              Opt_WarnDuplicateConstraints-              "it is subsumed by -Wredundant-constraints",-  warnSpec    Opt_WarnRedundantConstraints,-  warnSpec    Opt_WarnDuplicateExports,-  depWarnSpec Opt_WarnHiShadows-              "it is not used, and was never implemented",-  warnSpec    Opt_WarnInaccessibleCode,-  warnSpec    Opt_WarnImplicitPrelude,-  depWarnSpec Opt_WarnImplicitKindVars-              "it is now an error",-  warnSpec    Opt_WarnIncompletePatterns,-  warnSpec    Opt_WarnIncompletePatternsRecUpd,-  warnSpec    Opt_WarnIncompleteUniPatterns,-  warnSpec    Opt_WarnInlineRuleShadowing,-  warnSpec    Opt_WarnIdentities,-  warnSpec    Opt_WarnMissingFields,-  warnSpec    Opt_WarnMissingImportList,-  warnSpec    Opt_WarnMissingExportList,-  subWarnSpec "missing-local-sigs"-              Opt_WarnMissingLocalSignatures-              "it is replaced by -Wmissing-local-signatures",-  warnSpec    Opt_WarnMissingLocalSignatures,-  warnSpec    Opt_WarnMissingMethods,-  depWarnSpec Opt_WarnMissingMonadFailInstances-              "fail is no longer a method of Monad",-  warnSpec    Opt_WarnSemigroup,-  warnSpec    Opt_WarnMissingSignatures,-  warnSpec    Opt_WarnMissingKindSignatures,-  warnSpec    Opt_WarnMissingPolyKindSignatures,-  subWarnSpec "missing-exported-sigs"-              Opt_WarnMissingExportedSignatures-              "it is replaced by -Wmissing-exported-signatures",-  warnSpec    Opt_WarnMissingExportedSignatures,-  warnSpec    Opt_WarnMonomorphism,-  warnSpec    Opt_WarnNameShadowing,-  warnSpec    Opt_WarnNonCanonicalMonadInstances,-  depWarnSpec Opt_WarnNonCanonicalMonadFailInstances-              "fail is no longer a method of Monad",-  warnSpec    Opt_WarnNonCanonicalMonoidInstances,-  warnSpec    Opt_WarnOrphans,-  warnSpec    Opt_WarnOverflowedLiterals,-  warnSpec    Opt_WarnOverlappingPatterns,-  warnSpec    Opt_WarnMissedSpecs,-  warnSpec    Opt_WarnAllMissedSpecs,-  warnSpec'   Opt_WarnSafe setWarnSafe,-  warnSpec    Opt_WarnTrustworthySafe,-  warnSpec    Opt_WarnInferredSafeImports,-  warnSpec    Opt_WarnMissingSafeHaskellMode,-  warnSpec    Opt_WarnTabs,-  warnSpec    Opt_WarnTypeDefaults,-  warnSpec    Opt_WarnTypedHoles,-  warnSpec    Opt_WarnPartialTypeSignatures,-  warnSpec    Opt_WarnUnrecognisedPragmas,-  warnSpec    Opt_WarnMisplacedPragmas,-  warnSpec'   Opt_WarnUnsafe setWarnUnsafe,-  warnSpec    Opt_WarnUnsupportedCallingConventions,-  warnSpec    Opt_WarnUnsupportedLlvmVersion,-  warnSpec    Opt_WarnMissedExtraSharedLib,-  warnSpec    Opt_WarnUntickedPromotedConstructors,-  warnSpec    Opt_WarnUnusedDoBind,-  warnSpec    Opt_WarnUnusedForalls,-  warnSpec    Opt_WarnUnusedImports,-  warnSpec    Opt_WarnUnusedLocalBinds,-  warnSpec    Opt_WarnUnusedMatches,-  warnSpec    Opt_WarnUnusedPatternBinds,-  warnSpec    Opt_WarnUnusedTopBinds,-  warnSpec    Opt_WarnUnusedTypePatterns,-  warnSpec    Opt_WarnUnusedRecordWildcards,-  warnSpec    Opt_WarnRedundantBangPatterns,-  warnSpec    Opt_WarnRedundantRecordWildcards,-  warnSpec    Opt_WarnRedundantStrictnessFlags,-  warnSpec    Opt_WarnWrongDoBind,-  warnSpec    Opt_WarnMissingPatternSynonymSignatures,-  warnSpec    Opt_WarnMissingDerivingStrategies,-  warnSpec    Opt_WarnSimplifiableClassConstraints,-  warnSpec    Opt_WarnMissingHomeModules,-  warnSpec    Opt_WarnUnrecognisedWarningFlags,-  warnSpec    Opt_WarnStarBinder,-  warnSpec    Opt_WarnStarIsType,-  depWarnSpec Opt_WarnSpaceAfterBang-              "bang patterns can no longer be written with a space",-  warnSpec    Opt_WarnPartialFields,-  warnSpec    Opt_WarnPrepositiveQualifiedModule,-  warnSpec    Opt_WarnUnusedPackages,-  warnSpec    Opt_WarnCompatUnqualifiedImports,-  warnSpec    Opt_WarnInvalidHaddock,-  warnSpec    Opt_WarnOperatorWhitespaceExtConflict,-  warnSpec    Opt_WarnOperatorWhitespace,-  warnSpec    Opt_WarnImplicitLift,-  warnSpec    Opt_WarnMissingExportedPatternSynonymSignatures,-  warnSpec    Opt_WarnForallIdentifier,-  warnSpec    Opt_WarnUnicodeBidirectionalFormatCharacters,-  warnSpec    Opt_WarnGADTMonoLocalBinds,-  warnSpec    Opt_WarnTypeEqualityOutOfScope,-  warnSpec    Opt_WarnTypeEqualityRequiresOperators,-  warnSpec    Opt_WarnTermVariableCapture,-  warnSpec    Opt_WarnMissingRoleAnnotations,-  warnSpec    Opt_WarnImplicitRhsQuantification,-  warnSpec    Opt_WarnIncompleteExportWarnings- ]+  Opt_WarnAlternativeLayoutRuleTransitional -> warnSpec x+  Opt_WarnAmbiguousFields -> warnSpec x+  Opt_WarnAutoOrphans+    -> depWarnSpec x  "it has no effect"+  Opt_WarnCPPUndef -> warnSpec x+  Opt_WarnUnbangedStrictPatterns -> warnSpec x+  Opt_WarnDeferredTypeErrors -> warnSpec x+  Opt_WarnDeferredOutOfScopeVariables -> warnSpec x+  Opt_WarnDeprecatedFlags -> warnSpec x+  Opt_WarnDerivingDefaults -> warnSpec x+  Opt_WarnDerivingTypeable -> warnSpec x+  Opt_WarnDodgyExports -> warnSpec x+  Opt_WarnDodgyForeignImports -> warnSpec x+  Opt_WarnDodgyImports -> warnSpec x+  Opt_WarnEmptyEnumerations -> warnSpec x+  Opt_WarnDuplicateConstraints+    -> subWarnSpec "duplicate-constraints" x "it is subsumed by -Wredundant-constraints"+  Opt_WarnRedundantConstraints -> warnSpec x+  Opt_WarnDuplicateExports -> warnSpec x+  Opt_WarnHiShadows+    -> depWarnSpec x "it is not used, and was never implemented"+  Opt_WarnInaccessibleCode -> warnSpec x+  Opt_WarnImplicitPrelude -> warnSpec x+  Opt_WarnImplicitKindVars+    -> depWarnSpec x "it is now an error"+  Opt_WarnIncompletePatterns -> warnSpec x+  Opt_WarnIncompletePatternsRecUpd -> warnSpec x+  Opt_WarnIncompleteUniPatterns -> warnSpec x+  Opt_WarnInconsistentFlags -> warnSpec x+  Opt_WarnInlineRuleShadowing -> warnSpec x+  Opt_WarnIdentities -> warnSpec x+  Opt_WarnLoopySuperclassSolve -> warnSpec x+  Opt_WarnMissingFields -> warnSpec x+  Opt_WarnMissingImportList -> warnSpec x+  Opt_WarnMissingExportList -> warnSpec x+  Opt_WarnMissingLocalSignatures+    -> subWarnSpec "missing-local-sigs" x+                 "it is replaced by -Wmissing-local-signatures"+       ++ warnSpec x+  Opt_WarnMissingMethods -> warnSpec x+  Opt_WarnMissingMonadFailInstances+    -> depWarnSpec x "fail is no longer a method of Monad"+  Opt_WarnSemigroup -> warnSpec x+  Opt_WarnMissingSignatures -> warnSpec x+  Opt_WarnMissingKindSignatures -> warnSpec x+  Opt_WarnMissingPolyKindSignatures -> warnSpec x+  Opt_WarnMissingExportedSignatures+    -> subWarnSpec "missing-exported-sigs" x+                   "it is replaced by -Wmissing-exported-signatures"+       ++ warnSpec x+  Opt_WarnMonomorphism -> warnSpec x+  Opt_WarnNameShadowing -> warnSpec x+  Opt_WarnNonCanonicalMonadInstances -> warnSpec x+  Opt_WarnNonCanonicalMonadFailInstances -> depWarnSpec x "fail is no longer a method of Monad"+  Opt_WarnNonCanonicalMonoidInstances -> warnSpec x+  Opt_WarnOrphans -> warnSpec x+  Opt_WarnOverflowedLiterals -> warnSpec x+  Opt_WarnOverlappingPatterns -> warnSpec x+  Opt_WarnMissedSpecs -> warnSpec x+  Opt_WarnAllMissedSpecs -> warnSpec x+  Opt_WarnSafe -> warnSpec' x setWarnSafe+  Opt_WarnTrustworthySafe -> warnSpec x+  Opt_WarnInferredSafeImports -> warnSpec x+  Opt_WarnMissingSafeHaskellMode -> warnSpec x+  Opt_WarnTabs -> warnSpec x+  Opt_WarnTypeDefaults -> warnSpec x+  Opt_WarnTypedHoles -> warnSpec x+  Opt_WarnPartialTypeSignatures -> warnSpec x+  Opt_WarnUnrecognisedPragmas -> warnSpec x+  Opt_WarnMisplacedPragmas -> warnSpec x+  Opt_WarnUnsafe -> warnSpec' x setWarnUnsafe+  Opt_WarnUnsupportedCallingConventions -> warnSpec x+  Opt_WarnUnsupportedLlvmVersion -> warnSpec x+  Opt_WarnMissedExtraSharedLib -> warnSpec x+  Opt_WarnUntickedPromotedConstructors -> warnSpec x+  Opt_WarnUnusedDoBind -> warnSpec x+  Opt_WarnUnusedForalls -> warnSpec x+  Opt_WarnUnusedImports -> warnSpec x+  Opt_WarnUnusedLocalBinds -> warnSpec x+  Opt_WarnUnusedMatches -> warnSpec x+  Opt_WarnUnusedPatternBinds -> warnSpec x+  Opt_WarnUnusedTopBinds -> warnSpec x+  Opt_WarnUnusedTypePatterns -> warnSpec x+  Opt_WarnUnusedRecordWildcards -> warnSpec x+  Opt_WarnRedundantBangPatterns -> warnSpec x+  Opt_WarnRedundantRecordWildcards -> warnSpec x+  Opt_WarnRedundantStrictnessFlags -> warnSpec x+  Opt_WarnWrongDoBind -> warnSpec x+  Opt_WarnMissingPatternSynonymSignatures -> warnSpec x+  Opt_WarnMissingDerivingStrategies -> warnSpec x+  Opt_WarnSimplifiableClassConstraints -> warnSpec x+  Opt_WarnMissingHomeModules -> warnSpec x+  Opt_WarnUnrecognisedWarningFlags -> warnSpec x+  Opt_WarnStarBinder -> warnSpec x+  Opt_WarnStarIsType -> warnSpec x+  Opt_WarnSpaceAfterBang+    -> depWarnSpec x "bang patterns can no longer be written with a space"+  Opt_WarnPartialFields -> warnSpec x+  Opt_WarnPrepositiveQualifiedModule -> warnSpec x+  Opt_WarnUnusedPackages -> warnSpec x+  Opt_WarnCompatUnqualifiedImports -> warnSpec x+  Opt_WarnInvalidHaddock -> warnSpec x+  Opt_WarnOperatorWhitespaceExtConflict -> warnSpec x+  Opt_WarnOperatorWhitespace -> warnSpec x+  Opt_WarnImplicitLift -> warnSpec x+  Opt_WarnMissingExportedPatternSynonymSignatures -> warnSpec x+  Opt_WarnForallIdentifier -> warnSpec x+  Opt_WarnUnicodeBidirectionalFormatCharacters -> warnSpec x+  Opt_WarnGADTMonoLocalBinds -> warnSpec x+  Opt_WarnTypeEqualityOutOfScope -> warnSpec x+  Opt_WarnTypeEqualityRequiresOperators -> warnSpec x+  Opt_WarnTermVariableCapture -> warnSpec x+  Opt_WarnMissingRoleAnnotations -> warnSpec x+  Opt_WarnImplicitRhsQuantification -> warnSpec x+  Opt_WarnIncompleteExportWarnings -> warnSpec x  warningGroupsDeps :: [(Deprecation, FlagSpec WarningGroup)] warningGroupsDeps = map mk warningGroups@@ -2486,7 +2483,11 @@   flagSpec "show-error-context"               Opt_ShowErrorContext,   flagSpec "cmm-thread-sanitizer"             Opt_CmmThreadSanitizer,   flagSpec "split-sections"                   Opt_SplitSections,-  flagSpec "break-points"                     Opt_InsertBreakpoints+  flagSpec "break-points"                     Opt_InsertBreakpoints,+  flagSpec "distinct-constructor-tables"      Opt_DistinctConstructorTables,+  flagSpec "info-table-map"                   Opt_InfoTableMap,+  flagSpec "info-table-map-with-stack"        Opt_InfoTableMapWithStack,+  flagSpec "info-table-map-with-fallback"     Opt_InfoTableMapWithFallback   ]   ++ fHoleFlags @@ -2780,6 +2781,8 @@                 ,(Opt_Strictness, turnOn, Opt_WorkerWrapper)                 ,(Opt_WriteIfSimplifiedCore, turnOn, Opt_WriteInterface)                 ,(Opt_ByteCodeAndObjectCode, turnOn, Opt_WriteIfSimplifiedCore)+                ,(Opt_InfoTableMap, turnOn, Opt_InfoTableMapWithStack)+                ,(Opt_InfoTableMap, turnOn, Opt_InfoTableMapWithFallback)                 ] ++ validHoleFitsImpliedGFlags  -- General flags that are switched on/off when other general flags are switched

@@ -279,9 +279,10 @@     mod_hidden pkg =         text "it is a hidden module in the package" <+> quotes (ppr pkg) -    unusable (pkg, reason)-      = text "It is a member of the package"-      <+> quotes (ppr pkg)+    unusable (UnusableUnit unit reason reexport)+      = text "It is " <> (if reexport then text "reexported from the package"+                                      else text "a member of the package")+      <+> quotes (ppr unit)       $$ pprReason (text "which is") reason  

@@ -25,7 +25,7 @@ import GHC.Types.Name (Name) import GHC.Types.TyThing (TyThing) import GHC.Unit.Types (Module, InstalledModule, UnitId, Unit)-import GHC.Unit.State (UnitState, ModuleSuggestion, ModuleOrigin, UnusableUnitReason, UnitInfo)+import GHC.Unit.State (UnitState, ModuleSuggestion, ModuleOrigin, UnusableUnit, UnitInfo) import GHC.Exception.Type (SomeException) import GHC.Unit.Types ( IsBootInterface ) import Language.Haskell.Syntax.Module.Name ( ModuleName )@@ -80,7 +80,7 @@   | CouldntFindInFiles [FilePath]   | GenericMissing       [(Unit, Maybe UnitInfo)] [Unit]-      [(Unit, UnusableUnitReason)] [FilePath]+      [UnusableUnit] [FilePath]   | MultiplePackages [(Module, ModuleOrigin)]   deriving Generic 

@@ -1486,7 +1486,7 @@ nested_doc_comment :: Action nested_doc_comment span buf _len _buf2 = {-# SCC "nested_doc_comment" #-} withLexedDocType worker   where-    worker input docType _checkNextLine = nested_comment_logic endComment "" input span+    worker input@(AI start_loc _) docType _checkNextLine = nested_comment_logic endComment "" input (mkPsSpan start_loc (psSpanEnd span))       where         endComment input lcomment           = docCommentEnd input (docType (\d -> NestedDocString d (mkHsDocStringChunk . dropTrailingDec <$> lcomment))) buf span

@@ -4,7 +4,6 @@  import GHC.Prelude --- TODO-#define MACHREGS_NO_REGS 1--- #define MACHREGS_wasm32 1+#define MACHREGS_NO_REGS 0+#define MACHREGS_wasm32 1 #include "CodeGen.Platform.h"

@@ -175,7 +175,7 @@   | RTSRep              -- The RTS needs to declare info tables with specific         Int             -- type tags, so this form lets us override the default         SMRep           -- tag for an SMRep.-  deriving Eq+  deriving (Eq, Ord)  -- | True \<=> This is a static closure.  Affects how we garbage-collect it. -- Static closure have an extra static link field at the end.@@ -193,7 +193,7 @@   | ThunkSelector SelectorOffset   | BlackHole   | IndStatic-  deriving Eq+  deriving (Eq, Ord)  type ConstrDescription = ByteString -- result of dataConIdentity type FunArity          = Int@@ -223,7 +223,7 @@   | ArgUnknown          -- For imported binds.                         -- Invariant: Never Unknown for binds of the module                         -- we are compiling.-  deriving (Eq)+  deriving (Eq, Ord)  instance Outputable ArgDescr where   ppr (ArgSpec n) = text "ArgSpec" <+> ppr n

@@ -89,6 +89,7 @@   { toolSettings_ldSupportsCompactUnwind :: Bool   , toolSettings_ldSupportsFilelist      :: Bool   , toolSettings_ldSupportsResponseFiles :: Bool+  , toolSettings_ldSupportsSingleModule  :: Bool   , toolSettings_ldIsGnuLd               :: Bool   , toolSettings_ccSupportsNoPie         :: Bool   , toolSettings_useInplaceMinGW         :: Bool

@@ -50,8 +50,9 @@   , stgToCmmFastPAPCalls   :: !Bool              -- ^   , stgToCmmSCCProfiling   :: !Bool              -- ^ Check if cost-centre profiling is enabled   , stgToCmmEagerBlackHole :: !Bool              -- ^-  , stgToCmmInfoTableMap   :: !Bool              -- ^ true means generate C Stub for IPE map, See note [Mapping-                                                 -- Info Tables to Source Positions]+  , stgToCmmInfoTableMap   :: !Bool              -- ^ true means generate C Stub for IPE map, See Note [Mapping Info Tables to Source Positions]+  , stgToCmmInfoTableMapWithFallback :: !Bool    -- ^ Include info tables with fallback source locations in the info table map+  , stgToCmmInfoTableMapWithStack :: !Bool       -- ^ Include info tables for STACK closures in the info table map   , stgToCmmOmitYields     :: !Bool              -- ^ true means omit heap checks when no allocation is performed   , stgToCmmOmitIfPragmas  :: !Bool              -- ^ true means don't generate interface programs (implied by -O0)   , stgToCmmPIC            :: !Bool              -- ^ true if @-fPIC@

@@ -987,6 +987,12 @@                             -- Note [Swizzling the tyvars before generaliseTcTyCon]                 = vcat [ quotes (ppr n1) <+> text "bound at" <+> ppr (getSrcLoc n1)                        , quotes (ppr n2) <+> text "bound at" <+> ppr (getSrcLoc n2) ]++    TcRnDisconnectedTyVar n+      -> mkSimpleDecorated $+           hang (text "Scoped type variable only appears non-injectively in declaration header:")+              2 (quotes (ppr n) <+> text "bound at" <+> ppr (getSrcLoc n))+     TcRnInvalidReturnKind data_sort allowed_kind kind _suggested_ext       -> mkSimpleDecorated $            sep [ ppDataSort data_sort <+>@@ -2135,6 +2141,8 @@       -> ErrorWithoutFlag     TcRnDifferentNamesForTyVar{}       -> ErrorWithoutFlag+    TcRnDisconnectedTyVar{}+      -> ErrorWithoutFlag     TcRnInvalidReturnKind{}       -> ErrorWithoutFlag     TcRnClassKindNotConstraint{}@@ -2752,6 +2760,8 @@       -> noHints     TcRnDifferentNamesForTyVar{}       -> noHints+    TcRnDisconnectedTyVar n+      -> [SuggestBindTyVarExplicitly n]     TcRnInvalidReturnKind _ _ _ mb_suggest_unlifted_ext       -> case mb_suggest_unlifted_ext of            Nothing -> noHints@@ -5994,7 +6004,7 @@     hang (text "Mismatched type name in type family instance.")        2 (vcat [ text "Expected:" <+> ppr fam_tc_name                , text "  Actual:" <+> ppr eqn_tc_name ])-  FamInstRHSOutOfScopeTyVars mb_dodgy tvs ->+  FamInstRHSOutOfScopeTyVars mb_dodgy (NE.toList -> tvs) ->     hang (text "Out of scope type variable" <> plural tvs          <+> pprWithCommas (quotes . ppr) tvs          <+> text "in the RHS of a family instance.")@@ -6007,13 +6017,60 @@     mk_extra = case mb_dodgy of       Nothing -> empty       Just (fam_tc, pats, dodgy_tvs) ->-        ppWhen (any (`elemVarSetByKey` dodgy_tvs) (map nameUnique tvs)) $+        ppWhen (any (`elemVarSetByKey` dodgy_tvs) (fmap nameUnique tvs)) $           hang (text "The real LHS (expanding synonyms) is:")              2 (pprTypeApp fam_tc (map expandTypeSynonyms pats))-  FamInstLHSUnusedBoundTyVars tvs ->-    hang (text "Type variable" <> plural tvs <+> pprQuotedList tvs-          <+> isOrAre tvs <+> text "bound by a forall,")-       2 (text "but not used in the family instance.")+  FamInstLHSUnusedBoundTyVars (NE.toList -> bad_qtvs) ->+    vcat [ not_bound_msg, not_used_msg, dodgy_msg ]+    where++      -- Filter to only keep user-written variables,+      -- unless none were user-written in which case we report all of them+      -- (as we need to report an error).+      filter_user tvs+        = map ifiqtv+        $ case filter ifiqtv_user_written tvs of { [] -> tvs ; qvs -> qvs }++      (not_bound, not_used, dodgy)+        = case foldr acc_tv ([], [], []) bad_qtvs of+            (nb, nu, d) -> (filter_user nb, filter_user nu, filter_user d)++      acc_tv tv (nb, nu, d) = case ifiqtv_reason tv of+        InvalidFamInstQTvNotUsedInRHS   -> (nb, tv : nu, d)+        InvalidFamInstQTvNotBoundInPats -> (tv : nb, nu, d)+        InvalidFamInstQTvDodgy          -> (nb, nu, tv : d)++      -- Error message for type variables not bound in LHS patterns.+      not_bound_msg+        | null not_bound+        = empty+        | otherwise+        = vcat [ text "The type variable" <> plural not_bound <+> pprQuotedList not_bound+            <+> isOrAre not_bound <+> text "bound by a forall,"+              , text "but" <+> doOrDoes not_bound <+> text "not appear in any of the LHS patterns of the family instance." ]++      -- Error message for type variables bound by a forall but not used+      -- in the RHS.+      not_used_msg =+        if null not_used+        then empty+        else text "The type variable" <> plural not_used <+> pprQuotedList not_used+             <+> isOrAre not_used <+> text "bound by a forall," $$+             text "but" <+> itOrThey not_used <+>+             isOrAre not_used <> text "n't used in the family instance."++      -- Error message for dodgy type variables.+      -- See Note [Dodgy binding sites in type family instances] in GHC.Tc.Validity.+      dodgy_msg+        | null dodgy+        = empty+        | otherwise+        = hang (text "Dodgy type variable" <> plural dodgy <+> pprQuotedList dodgy+               <+> text "in the LHS of a family instance:")+             2 (text "the type variable" <> plural dodgy <+> pprQuotedList dodgy+                <+> text "syntactically appear" <> singular dodgy <+> text "in LHS patterns,"+               $$ text "but" <+> itOrThey dodgy <+> doOrDoes dodgy <> text "n't appear in an injective position.")+  illegalFamilyInstanceHints :: IllegalFamilyInstanceReason -> [GhcHint] illegalFamilyInstanceHints = \case

@@ -137,6 +137,7 @@   , IllegalHasFieldInstance(..)   , CoverageProblem(..), FailedCoverageCondition(..)   , IllegalFamilyInstanceReason(..)+  , InvalidFamInstQTv(..), InvalidFamInstQTvReason(..)   , InvalidAssoc(..), InvalidAssocInstance(..)   , InvalidAssocDefault(..), AssocDefaultBadArgs(..) @@ -180,7 +181,7 @@ import GHC.Types.Hint (UntickedPromotedThing(..)) import GHC.Types.ForeignCall (CLabelString) import GHC.Types.Id.Info ( RecSelParent(..) )-import GHC.Types.Name (Name, OccName, getSrcLoc, getSrcSpan)+import GHC.Types.Name (NamedThing(..), Name, OccName, getSrcLoc, getSrcSpan) import qualified GHC.Types.Name.Occurrence as OccName import GHC.Types.Name.Reader import GHC.Types.SourceFile (HsBootOrSig(..))@@ -2262,6 +2263,13 @@   -}   TcRnDifferentNamesForTyVar :: !Name -> !Name -> TcRnMessage +  {-| TcRnDisconnectedTyVar is an error for a data declaration that has a kind signature,+      where the implicitly-bound type type variables can't be matched up unambiguously+      with the ones from the signature. See Note [Disconnected type variables] in+      GHC.Tc.Gen.HsType.+  -}+  TcRnDisconnectedTyVar :: !Name -> TcRnMessage+   {-| TcRnInvalidReturnKind is an error for a data declaration that has a kind signature      with an invalid result kind. @@ -4547,13 +4555,46 @@         -- ^ family 'TyCon', arguments, and set of "dodgy" type variables         -- See Note [Dodgy binding sites in type family instances]         -- in GHC.Tc.Validity-      ![Name] -- ^ the out-of-scope type variables+      !(NE.NonEmpty Name) -- ^ the out-of-scope type variables    | FamInstLHSUnusedBoundTyVars-      ![Name] -- ^ the unused bound type variables+      !(NE.NonEmpty InvalidFamInstQTv) -- ^ the unused bound type variables    | InvalidAssoc !InvalidAssoc   deriving Generic++-- | A quantified type variable in a type or data family equation that+-- is either not bound in any LHS patterns or not used in the RHS (or both).+data InvalidFamInstQTv+  = InvalidFamInstQTv+    { ifiqtv :: TcTyVar+    , ifiqtv_user_written :: Bool+       -- ^ Did the user write this type variable, or was introduced by GHC?+       -- For example: with @-XPolyKinds@, in @type instance forall a. F = ()@,+       -- we have a user-written @a@ but GHC introduces a kind variable @k@+       -- as well. See #23734.+    , ifiqtv_reason       :: InvalidFamInstQTvReason+      -- ^ For what reason was the quantified type variable invalid?+    }++data InvalidFamInstQTvReason+  -- | A dodgy binder, i.e. a variable that syntactically appears in+  -- LHS patterns but only in non-injective positions.+  --+  -- See Note [Dodgy binding sites in type family instances]+  -- in GHC.Tc.Validity.+  = InvalidFamInstQTvDodgy+  -- | A quantified type variable in a type or data family equation+  -- that is not bound in any LHS patterns.+  | InvalidFamInstQTvNotBoundInPats+  -- | A quantified type variable in a type or data family equation+  -- that is not used on the RHS.+  | InvalidFamInstQTvNotUsedInRHS++-- The 'check_tvs' function in 'GHC.Tc.Validity.checkFamPatBinders'+-- uses 'getSrcSpan', so this 'NamedThing' instance is convenient.+instance NamedThing InvalidFamInstQTv where+  getName = getName . ifiqtv  data InvalidAssoc   -- | An invalid associated family instance.

@@ -175,7 +175,7 @@ -- 'avails' may have several items with the same availName -- E.g  import Ix( Ix(..), index ) -- will give Ix(Ix,index,range) and Ix(index)--- We want to combine these; addAvail does that+-- We want to combine these; plusAvail does that nubAvails :: [AvailInfo] -> [AvailInfo] nubAvails avails = eltsDNameEnv (foldl' add emptyDNameEnv avails)   where

@@ -458,6 +458,7 @@   GhcDiagnosticCode "TcRnInvalidVisibleKindArgument"                = 20967   GhcDiagnosticCode "TcRnTooManyBinders"                            = 05989   GhcDiagnosticCode "TcRnDifferentNamesForTyVar"                    = 17370+  GhcDiagnosticCode "TcRnDisconnectedTyVar"                         = 59738   GhcDiagnosticCode "TcRnInvalidReturnKind"                         = 55233   GhcDiagnosticCode "TcRnClassKindNotConstraint"                    = 80768   GhcDiagnosticCode "TcRnMatchesHaveDiffNumArgs"                    = 91938

@@ -474,6 +474,9 @@   -}   | SuggestBindTyVarOnLhs RdrName +  {-| Suggest binding explicitly; e.g   data T @k (a :: F k) = .... -}+  | SuggestBindTyVarExplicitly Name+ -- | An 'InstantiationSuggestion' for a '.hsig' file. This is generated -- by GHC in case of a 'DriverUnexpectedSignature' and suggests a way -- to instantiate a particular signature, where the first argument is

@@ -266,6 +266,9 @@             ppr_r = quotes $ ppr r     SuggestBindTyVarOnLhs tv       -> text "Bind" <+> quotes (ppr tv) <+> text "on the LHS of the type declaration"+    SuggestBindTyVarExplicitly tv+      -> text "bind" <+> quotes (ppr tv)+         <+> text "explicitly with" <+> quotes (char '@' <> ppr tv)  perhapsAsPat :: SDoc perhapsAsPat = text "Perhaps you meant an as-pattern, which must not be surrounded by whitespace"

@@ -76,6 +76,7 @@         -- ** Global 'RdrName' mapping elements: 'GlobalRdrElt', 'Provenance', 'ImportSpec'         GlobalRdrEltX(..), GlobalRdrElt, IfGlobalRdrElt, FieldGlobalRdrElt,         greName, greNameSpace, greParent, greInfo,+        plusGRE, insertGRE,         forceGlobalRdrEnv, hydrateGlobalRdrEnv,         isLocalGRE, isImportedGRE, isRecFldGRE,         fieldGREInfo,@@ -573,7 +574,10 @@             -- Note [Retrieving the GREInfo from interfaces] in GHC.Types.GREInfo.     } deriving (Data) +instance NFData a => NFData (GlobalRdrEltX a) where+  rnf (GRE name par _ imp info) = rnf name `seq` rnf par `seq` rnf imp `seq` rnf info + {- Note [IfGlobalRdrEnv] ~~~~~~~~~~~~~~~~~~~~~~~~ Information pertinent to the renamer about a 'Name' is stored in the fields of@@ -619,18 +623,19 @@ greInfo :: GlobalRdrElt -> GREInfo greInfo = gre_info -instance NFData IfGlobalRdrElt where-  rnf !_ = ()- -- | See Note [Parents] data Parent = NoParent-            | ParentIs  { par_is :: Name }+            | ParentIs  { par_is :: !Name }             deriving (Eq, Data)  instance Outputable Parent where    ppr NoParent        = empty    ppr (ParentIs n)    = text "parent:" <> ppr n +instance NFData Parent where+  rnf NoParent = ()+  rnf (ParentIs n) = rnf n+ plusParent :: Parent -> Parent -> Parent -- See Note [Combining parents] plusParent p1@(ParentIs _)    p2 = hasParent p1 p2@@ -933,11 +938,10 @@  -- | Drop all 'GREInfo' fields in a 'GlobalRdrEnv' in order to -- avoid space leaks.--- -- See Note [Forcing GREInfo] in GHC.Types.GREInfo. forceGlobalRdrEnv :: GlobalRdrEnvX info -> IfGlobalRdrEnv forceGlobalRdrEnv rdrs =-  strictMapOccEnv (strictMap (\ gre -> gre { gre_info = () })) rdrs+  strictMapOccEnv (strictMap (\ gre -> gre { gre_info = ()})) rdrs  -- | Hydrate a previously dehydrated 'GlobalRdrEnv', -- by (lazily!) looking up the 'GREInfo' using the provided function.@@ -1165,6 +1169,17 @@        }     -> WhichGREs GREInfo +instance Outputable (WhichGREs info) where+  ppr SameNameSpace = text "SameNameSpace"+  ppr (RelevantGREs { includeFieldSelectors = sel+                    , lookupVariablesForFields = vars+                    , lookupTyConsAsWell = tcs_too })+    = braces $ hsep+       [ text "RelevantGREs"+       , text (show sel)+       , if vars then text "[vars]" else empty+       , if tcs_too then text "[tcs]" else empty ]+ -- | Look up as many possibly relevant 'GlobalRdrElt's as possible. pattern AllRelevantGREs :: WhichGREs GREInfo pattern AllRelevantGREs =@@ -1199,6 +1214,17 @@     -- See Note [childGREPriority].   } +instance Outputable LookupChild where+  ppr (LookupChild { wantedParent = par+                   , lookupDataConFirst = dc+                   , prioritiseParent = prio_parent })+    = braces $ hsep+        [ text "LookupChild"+        , braces (text "parent:" <+> ppr par)+        , if dc then text "[dc_first]" else empty+        , if prio_parent then text "[prio_parent]" else empty+        ]+ -- | After looking up something with the given 'NameSpace', is the resulting -- 'GlobalRdrElt' we have obtained relevant, according to the 'RelevantGREs' -- specification of which 'NameSpace's are relevant?@@ -1893,25 +1919,28 @@ -- -- The 'ImportSpec' of something says how it came to be imported -- It's quite elaborate so that we can give accurate unused-name warnings.-data ImportSpec = ImpSpec { is_decl :: ImpDeclSpec,-                            is_item :: ImpItemSpec }+data ImportSpec = ImpSpec { is_decl :: !ImpDeclSpec,+                            is_item :: !ImpItemSpec }                 deriving( Eq, Data ) +instance NFData ImportSpec where+  rnf = rwhnf -- All fields are strict, so we don't need to do anything+ -- | Import Declaration Specification -- -- Describes a particular import declaration and is -- shared among all the 'Provenance's for that decl data ImpDeclSpec   = ImpDeclSpec {-        is_mod      :: Module,     -- ^ Module imported, e.g. @import Muggle@+        is_mod      :: !Module,     -- ^ Module imported, e.g. @import Muggle@                                    -- Note the @Muggle@ may well not be                                    -- the defining module for this thing!                                     -- TODO: either should be Module, or there                                    -- should be a Maybe UnitId here too.-        is_as       :: ModuleName, -- ^ Import alias, e.g. from @as M@ (or @Muggle@ if there is no @as@ clause)-        is_qual     :: Bool,       -- ^ Was this import qualified?-        is_dloc     :: SrcSpan     -- ^ The location of the entire import declaration+        is_as       :: !ModuleName, -- ^ Import alias, e.g. from @as M@ (or @Muggle@ if there is no @as@ clause)+        is_qual     :: !Bool,       -- ^ Was this import qualified?+        is_dloc     :: !SrcSpan     -- ^ The location of the entire import declaration     } deriving (Eq, Data)  -- | Import Item Specification@@ -1922,8 +1951,8 @@                         -- or had a hiding list    | ImpSome {-        is_explicit :: Bool,-        is_iloc     :: SrcSpan  -- Location of the import item+        is_explicit :: !Bool,+        is_iloc     :: !SrcSpan  -- Location of the import item     }   -- ^ The import had an import list.         -- The 'is_explicit' field is @True@ iff the thing was named         -- /explicitly/ in the import specs rather

@@ -61,7 +61,7 @@                                            --   but the *unit* is hidden          -- | Module is in these units, but it is unusable-      , fr_unusables   :: [(Unit, UnusableUnitReason)]+      , fr_unusables   :: [UnusableUnit]        , fr_suggestions :: [ModuleSuggestion] -- ^ Possible mis-spelled modules       }

@@ -575,11 +575,7 @@     `seq` rnf mi_anns     `seq` rnf mi_decls     `seq` rnf mi_extra_decls-    `seq`     mi_globals-    -- NB: we already removed any potential space leaks in 'mi_globals' by-    -- dehydrating, that is, by turning the 'GlobalRdrEnv' into a 'IfGlobalRdrEnv'.-    -- This means we don't need to use 'rnf' here.-    -- See Note [Forcing GREInfo] in GHC.Types.GREInfo.+    `seq` rnf mi_globals     `seq` rnf mi_insts     `seq` rnf mi_fam_insts     `seq` rnf mi_rules

@@ -43,6 +43,7 @@         LookupResult(..),         ModuleSuggestion(..),         ModuleOrigin(..),+        UnusableUnit(..),         UnusableUnitReason(..),         pprReason, @@ -173,8 +174,10 @@     -- (But maybe the user didn't realize), so we'll still keep track     -- of these modules.)     ModHidden-    -- | Module is unavailable because the package is unusable.-  | ModUnusable UnusableUnitReason++    -- | Module is unavailable because the unit is unusable.+  | ModUnusable !UnusableUnit+     -- | Module is public, and could have come from some places.   | ModOrigin {         -- | @Just False@ means that this module is in@@ -192,6 +195,13 @@       , fromPackageFlag :: Bool       } +-- | A unusable unit module origin+data UnusableUnit = UnusableUnit+  { uuUnit        :: !Unit               -- ^ Unusable unit+  , uuReason      :: !UnusableUnitReason -- ^ Reason+  , uuIsReexport  :: !Bool               -- ^ Is the "module" a reexport?+  }+ instance Outputable ModuleOrigin where     ppr ModHidden = text "hidden module"     ppr (ModUnusable _) = text "unusable module"@@ -236,7 +246,8 @@                     text "x: " <> ppr x $$ text "y: " <> ppr y             g Nothing x = x             g x Nothing = x-    x <> y = pprPanic "ModOrigin: hidden module redefined" $++    x <> y = pprPanic "ModOrigin: module origin mismatch" $                  text "x: " <> ppr x $$ text "y: " <> ppr y  instance Monoid ModuleOrigin where@@ -1818,21 +1829,36 @@ mkUnusableModuleNameProvidersMap unusables =     nonDetFoldUniqMap extend_modmap emptyUniqMap unusables  where-    extend_modmap (_uid, (pkg, reason)) modmap = addListTo modmap bindings+    extend_modmap (_uid, (unit_info, reason)) modmap = addListTo modmap bindings       where bindings :: [(ModuleName, UniqMap Module ModuleOrigin)]             bindings = exposed ++ hidden -            origin = ModUnusable reason-            pkg_id = mkUnit pkg+            origin_reexport =  ModUnusable (UnusableUnit unit reason True)+            origin_normal   =  ModUnusable (UnusableUnit unit reason False)+            unit = mkUnit unit_info              exposed = map get_exposed exposed_mods-            hidden = [(m, mkModMap pkg_id m origin) | m <- hidden_mods]+            hidden = [(m, mkModMap unit m origin_normal) | m <- hidden_mods] -            get_exposed (mod, Just mod') = (mod, unitUniqMap mod' origin)-            get_exposed (mod, _)         = (mod, mkModMap pkg_id mod origin)+            -- with re-exports, c:Foo can be reexported from two (or more)+            -- unusable packages:+            --  Foo -> a:Foo (unusable reason A) -> c:Foo+            --      -> b:Foo (unusable reason B) -> c:Foo+            --+            -- We must be careful to not record the following (#21097):+            --  Foo -> c:Foo (unusable reason A)+            --      -> c:Foo (unusable reason B)+            -- But:+            --  Foo -> a:Foo (unusable reason A)+            --      -> b:Foo (unusable reason B)+            --+            get_exposed (mod, Just _) = (mod, mkModMap unit mod origin_reexport)+            get_exposed (mod, _) = (mod, mkModMap unit mod origin_normal)+              -- in the reexport case, we create a virtual module that doesn't+              -- exist but we don't care as it's only used as a key in the map. -            exposed_mods = unitExposedModules pkg-            hidden_mods  = unitHiddenModules pkg+            exposed_mods = unitExposedModules unit_info+            hidden_mods  = unitHiddenModules  unit_info  -- | Add a list of key/value pairs to a nested map. --

@@ -51,6 +51,7 @@         ppWhen, ppUnless, ppWhenOption, ppUnlessOption,         speakNth, speakN, speakNOf, plural, singular,         isOrAre, doOrDoes, itsOrTheir, thisOrThese, hasOrHave,+        itOrThey,         unicodeSyntax,          coloured, keyword,@@ -1523,6 +1524,15 @@ itsOrTheir :: [a] -> SDoc itsOrTheir [_] = text "its" itsOrTheir _   = text "their"++-- | 'it' or 'they', depeneding on the length of the list.+--+-- > itOrThey [x]   = text "it"+-- > itOrThey [x,y] = text "they"+-- > itOrThey []    = text "they"  -- probably avoid this+itOrThey :: [a] -> SDoc+itOrThey [_] = text "it"+itOrThey _   = text "they"   -- | Determines the form of subject appropriate for the length of a list:

@@ -457,6 +457,12 @@ #define REG_D3          d14 #define REG_D4          d15 +#define REG_XMM1        q4+#define REG_XMM2        q5++#define CALLER_SAVES_XMM1+#define CALLER_SAVES_XMM2+ /* -----------------------------------------------------------------------------    The s390x register mapping @@ -593,6 +599,8 @@  #elif defined(MACHREGS_wasm32) +#define REG_Base           0+ #define REG_R1             1 #define REG_R2             2 #define REG_R3             3@@ -624,7 +632,6 @@ #define REG_SpLim          25 #define REG_Hp             26 #define REG_HpLim          27-#define REG_CCCS           28  /* -----------------------------------------------------------------------------    The loongarch64 register mapping

@@ -3,7 +3,7 @@ -- ./configure.  Make sure you are editing ghc.cabal.in, not ghc.cabal.  Name: ghc-Version: 9.8.1+Version: 9.8.2 License: BSD-3-Clause License-File: LICENSE Author: The GHC Team@@ -110,9 +110,9 @@                    exceptions == 0.10.*,                    semaphore-compat,                    stm,-                   ghc-boot   == 9.8.1,-                   ghc-heap   == 9.8.1,-                   ghci == 9.8.1+                   ghc-boot   == 9.8.2,+                   ghc-heap   == 9.8.2,+                   ghci == 9.8.2      if os(windows)         Build-Depends: Win32  >= 2.3 && < 2.14

@@ -1,7 +1,7 @@ cabal-version: 3.0 build-type: Simple name: ghc-lib-parser-version: 9.8.1.20231121+version: 9.8.2.20240223 license: BSD-3-Clause license-file: LICENSE category: Development@@ -52,6 +52,7 @@     compiler/GHC/Parser/HaddockLex.x     compiler/GHC/Parser.hs-boot     libraries/containers/containers/include/containers.h+    compiler/ghc-llvm-version.h     rts/include/ghcconfig.h     compiler/MachRegs.h     compiler/CodeGen.Platform.h@@ -59,7 +60,6 @@     compiler/ClosureTypes.h     compiler/FunTypes.h     compiler/Unique.h-    compiler/ghc-llvm-version.h source-repository head     type: git     location: git@github.com:digital-asset/ghc-lib.git

@@ -28,4 +28,4 @@ cStage                = show (1 :: Int)  cProjectUnitId :: String-cProjectUnitId = "ghc-9.8.1-inplace"+cProjectUnitId = "ghc-9.8.2-inplace"

@@ -386,7 +386,7 @@   , ("traceMarker#"," Emits a marker event via the RTS tracing framework.  The contents\n     of the event is the zero-terminated byte string passed as the first\n     argument.  The event will be emitted either to the @.eventlog@ file,\n     or to stderr, depending on the runtime RTS flags. ")   , ("setThreadAllocationCounter#"," Sets the allocation counter for the current thread to the given value. ")   , ("StackSnapshot#"," Haskell representation of a @StgStack*@ that was created (cloned)\n     with a function in \"GHC.Stack.CloneStack\". Please check the\n     documentation in that module for more detailed explanations. ")-  , ("coerce"," The function 'coerce' allows you to safely convert between values of\n     types that have the same representation with no run-time overhead. In the\n     simplest case you can use it instead of a newtype constructor, to go from\n     the newtype's concrete type to the abstract type. But it also works in\n     more complicated settings, e.g. converting a list of newtypes to a list of\n     concrete types.\n\n     This function is representation-polymorphic, but the\n     'RuntimeRep' type argument is marked as 'Inferred', meaning\n     that it is not available for visible type application. This means\n     the typechecker will accept @'coerce' \\@'Int' \\@Age 42@.\n   ")+  , ("coerce"," The function 'coerce' allows you to safely convert between values of\n     types that have the same representation with no run-time overhead. In the\n     simplest case you can use it instead of a newtype constructor, to go from\n     the newtype's concrete type to the abstract type. But it also works in\n     more complicated settings, e.g. converting a list of newtypes to a list of\n     concrete types.\n\n     When used in conversions involving a newtype wrapper,\n     make sure the newtype constructor is in scope.\n\n     This function is representation-polymorphic, but the\n     'RuntimeRep' type argument is marked as 'Inferred', meaning\n     that it is not available for visible type application. This means\n     the typechecker will accept @'coerce' \\@'Int' \\@Age 42@.\n\n     === __Examples__\n\n     >>> newtype TTL = TTL Int deriving (Eq, Ord, Show)\n     >>> newtype Age = Age Int deriving (Eq, Ord, Show)\n     >>> coerce (Age 42) :: TTL\n     TTL 42\n     >>> coerce (+ (1 :: Int)) (Age 42) :: TTL\n     TTL 43\n     >>> coerce (map (+ (1 :: Int))) [Age 42, Age 24] :: [TTL]\n     [TTL 43,TTL 25]\n\n   ")   , ("broadcastInt8X16#"," Broadcast a scalar to all elements of a vector. ")   , ("broadcastInt16X8#"," Broadcast a scalar to all elements of a vector. ")   , ("broadcastInt32X4#"," Broadcast a scalar to all elements of a vector. ")

@@ -2,7 +2,7 @@ ,("C compiler flags", "--target=x86_64-apple-darwin  -Qunused-arguments") ,("C++ compiler command", "/usr/bin/g++") ,("C++ compiler flags", "--target=x86_64-apple-darwin ")-,("C compiler link flags", "--target=x86_64-apple-darwin -Wl,-no_fixup_chains")+,("C compiler link flags", "--target=x86_64-apple-darwin -Wl,-no_fixup_chains -Wl,-no_warn_duplicate_libraries") ,("C compiler supports -no-pie", "NO") ,("Haskell CPP command", "/usr/bin/gcc") ,("Haskell CPP flags", "-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")@@ -10,8 +10,9 @@ ,("ld flags", "") ,("ld supports compact unwind", "YES") ,("ld supports filelist", "YES")-,("ld supports response files", "NO")+,("ld supports response files", "YES") ,("ld is GNU ld", "NO")+,("ld supports single module", "NO") ,("Merge objects command", "ld") ,("Merge objects flags", "-r") ,("ar command", "/usr/bin/ar")

@@ -3,19 +3,19 @@ import Prelude -- See Note [Why do we import Prelude here?]  cProjectGitCommitId   :: String-cProjectGitCommitId   = "443e870d977b1ab6fc05f47a9a17bc49296adbd6"+cProjectGitCommitId   = "f3225ed4b3f3c4309f9342c5e40643eeb0cc45da"  cProjectVersion       :: String-cProjectVersion       = "9.8.1"+cProjectVersion       = "9.8.2"  cProjectVersionInt    :: String cProjectVersionInt    = "908"  cProjectPatchLevel    :: String-cProjectPatchLevel    = "1"+cProjectPatchLevel    = "2"  cProjectPatchLevel1   :: String-cProjectPatchLevel1   = "1"+cProjectPatchLevel1   = "2"  cProjectPatchLevel2   :: String cProjectPatchLevel2   = "0"

@@ -1,5 +1,12 @@ /* This file is created automatically.  Do not edit by hand.*/ +// MAX_Real_Vanilla_REG 6+// MAX_Real_Float_REG 6+// MAX_Real_Double_REG 6+// MAX_Real_Long_REG 0+// WORD_SIZE 8+// BITMAP_BITS_SHIFT 6+// TAG_BITS 3 #define HS_CONSTANTS "291,1,2,4096,252,9,0,8,16,24,32,40,48,56,64,72,80,84,88,92,96,100,104,112,120,128,136,144,152,168,184,200,216,232,248,280,312,344,376,408,440,504,568,632,696,760,824,832,840,848,856,864,872,888,904,-24,-16,-8,24,0,8,48,46,96,72,8,48,8,8,16,8,64,8,16,8,0,72,56,8,16,0,8,8,0,8,0,104,120,16,8,16,0,4,4,24,20,4,15,7,1,-16,255,0,255,7,10,6,6,1,6,6,6,6,6,0,16384,21,1024,8,4,8,8,6,3,30,1152921503533105152,0,1152921504606846976,1" #define CONTROL_GROUP_CONST_291 291 #define STD_HDR_SIZE 1

@@ -106,36 +106,36 @@ /* Does C compiler support __atomic primitives? */ #define HAVE_C11_ATOMICS 1 -/* Define to 1 if you have the `clock_gettime' function. */+/* Define to 1 if you have the 'clock_gettime' function. */ #define HAVE_CLOCK_GETTIME 1 -/* Define to 1 if you have the `ctime_r' function. */+/* Define to 1 if you have the 'ctime_r' function. */ #define HAVE_CTIME_R 1  /* Define to 1 if you have the <ctype.h> header file. */ #define HAVE_CTYPE_H 1 -/* Define to 1 if you have the declaration of `ctime_r', and to 0 if you+/* Define to 1 if you have the declaration of 'ctime_r', and to 0 if you    don't. */ #define HAVE_DECL_CTIME_R 1 -/* Define to 1 if you have the declaration of `environ', and to 0 if you+/* Define to 1 if you have the declaration of 'environ', and to 0 if you    don't. */ #define HAVE_DECL_ENVIRON 0 -/* Define to 1 if you have the declaration of `MADV_DONTNEED', and to 0 if you+/* Define to 1 if you have the declaration of 'MADV_DONTNEED', and to 0 if you    don't. */ /* #undef HAVE_DECL_MADV_DONTNEED */ -/* Define to 1 if you have the declaration of `MADV_FREE', and to 0 if you+/* Define to 1 if you have the declaration of 'MADV_FREE', and to 0 if you    don't. */ /* #undef HAVE_DECL_MADV_FREE */ -/* Define to 1 if you have the declaration of `MAP_NORESERVE', and to 0 if you+/* Define to 1 if you have the declaration of 'MAP_NORESERVE', and to 0 if you    don't. */ /* #undef HAVE_DECL_MAP_NORESERVE */ -/* Define to 1 if you have the declaration of `program_invocation_short_name',+/* Define to 1 if you have the declaration of 'program_invocation_short_name',    and to 0 if you don't. */ #define HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME 0 @@ -145,7 +145,7 @@ /* Define to 1 if you have the <dlfcn.h> header file. */ #define HAVE_DLFCN_H 1 -/* Define to 1 if you have the `dlinfo' function. */+/* Define to 1 if you have the 'dlinfo' function. */ /* #undef HAVE_DLINFO */  /* Define to 1 if you have the <elfutils/libdw.h> header file. */@@ -154,7 +154,7 @@ /* Define to 1 if you have the <errno.h> header file. */ #define HAVE_ERRNO_H 1 -/* Define to 1 if you have the `eventfd' function. */+/* Define to 1 if you have the 'eventfd' function. */ /* #undef HAVE_EVENTFD */  /* Define to 1 if you have the <fcntl.h> header file. */@@ -163,25 +163,25 @@ /* Define to 1 if you have the <ffi.h> header file. */ /* #undef HAVE_FFI_H */ -/* Define to 1 if you have the `fork' function. */+/* Define to 1 if you have the 'fork' function. */ #define HAVE_FORK 1 -/* Define to 1 if you have the `getclock' function. */+/* Define to 1 if you have the 'getclock' function. */ /* #undef HAVE_GETCLOCK */  /* Define to 1 if you have the `GetModuleFileName' function. */ /* #undef HAVE_GETMODULEFILENAME */ -/* Define to 1 if you have the `getpid' function. */+/* Define to 1 if you have the 'getpid' function. */ #define HAVE_GETPID 1 -/* Define to 1 if you have the `getrusage' function. */+/* Define to 1 if you have the 'getrusage' function. */ #define HAVE_GETRUSAGE 1 -/* Define to 1 if you have the `gettimeofday' function. */+/* Define to 1 if you have the 'gettimeofday' function. */ #define HAVE_GETTIMEOFDAY 1 -/* Define to 1 if you have the `getuid' function. */+/* Define to 1 if you have the 'getuid' function. */ #define HAVE_GETUID 1  /* Define to 1 if you have the <grp.h> header file. */@@ -190,28 +190,28 @@ /* Define to 1 if you have the <inttypes.h> header file. */ #define HAVE_INTTYPES_H 1 -/* Define to 1 if you have the `bfd' library (-lbfd). */+/* Define to 1 if you have the 'bfd' library (-lbfd). */ /* #undef HAVE_LIBBFD */ -/* Define to 1 if you have the `dl' library (-ldl). */+/* Define to 1 if you have the 'dl' library (-ldl). */ #define HAVE_LIBDL 1 -/* Define to 1 if you have the `iberty' library (-liberty). */+/* Define to 1 if you have the 'iberty' library (-liberty). */ /* #undef HAVE_LIBIBERTY */  /* Define to 1 if you need to link with libm */ #define HAVE_LIBM 1 -/* Define to 1 if you have the `mingwex' library (-lmingwex). */+/* Define to 1 if you have the 'mingwex' library (-lmingwex). */ /* #undef HAVE_LIBMINGWEX */  /* Define to 1 if you have libnuma */ #define HAVE_LIBNUMA 0 -/* Define to 1 if you have the `pthread' library (-lpthread). */+/* Define to 1 if you have the 'pthread' library (-lpthread). */ #define HAVE_LIBPTHREAD 1 -/* Define to 1 if you have the `rt' library (-lrt). */+/* Define to 1 if you have the 'rt' library (-lrt). */ /* #undef HAVE_LIBRT */  /* Define to 1 if you wish to compress IPE data in compiler results (requires@@ -224,7 +224,7 @@ /* Define to 1 if you have the <locale.h> header file. */ #define HAVE_LOCALE_H 1 -/* Define to 1 if the system has the type `long long'. */+/* Define to 1 if the system has the type 'long long'. */ #define HAVE_LONG_LONG 1  /* Define to 1 if you have the <minix/config.h> header file. */@@ -242,7 +242,7 @@ /* Define to 1 if we have printf$LDBLStub (Apple Mac OS >= 10.4, PPC). */ #define HAVE_PRINTF_LDBLSTUB 0 -/* Define to 1 if you have the `pthread_condattr_setclock' function. */+/* Define to 1 if you have the 'pthread_condattr_setclock' function. */ /* #undef HAVE_PTHREAD_CONDATTR_SETCLOCK */  /* Define to 1 if you have the <pthread.h> header file. */@@ -266,25 +266,25 @@ /* Define to 1 if you have the <pwd.h> header file. */ #define HAVE_PWD_H 1 -/* Define to 1 if you have the `raise' function. */+/* Define to 1 if you have the 'raise' function. */ #define HAVE_RAISE 1 -/* Define to 1 if you have the `sched_getaffinity' function. */+/* Define to 1 if you have the 'sched_getaffinity' function. */ /* #undef HAVE_SCHED_GETAFFINITY */  /* Define to 1 if you have the <sched.h> header file. */ #define HAVE_SCHED_H 1 -/* Define to 1 if you have the `sched_setaffinity' function. */+/* Define to 1 if you have the 'sched_setaffinity' function. */ /* #undef HAVE_SCHED_SETAFFINITY */ -/* Define to 1 if you have the `setitimer' function. */+/* Define to 1 if you have the 'setitimer' function. */ #define HAVE_SETITIMER 1 -/* Define to 1 if you have the `setlocale' function. */+/* Define to 1 if you have the 'setlocale' function. */ #define HAVE_SETLOCALE 1 -/* Define to 1 if you have the `siginterrupt' function. */+/* Define to 1 if you have the 'siginterrupt' function. */ #define HAVE_SIGINTERRUPT 1  /* Define to 1 if you have the <signal.h> header file. */@@ -308,7 +308,7 @@ /* Define to 1 if Apple-style dead-stripping is supported. */ #define HAVE_SUBSECTIONS_VIA_SYMBOLS 1 -/* Define to 1 if you have the `sysconf' function. */+/* Define to 1 if you have the 'sysconf' function. */ #define HAVE_SYSCONF 1  /* Define to 1 if you have libffi. */@@ -362,22 +362,22 @@ /* Define to 1 if you have the <termios.h> header file. */ #define HAVE_TERMIOS_H 1 -/* Define to 1 if you have the `timer_settime' function. */+/* Define to 1 if you have the 'timer_settime' function. */ /* #undef HAVE_TIMER_SETTIME */ -/* Define to 1 if you have the `times' function. */+/* Define to 1 if you have the 'times' function. */ #define HAVE_TIMES 1  /* Define to 1 if you have the <unistd.h> header file. */ #define HAVE_UNISTD_H 1 -/* Define to 1 if you have the `uselocale' function. */+/* Define to 1 if you have the 'uselocale' function. */ #define HAVE_USELOCALE 1  /* Define to 1 if you have the <utime.h> header file. */ #define HAVE_UTIME_H 1 -/* Define to 1 if you have the `vfork' function. */+/* Define to 1 if you have the 'vfork' function. */ #define HAVE_VFORK 1  /* Define to 1 if you have the <vfork.h> header file. */@@ -395,10 +395,10 @@ /* Define to 1 if you have the <winsock.h> header file. */ /* #undef HAVE_WINSOCK_H */ -/* Define to 1 if `fork' works. */+/* Define to 1 if 'fork' works. */ #define HAVE_WORKING_FORK 1 -/* Define to 1 if `vfork' works. */+/* Define to 1 if 'vfork' works. */ #define HAVE_WORKING_VFORK 1  /* Define to 1 if you have the <zstd.h> header file. */@@ -435,67 +435,67 @@ /* Use mmap in the runtime linker */ #define RTS_LINKER_USE_MMAP 1 -/* The size of `char', as computed by sizeof. */+/* The size of 'char', as computed by sizeof. */ #define SIZEOF_CHAR 1 -/* The size of `double', as computed by sizeof. */+/* The size of 'double', as computed by sizeof. */ #define SIZEOF_DOUBLE 8 -/* The size of `float', as computed by sizeof. */+/* The size of 'float', as computed by sizeof. */ #define SIZEOF_FLOAT 4 -/* The size of `int', as computed by sizeof. */+/* The size of 'int', as computed by sizeof. */ #define SIZEOF_INT 4 -/* The size of `int16_t', as computed by sizeof. */+/* The size of 'int16_t', as computed by sizeof. */ #define SIZEOF_INT16_T 2 -/* The size of `int32_t', as computed by sizeof. */+/* The size of 'int32_t', as computed by sizeof. */ #define SIZEOF_INT32_T 4 -/* The size of `int64_t', as computed by sizeof. */+/* The size of 'int64_t', as computed by sizeof. */ #define SIZEOF_INT64_T 8 -/* The size of `int8_t', as computed by sizeof. */+/* The size of 'int8_t', as computed by sizeof. */ #define SIZEOF_INT8_T 1 -/* The size of `long', as computed by sizeof. */+/* The size of 'long', as computed by sizeof. */ #define SIZEOF_LONG 8 -/* The size of `long long', as computed by sizeof. */+/* The size of 'long long', as computed by sizeof. */ #define SIZEOF_LONG_LONG 8 -/* The size of `short', as computed by sizeof. */+/* The size of 'short', as computed by sizeof. */ #define SIZEOF_SHORT 2 -/* The size of `uint16_t', as computed by sizeof. */+/* The size of 'uint16_t', as computed by sizeof. */ #define SIZEOF_UINT16_T 2 -/* The size of `uint32_t', as computed by sizeof. */+/* The size of 'uint32_t', as computed by sizeof. */ #define SIZEOF_UINT32_T 4 -/* The size of `uint64_t', as computed by sizeof. */+/* The size of 'uint64_t', as computed by sizeof. */ #define SIZEOF_UINT64_T 8 -/* The size of `uint8_t', as computed by sizeof. */+/* The size of 'uint8_t', as computed by sizeof. */ #define SIZEOF_UINT8_T 1 -/* The size of `unsigned char', as computed by sizeof. */+/* The size of 'unsigned char', as computed by sizeof. */ #define SIZEOF_UNSIGNED_CHAR 1 -/* The size of `unsigned int', as computed by sizeof. */+/* The size of 'unsigned int', as computed by sizeof. */ #define SIZEOF_UNSIGNED_INT 4 -/* The size of `unsigned long', as computed by sizeof. */+/* The size of 'unsigned long', as computed by sizeof. */ #define SIZEOF_UNSIGNED_LONG 8 -/* The size of `unsigned long long', as computed by sizeof. */+/* The size of 'unsigned long long', as computed by sizeof. */ #define SIZEOF_UNSIGNED_LONG_LONG 8 -/* The size of `unsigned short', as computed by sizeof. */+/* The size of 'unsigned short', as computed by sizeof. */ #define SIZEOF_UNSIGNED_SHORT 2 -/* The size of `void *', as computed by sizeof. */+/* The size of 'void *', as computed by sizeof. */ #define SIZEOF_VOID_P 8  /* If using the C implementation of alloca, define if you know the@@ -510,7 +510,7 @@    in the compiler (requires libzstd) */ #define STATIC_LIBZSTD 0 -/* Define to 1 if all of the C90 standard headers exist (not just the ones+/* Define to 1 if all of the C89 standard headers exist (not just the ones    required in a freestanding environment). This macro is provided for    backward compatibility; new code need not use it. */ #define STDC_HEADERS 1@@ -527,7 +527,7 @@ /* Set to 1 to use libdw */ #define USE_LIBDW 0 -/* Enable extensions on AIX 3, Interix.  */+/* Enable extensions on AIX, Interix, z/OS.  */ #ifndef _ALL_SOURCE # define _ALL_SOURCE 1 #endif@@ -588,11 +588,15 @@ #ifndef __STDC_WANT_IEC_60559_DFP_EXT__ # define __STDC_WANT_IEC_60559_DFP_EXT__ 1 #endif+/* Enable extensions specified by C23 Annex F.  */+#ifndef __STDC_WANT_IEC_60559_EXT__+# define __STDC_WANT_IEC_60559_EXT__ 1+#endif /* Enable extensions specified by ISO/IEC TS 18661-4:2015.  */ #ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__ # define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1 #endif-/* Enable extensions specified by ISO/IEC TS 18661-3:2015.  */+/* Enable extensions specified by C23 Annex H and ISO/IEC TS 18661-3:2015.  */ #ifndef __STDC_WANT_IEC_60559_TYPES_EXT__ # define __STDC_WANT_IEC_60559_TYPES_EXT__ 1 #endif@@ -633,16 +637,22 @@ /* Number of bits in a file offset, on hosts where this is settable. */ /* #undef _FILE_OFFSET_BITS */ -/* Define for large files, on AIX-style hosts. */+/* Define to 1 on platforms where this makes off_t a 64-bit type. */ /* #undef _LARGE_FILES */ +/* Number of bits in time_t, on hosts where this is settable. */+/* #undef _TIME_BITS */++/* Define to 1 on platforms where this makes time_t a 64-bit type. */+/* #undef __MINGW_USE_VC2005_COMPAT */+ /* ARM pre v6 */ /* #undef arm_HOST_ARCH_PRE_ARMv6 */  /* ARM pre v7 */ /* #undef arm_HOST_ARCH_PRE_ARMv7 */ -/* Define to empty if `const' does not conform to ANSI C. */+/* Define to empty if 'const' does not conform to ANSI C. */ /* #undef const */  /* Define as a signed integer type capable of holding a process identifier. */@@ -654,10 +664,10 @@ /* The minimum supported LLVM version number */ #define sUPPORTED_LLVM_VERSION_MIN (11) -/* Define to `unsigned int' if <sys/types.h> does not define. */+/* Define as 'unsigned int' if <stddef.h> doesn't define. */ /* #undef size_t */ -/* Define as `fork' if `vfork' does not work. */+/* Define as 'fork' if 'vfork' does not work. */ /* #undef vfork */ /* ghcautoconf.h.autoconf.  Generated from ghcautoconf.h.autoconf.in by configure.  */ /* ghcautoconf.h.autoconf.in.  Generated from configure.ac by autoheader.  */

@@ -2,7 +2,7 @@ -- ./configure.  Make sure you are editing ghc-bin.cabal.in, not ghc-bin.cabal.  Name: ghc-bin-Version: 9.8.1+Version: 9.8.2 Copyright: XXX -- License: XXX -- License-File: XXX@@ -39,8 +39,8 @@                    filepath   >= 1   && < 1.5,                    containers >= 0.5 && < 0.7,                    transformers >= 0.5 && < 0.7,-                   ghc-boot      == 9.8.1,-                   ghc           == 9.8.1+                   ghc-boot      == 9.8.2,+                   ghc           == 9.8.2      if os(windows)         Build-Depends: Win32  >= 2.3 && < 2.14@@ -58,7 +58,7 @@         Build-depends:             deepseq        >= 1.4 && < 1.6,             ghc-prim       >= 0.5.0 && < 0.12,-            ghci           == 9.8.1,+            ghci           == 9.8.2,             haskeline      == 0.8.*,             exceptions     == 0.10.*,             time           >= 1.8 && < 1.13

@@ -3,7 +3,7 @@ -- ghc-boot-th.cabal.in, not ghc-boot-th.cabal.  name:           ghc-boot-th-version:        9.8.1+version:        9.8.2 license:        BSD3 license-file:   LICENSE category:       GHC

@@ -5,7 +5,7 @@ -- ghc-boot.cabal.  name:           ghc-boot-version:        9.8.1+version:        9.8.2 license:        BSD-3-Clause license-file:   LICENSE category:       GHC@@ -77,7 +77,7 @@                    directory  >= 1.2 && < 1.4,                    filepath   >= 1.3 && < 1.5,                    deepseq    >= 1.4 && < 1.6,-                   ghc-boot-th == 9.8.1+                   ghc-boot-th == 9.8.2     if !os(windows)         build-depends:                    unix       >= 2.7 && < 2.9

@@ -1,6 +1,6 @@ cabal-version:  3.0 name:           ghc-heap-version:        9.8.1+version:        9.8.2 license:        BSD-3-Clause license-file:   LICENSE maintainer:     libraries@haskell.org

@@ -465,7 +465,7 @@ #define MIN_VERSION_ghc_heap(major1,major2,minor) (\   (major1) <  9 || \   (major1) == 9 && (major2) <  8 || \-  (major1) == 9 && (major2) == 8 && (minor) <= 1)+  (major1) == 9 && (major2) == 8 && (minor) <= 2) #endif /* MIN_VERSION_ghc_heap */ #if MIN_VERSION_ghc_heap(8,11,0) instance Binary Heap.StgTSOProfInfo

@@ -2,7 +2,7 @@ -- ../../configure.  Make sure you are editing ghci.cabal.in, not ghci.cabal.  name:           ghci-version:        9.8.1+version:        9.8.2 license:        BSD3 license-file:   LICENSE category:       GHC@@ -82,8 +82,8 @@         containers       >= 0.5 && < 0.7,         deepseq          >= 1.4 && < 1.6,         filepath         == 1.4.*,-        ghc-boot         == 9.8.1,-        ghc-heap         == 9.8.1,+        ghc-boot         == 9.8.2,+        ghc-heap         == 9.8.2,         template-haskell == 2.21.*,         transformers     >= 0.5 && < 0.7 

@@ -56,7 +56,7 @@      build-depends:         base        >= 4.11 && < 4.20,-        ghc-boot-th == 9.8.1,+        ghc-boot-th == 9.8.2,         ghc-prim,         pretty      == 1.1.*