diff --git a/compiler/CodeGen.Platform.h b/compiler/CodeGen.Platform.h --- a/compiler/CodeGen.Platform.h +++ b/compiler/CodeGen.Platform.h @@ -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) diff --git a/compiler/GHC/Cmm.hs b/compiler/GHC/Cmm.hs --- a/compiler/GHC/Cmm.hs +++ b/compiler/GHC/Cmm.hs @@ -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 ----------------------------------------------------------------------------- diff --git a/compiler/GHC/Core.hs b/compiler/GHC/Core.hs --- a/compiler/GHC/Core.hs +++ b/compiler/GHC/Core.hs @@ -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] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/compiler/GHC/Core/Class.hs b/compiler/GHC/Core/Class.hs --- a/compiler/GHC/Core/Class.hs +++ b/compiler/GHC/Core/Class.hs @@ -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. diff --git a/compiler/GHC/Core/Coercion/Axiom.hs b/compiler/GHC/Core/Coercion/Axiom.hs --- a/compiler/GHC/Core/Coercion/Axiom.hs +++ b/compiler/GHC/Core/Coercion/Axiom.hs @@ -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 diff --git a/compiler/GHC/Core/Opt/Simplify/Iteration.hs b/compiler/GHC/Core/Opt/Simplify/Iteration.hs --- a/compiler/GHC/Core/Opt/Simplify/Iteration.hs +++ b/compiler/GHC/Core/Opt/Simplify/Iteration.hs @@ -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#] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/compiler/GHC/Core/Opt/Simplify/Utils.hs b/compiler/GHC/Core/Opt/Simplify/Utils.hs --- a/compiler/GHC/Core/Opt/Simplify/Utils.hs +++ b/compiler/GHC/Core/Opt/Simplify/Utils.hs @@ -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 diff --git a/compiler/GHC/Core/Predicate.hs b/compiler/GHC/Core/Predicate.hs --- a/compiler/GHC/Core/Predicate.hs +++ b/compiler/GHC/Core/Predicate.hs @@ -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] diff --git a/compiler/GHC/Core/Subst.hs b/compiler/GHC/Core/Subst.hs --- a/compiler/GHC/Core/Subst.hs +++ b/compiler/GHC/Core/Subst.hs @@ -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] diff --git a/compiler/GHC/Core/Unify.hs b/compiler/GHC/Core/Unify.hs --- a/compiler/GHC/Core/Unify.hs +++ b/compiler/GHC/Core/Unify.hs @@ -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] diff --git a/compiler/GHC/Data/Bag.hs b/compiler/GHC/Data/Bag.hs --- a/compiler/GHC/Data/Bag.hs +++ b/compiler/GHC/Data/Bag.hs @@ -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 diff --git a/compiler/GHC/Data/Graph/Directed.hs b/compiler/GHC/Data/Graph/Directed.hs --- a/compiler/GHC/Data/Graph/Directed.hs +++ b/compiler/GHC/Data/Graph/Directed.hs @@ -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 ] diff --git a/compiler/GHC/Driver/DynFlags.hs b/compiler/GHC/Driver/DynFlags.hs --- a/compiler/GHC/Driver/DynFlags.hs +++ b/compiler/GHC/Driver/DynFlags.hs @@ -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", diff --git a/compiler/GHC/Driver/Flags.hs b/compiler/GHC/Driver/Flags.hs --- a/compiler/GHC/Driver/Flags.hs +++ b/compiler/GHC/Driver/Flags.hs @@ -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 -- diff --git a/compiler/GHC/Driver/Session.hs b/compiler/GHC/Driver/Session.hs --- a/compiler/GHC/Driver/Session.hs +++ b/compiler/GHC/Driver/Session.hs @@ -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 diff --git a/compiler/GHC/Iface/Errors/Ppr.hs b/compiler/GHC/Iface/Errors/Ppr.hs --- a/compiler/GHC/Iface/Errors/Ppr.hs +++ b/compiler/GHC/Iface/Errors/Ppr.hs @@ -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 diff --git a/compiler/GHC/Iface/Errors/Types.hs b/compiler/GHC/Iface/Errors/Types.hs --- a/compiler/GHC/Iface/Errors/Types.hs +++ b/compiler/GHC/Iface/Errors/Types.hs @@ -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 diff --git a/compiler/GHC/Parser/Lexer.x b/compiler/GHC/Parser/Lexer.x --- a/compiler/GHC/Parser/Lexer.x +++ b/compiler/GHC/Parser/Lexer.x @@ -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 diff --git a/compiler/GHC/Platform/Wasm32.hs b/compiler/GHC/Platform/Wasm32.hs --- a/compiler/GHC/Platform/Wasm32.hs +++ b/compiler/GHC/Platform/Wasm32.hs @@ -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" diff --git a/compiler/GHC/Runtime/Heap/Layout.hs b/compiler/GHC/Runtime/Heap/Layout.hs --- a/compiler/GHC/Runtime/Heap/Layout.hs +++ b/compiler/GHC/Runtime/Heap/Layout.hs @@ -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 diff --git a/compiler/GHC/Settings.hs b/compiler/GHC/Settings.hs --- a/compiler/GHC/Settings.hs +++ b/compiler/GHC/Settings.hs @@ -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 diff --git a/compiler/GHC/StgToCmm/Config.hs b/compiler/GHC/StgToCmm/Config.hs --- a/compiler/GHC/StgToCmm/Config.hs +++ b/compiler/GHC/StgToCmm/Config.hs @@ -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@ diff --git a/compiler/GHC/Tc/Errors/Ppr.hs b/compiler/GHC/Tc/Errors/Ppr.hs --- a/compiler/GHC/Tc/Errors/Ppr.hs +++ b/compiler/GHC/Tc/Errors/Ppr.hs @@ -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 diff --git a/compiler/GHC/Tc/Errors/Types.hs b/compiler/GHC/Tc/Errors/Types.hs --- a/compiler/GHC/Tc/Errors/Types.hs +++ b/compiler/GHC/Tc/Errors/Types.hs @@ -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. diff --git a/compiler/GHC/Types/Avail.hs b/compiler/GHC/Types/Avail.hs --- a/compiler/GHC/Types/Avail.hs +++ b/compiler/GHC/Types/Avail.hs @@ -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 diff --git a/compiler/GHC/Types/Error/Codes.hs b/compiler/GHC/Types/Error/Codes.hs --- a/compiler/GHC/Types/Error/Codes.hs +++ b/compiler/GHC/Types/Error/Codes.hs @@ -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 diff --git a/compiler/GHC/Types/Hint.hs b/compiler/GHC/Types/Hint.hs --- a/compiler/GHC/Types/Hint.hs +++ b/compiler/GHC/Types/Hint.hs @@ -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 diff --git a/compiler/GHC/Types/Hint/Ppr.hs b/compiler/GHC/Types/Hint/Ppr.hs --- a/compiler/GHC/Types/Hint/Ppr.hs +++ b/compiler/GHC/Types/Hint/Ppr.hs @@ -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" diff --git a/compiler/GHC/Types/Name/Reader.hs b/compiler/GHC/Types/Name/Reader.hs --- a/compiler/GHC/Types/Name/Reader.hs +++ b/compiler/GHC/Types/Name/Reader.hs @@ -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 diff --git a/compiler/GHC/Unit/Finder/Types.hs b/compiler/GHC/Unit/Finder/Types.hs --- a/compiler/GHC/Unit/Finder/Types.hs +++ b/compiler/GHC/Unit/Finder/Types.hs @@ -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 } diff --git a/compiler/GHC/Unit/Module/ModIface.hs b/compiler/GHC/Unit/Module/ModIface.hs --- a/compiler/GHC/Unit/Module/ModIface.hs +++ b/compiler/GHC/Unit/Module/ModIface.hs @@ -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 diff --git a/compiler/GHC/Unit/State.hs b/compiler/GHC/Unit/State.hs --- a/compiler/GHC/Unit/State.hs +++ b/compiler/GHC/Unit/State.hs @@ -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. -- diff --git a/compiler/GHC/Utils/Outputable.hs b/compiler/GHC/Utils/Outputable.hs --- a/compiler/GHC/Utils/Outputable.hs +++ b/compiler/GHC/Utils/Outputable.hs @@ -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: diff --git a/compiler/MachRegs.h b/compiler/MachRegs.h --- a/compiler/MachRegs.h +++ b/compiler/MachRegs.h @@ -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 diff --git a/compiler/ghc.cabal b/compiler/ghc.cabal --- a/compiler/ghc.cabal +++ b/compiler/ghc.cabal @@ -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 diff --git a/ghc-lib-parser.cabal b/ghc-lib-parser.cabal --- a/ghc-lib-parser.cabal +++ b/ghc-lib-parser.cabal @@ -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 diff --git a/ghc-lib/stage0/compiler/build/GHC/Settings/Config.hs b/ghc-lib/stage0/compiler/build/GHC/Settings/Config.hs --- a/ghc-lib/stage0/compiler/build/GHC/Settings/Config.hs +++ b/ghc-lib/stage0/compiler/build/GHC/Settings/Config.hs @@ -28,4 +28,4 @@ cStage = show (1 :: Int) cProjectUnitId :: String -cProjectUnitId = "ghc-9.8.1-inplace" +cProjectUnitId = "ghc-9.8.2-inplace" diff --git a/ghc-lib/stage0/compiler/build/primop-docs.hs-incl b/ghc-lib/stage0/compiler/build/primop-docs.hs-incl --- a/ghc-lib/stage0/compiler/build/primop-docs.hs-incl +++ b/ghc-lib/stage0/compiler/build/primop-docs.hs-incl @@ -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. ") diff --git a/ghc-lib/stage0/lib/settings b/ghc-lib/stage0/lib/settings --- a/ghc-lib/stage0/lib/settings +++ b/ghc-lib/stage0/lib/settings @@ -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") diff --git a/ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs b/ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs --- a/ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs +++ b/ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs @@ -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" diff --git a/ghc-lib/stage0/rts/build/include/GhclibDerivedConstants.h b/ghc-lib/stage0/rts/build/include/GhclibDerivedConstants.h --- a/ghc-lib/stage0/rts/build/include/GhclibDerivedConstants.h +++ b/ghc-lib/stage0/rts/build/include/GhclibDerivedConstants.h @@ -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 diff --git a/ghc-lib/stage0/rts/build/include/ghcautoconf.h b/ghc-lib/stage0/rts/build/include/ghcautoconf.h --- a/ghc-lib/stage0/rts/build/include/ghcautoconf.h +++ b/ghc-lib/stage0/rts/build/include/ghcautoconf.h @@ -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 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 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 header file. */ @@ -154,7 +154,7 @@ /* Define to 1 if you have the 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 header file. */ @@ -163,25 +163,25 @@ /* Define to 1 if you have the 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 header file. */ @@ -190,28 +190,28 @@ /* Define to 1 if you have the 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 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 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 header file. */ @@ -266,25 +266,25 @@ /* Define to 1 if you have the 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 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 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 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 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 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 header file. */ @@ -395,10 +395,10 @@ /* Define to 1 if you have the 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 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 does not define. */ +/* Define as 'unsigned int' if 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. */ diff --git a/ghc/ghc-bin.cabal b/ghc/ghc-bin.cabal --- a/ghc/ghc-bin.cabal +++ b/ghc/ghc-bin.cabal @@ -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 diff --git a/libraries/ghc-boot-th/ghc-boot-th.cabal b/libraries/ghc-boot-th/ghc-boot-th.cabal --- a/libraries/ghc-boot-th/ghc-boot-th.cabal +++ b/libraries/ghc-boot-th/ghc-boot-th.cabal @@ -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 diff --git a/libraries/ghc-boot/ghc-boot.cabal b/libraries/ghc-boot/ghc-boot.cabal --- a/libraries/ghc-boot/ghc-boot.cabal +++ b/libraries/ghc-boot/ghc-boot.cabal @@ -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 diff --git a/libraries/ghc-heap/ghc-heap.cabal b/libraries/ghc-heap/ghc-heap.cabal --- a/libraries/ghc-heap/ghc-heap.cabal +++ b/libraries/ghc-heap/ghc-heap.cabal @@ -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 diff --git a/libraries/ghci/GHCi/Message.hs b/libraries/ghci/GHCi/Message.hs --- a/libraries/ghci/GHCi/Message.hs +++ b/libraries/ghci/GHCi/Message.hs @@ -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 diff --git a/libraries/ghci/ghci.cabal b/libraries/ghci/ghci.cabal --- a/libraries/ghci/ghci.cabal +++ b/libraries/ghci/ghci.cabal @@ -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 diff --git a/libraries/template-haskell/template-haskell.cabal b/libraries/template-haskell/template-haskell.cabal --- a/libraries/template-haskell/template-haskell.cabal +++ b/libraries/template-haskell/template-haskell.cabal @@ -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.*