sheaf pushed to branch wip/spj-reinstallable-base2 at Glasgow Haskell Compiler / GHC Commits: 1575eb10 by sheaf at 2026-07-28T00:18:35+02:00 Allow GHC.Essentials to be hidden - - - - - 16 changed files: - compiler/GHC/Builtin.hs - compiler/GHC/Driver/Downsweep.hs - compiler/GHC/Driver/MakeFile.hs - compiler/GHC/HsToCore.hs - compiler/GHC/Iface/Errors/Ppr.hs - compiler/GHC/Iface/Load.hs - compiler/GHC/Iface/Make.hs - compiler/GHC/Iface/Recomp.hs - compiler/GHC/Unit/External.hs - compiler/GHC/Unit/Finder.hs - compiler/GHC/Unit/State.hs - libraries/base/base.cabal.in - testsuite/tests/interface-stability/base-exports.stdout - testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs - testsuite/tests/interface-stability/base-exports.stdout-mingw32 - utils/dump-decls/Main.hs Changes: ===================================== compiler/GHC/Builtin.hs ===================================== @@ -225,8 +225,7 @@ How known-occ entities work This is a big reason for (KnownOccNameInvariant): an export list cannot have two entities with the same OccName. - When GHC wants to find GHC.Essentials, it just looks for it in the same - way as any other import. + See Note [Finding GHC.Essentials] for how GHC finds the GHC.Essentials module. * There are three flags that control the treatment of known entities: -frebindable-known-names @@ -412,10 +411,9 @@ To make `wombat` into a known-key name, do the following. * Just like for known-occ names above, in any module in `base` or `ghc-internal` (which are compiled with -frebindable-known-names), ensure that `wombat` is in scope by saying `import M( wombat )`. --} -{- Note [Known entities and reinstallable base] -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Note [Known entities and reinstallable base] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The design of known-entities in GHC, described in Note [Overview of known entities], is carefully crafted to support a single version of GHC to compile different versions of base, even though GHC itself is compiled against a fixed version of @@ -453,6 +451,45 @@ Let's compare two examples: `coerce` and `enumFromTo`. `enumFromTo` (see `GHC.Iface.Load.lookupKnownOccName`). This means GHC never needs to know where precisely `enumFromTo` is defined, allowing it to be defined anywhere (wherever in `base`, or in a module imported by `base`). + +Note [Finding GHC.Essentials] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +As explained in Note [Overview of known entities], when compiling a module that +does not enable -frebindable-known-names, GHC resolves known entities by looking +them up in GHC.Essentials. Every module that does not enable +-frebindable-known-names therefore acquires an implicit dependency on GHC.Essentials. + +As GHC.Essentials is an implementation detail, we would really rather not insist +that it be an exposed module (e.g. of 'base'). So we must ensure that GHC can +still adequately resolve the implicit dependency even if GHC.Essentials is hidden. + +Hidden-ness only ever obstructs the resolution of a 'ModuleName' into a 'Module'. +Thus, to allow GHC.Essentials to be hidden (not available via user-written +imports) while retaining the ability to resolve known entities, we follow the +following plan: + + (FindEssentials1) + 'GHC.Unit.Finder.findModuleWithIsBoot' has special logic to resolve a + possibly hidden GHC.Essentials module, using 'GHC.Unit.Finder.findEssentialsModule'. + + Every code path that needs to find GHC.Essentials despite it being hidden + goes through here, including: + + - downsweep GHC.Driver.Downsweep.summariseModuleDispatch + - ghc -M GHC.Driver.MakeFile.findDependency + - recompilation checking GHC.Iface.Recomp.checkDependencies + + Source-written imports go via 'GHC.Iface.Load.loadSrcInterface_maybe', + which uses 'GHC.Unit.Finder.findImportedModule', which rejects hidden modules. + + (FindEssentials2) + 'GHC.Unit.Module.Deps.mkDependencies' records the unit that provides + GHC.Essentials, so that the implicit dependency appears in the interface file. + + (FindEssentials3) + 'GHC.Driver.Make.warnUnusedPackages' has a special case to ensure that we + don't flag up the unit that provides GHC.Essentials as unused when it is + only implicitly imported. -} {- ===================================== compiler/GHC/Driver/Downsweep.hs ===================================== @@ -1374,9 +1374,8 @@ summariseModuleDispatch k hsc_env' home_unit is_boot (L _ wanted_mod) mb_pkg exc hsc_env = hscSetActiveHomeUnit home_unit hsc_env' find_it :: IO SummariseResult - find_it = do - found <- findImportedModuleWithIsBoot hsc_env wanted_mod is_boot mb_pkg + found <- findModuleWithIsBoot hsc_env wanted_mod is_boot mb_pkg case found of Found location mod | moduleUnitId mod `Set.member` hsc_all_home_unit_ids hsc_env -> ===================================== compiler/GHC/Driver/MakeFile.hs ===================================== @@ -305,8 +305,8 @@ findDependency :: HscEnv -> IO (Either (MsgEnvelope GhcMessage) (Maybe FilePath)) -- Interface file findDependency hsc_env srcloc pkg imp is_boot include_pkg_deps = do -- Find the module; this will be fast because - -- we've done it once during downsweep - r <- findImportedModuleWithIsBoot hsc_env imp is_boot pkg + -- we've done it once during downsweep. + r <- findModuleWithIsBoot hsc_env imp is_boot pkg case r of Found loc _ -- Home package: just depend on the .hi or hi-boot file ===================================== compiler/GHC/HsToCore.hs ===================================== @@ -106,7 +106,7 @@ import GHC.Unit.Module.Deps import Data.List (partition) import Data.IORef import GHC.Types.Unique.FM -import GHC.Iface.Load (KnownEntitySource(..), lookupKnownKeyName, lookupKnownKeysModule) +import GHC.Iface.Load (KnownEntitySource(..), lookupKnownKeyName, essentialsUnitId) import GHC.HsToCore.Types (DsGblEnv(..)) {- @@ -228,12 +228,12 @@ deSugar hsc_env ; let pluginModules = map lpModule (loadedPlugins (hsc_plugins hsc_env)) home_unit = hsc_home_unit hsc_env - ; essentials_mod <- liftIO $ lookupKnownKeysModule hsc_env dflags + ; essentials_uid <- liftIO $ essentialsUnitId hsc_env dflags ; let deps = mkDependencies home_unit (tcg_mod tcg_env) (tcg_imports tcg_env) (map mi_module pluginModules) - (moduleUnitId <$> essentials_mod) + essentials_uid ; safe_mode <- finalSafeMode dflags tcg_env ===================================== compiler/GHC/Iface/Errors/Ppr.hs ===================================== @@ -210,7 +210,7 @@ cantFindErrorX pkg_hidden_hint may_show_locations mod_or_interface (CantFindInst -- package flags when making suggestions. ToDo: if the original package -- also has a reexport, prefer that one pp_sugg (SuggestVisible m mod o) = ppr m <+> provenance o - where provenance ModHidden = empty + where provenance (ModHidden {}) = empty provenance (ModUnusable _) = empty provenance (ModOrigin{ fromOrigUnit = e, fromExposedReexport = res, @@ -227,7 +227,7 @@ cantFindErrorX pkg_hidden_hint may_show_locations mod_or_interface (CantFindInst <+> ppr mod) | otherwise = empty pp_sugg (SuggestHidden m mod o) = ppr m <+> provenance o - where provenance ModHidden = empty + where provenance (ModHidden {}) = empty provenance (ModUnusable _) = empty provenance (ModOrigin{ fromOrigUnit = e, fromHiddenReexport = rhs }) @@ -261,7 +261,7 @@ cantFindErrorX pkg_hidden_hint may_show_locations mod_or_interface (CantFindInst where pprMod (m, o) = text "it is bound as" <+> ppr m <+> text "by" <+> pprOrigin m o - pprOrigin _ ModHidden = panic "cantFindErr: bound by mod hidden" + pprOrigin _ (ModHidden {}) = panic "cantFindErr: bound by mod hidden" pprOrigin _ (ModUnusable _) = panic "cantFindErr: bound by mod unusable" pprOrigin m (ModOrigin e res _ f) = sep $ punctuate comma ( if e == Just True ===================================== compiler/GHC/Iface/Load.hs ===================================== @@ -24,7 +24,7 @@ module GHC.Iface.Load ( lookupKnownKeyThing, lookupKnownKeyName, lookupKnownOccThing, lookupKnownOccName, loadKnownKeyOccMaps, lookupKnownGRE, - lookupKnownKeysMap, lookupKnownKeysModule, + lookupKnownKeysMap, essentialsUnitId, -- RnM/TcM functions loadModuleInterface, loadModuleInterfaces, @@ -302,13 +302,14 @@ loadKnownKeyOccMaps -- We don't have a KnownKeyOccMap yet, so create it -- from the interface file for KnownKeyName do { hsc_env <- getTopEnv - ; mb_res <- liftIO $ findImportedModule hsc_env eSSENTIALS_NAME NoPkgQual - ; case mb_res of - Found _ mod -> Succeeded <$> build_maps mod - fr -> return (Failed (CantFindEssentials - (cannotFindModule hsc_env eSSENTIALS_NAME fr) - UnknownLoadEssentialsReason)) - } } } + ; res <- liftIO $ getEssentialsModule hsc_env + ; case res of + Succeeded mod -> Succeeded <$> build_maps mod + Failed err -> + return $ Failed $ + CantFindEssentials err UnknownLoadEssentialsReason + }}} + where doc = text "Need interface for KnownKeyNames" @@ -372,23 +373,39 @@ checkKnownKeyNamesIface known_key_names_occ_map Just name -> getOccName name /= occ #endif --- | Lookup the module exporting the canonical known-entities definitions (GHC.Essentials) -lookupKnownKeysModule :: HscEnv -> DynFlags {-^ Module dyn flags -} -> IO (Maybe Module) -lookupKnownKeysModule hsc_env dflags = do - eps <- hscEPS hsc_env - case eps_known_keys eps of - Just (_, kk_mod) -> return (Just kk_mod) - Nothing -> do - found_essentials <- findImportedModule hsc_env eSSENTIALS_NAME NoPkgQual - let rebindable_kn = gopt Opt_RebindableKnownNames dflags - let essentials_uid - | rebindable_kn = return Nothing - | Found _ mod <- found_essentials = return (Just mod) - | fr <- found_essentials = do - throwOneError (initSourceErrorContext dflags) $ - mkPlainErrorMsgEnvelope noSrcSpan $ GhcDriverMessage $ DriverInterfaceError $ - CantFindEssentials (cannotFindModule hsc_env eSSENTIALS_NAME fr) LookingForEssentialsModule - essentials_uid +-- | Identify the 'GHC.Essentials' module to use. +getEssentialsModule :: HscEnv -> IO (MaybeErr MissingInterfaceError Module) +getEssentialsModule hsc_env + = do { fr <- findEssentialsModule hsc_env + ; return $ case fr of + Found _ mod -> Succeeded mod + _ -> Failed $ cannotFindModule hsc_env eSSENTIALS_NAME fr } + +-- | Find the unit that provides the 'GHC.Essentials' module that is +-- implicitly depended on. +-- +-- 'Nothing' when @-frebindable-known-names@ is on, as in that case there is +-- no implicit dependency. +-- +-- See Note [Finding GHC.Essentials] in GHC.Builtin. +essentialsUnitId :: HscEnv -> DynFlags {-^ Module dyn flags -} -> IO (Maybe UnitId) +essentialsUnitId hsc_env dflags + | gopt Opt_RebindableKnownNames dflags + = return Nothing + | otherwise + = do { eps <- hscEPS hsc_env + ; case eps_known_keys eps of + -- We already resolved it: re-use the cached value. + Just (_, kk_mod) -> return (Just (moduleUnitId kk_mod)) + Nothing -> + do { res <- getEssentialsModule hsc_env + ; case res of + Succeeded mod -> return (Just (moduleUnitId mod)) + Failed err -> + throwOneError (initSourceErrorContext dflags) $ + mkPlainErrorMsgEnvelope noSrcSpan $ + GhcDriverMessage $ DriverInterfaceError $ + CantFindEssentials err LookingForEssentialsModule } } {- ********************************************************************* * * ===================================== compiler/GHC/Iface/Make.hs ===================================== @@ -244,12 +244,12 @@ mkIfaceTc hsc_env safe_mode mod_details mod_summary mb_program mb_modBreaks = do let pluginModules = map lpModule (loadedPlugins (hsc_plugins hsc_env)) let home_unit = hsc_home_unit hsc_env let dflags = ms_hspp_opts mod_summary - essentials_mod <- liftIO $ lookupKnownKeysModule hsc_env dflags + essentials_uid <- liftIO $ essentialsUnitId hsc_env dflags let deps = mkDependencies home_unit (tcg_mod tc_result) (tcg_imports tc_result) (map mi_module pluginModules) - (moduleUnitId <$> essentials_mod) + essentials_uid usage <- mkRecompUsageInfo hsc_env tc_result docs <- extractDocs dflags tc_result ===================================== compiler/GHC/Iface/Recomp.hs ===================================== @@ -638,7 +638,8 @@ checkMergedSignatures hsc_env mod_summary self_recomp = do checkDependencies :: HscEnv -> ModSummary -> ModIface -> IfG RecompileRequired checkDependencies hsc_env summary iface = do - res_normal <- classify_import (findImportedModule hsc_env) + -- See (FindEssentials2) in Note [Finding GHC.Essentials] in GHC.Builtin. + res_normal <- classify_import (\mod pkg -> findModuleWithIsBoot hsc_env mod NotBoot pkg) ([(st, p, m) | (st, p, m) <- (ms_textual_imps summary)] ++ [(NormalLevel, NoPkgQual, m) | m <- ms_srcimps summary ]) ===================================== compiler/GHC/Unit/External.hs ===================================== @@ -156,6 +156,12 @@ data ExternalPackageState eps_known_keys :: Maybe (KnownKeyNameMaps, Module), -- ^ See Note [Overview of known entities]. -- Caches the 'Module' where known entities are defined. + -- + -- BEWARE: there is a single 'ExternalPackageState' for + -- the whole session, so this caches a single 'GHC.Essentials' + -- for all home units. If two home units are compiled + -- against two different units both providing GHC.Essentials, + -- whichever is resolved first will be used for both. eps_inst_env :: !PackageInstEnv, -- ^ The total 'InstEnv' accumulated -- from all the external-package modules ===================================== compiler/GHC/Unit/Finder.hs ===================================== @@ -14,7 +14,8 @@ module GHC.Unit.Finder ( FinderCache(..), initFinderCache, findImportedModule, - findImportedModuleWithIsBoot, + findModuleWithIsBoot, + findEssentialsModule, findPluginModule, findExactModule, findHomeModule, @@ -43,6 +44,7 @@ import GHC.Data.OsPath import GHC.Unit.Env import GHC.Unit.Types +import GHC.Builtin.Modules( eSSENTIALS_NAME ) import GHC.Unit.Module import GHC.Unit.Module.Graph ( @@ -191,11 +193,45 @@ findImportedModule hsc_env mod pkg_qual = let home_module_name_providers_map = mgHomeModuleNameProvidersMap (hsc_mod_graph hsc_env) findImportedModuleNoHsc fc fopts (hsc_unit_env hsc_env) home_module_name_providers_map mb_home_unit mod pkg_qual -findImportedModuleWithIsBoot :: HscEnv -> ModuleName -> IsBootInterface -> PkgQual -> IO FindResult -findImportedModuleWithIsBoot hsc_env mod is_boot pkg_qual = do - res <- findImportedModule hsc_env mod pkg_qual - case (res, is_boot) of - (Found loc mod, IsBoot) -> return (Found (addBootSuffixLocn loc) mod) +-- | Resolve a 'ModuleName' into a 'Module'. +-- +-- Use this wherever GHC resolves a module's dependencies. +-- +-- Resolving a user-written import must use 'findImportedModule' instead. +findModuleWithIsBoot :: HscEnv -> ModuleName -> IsBootInterface -> PkgQual -> IO FindResult +findModuleWithIsBoot hsc_env mod_name is_boot pkg_qual + -- Allow GHC.Essentials to be found even when it is hidden. + -- See (FindEssentials1) in Note [Finding GHC.Essentials] in GHC.Builtin. + | mod_name == eSSENTIALS_NAME + , NotBoot <- is_boot + = findEssentialsModule hsc_env + | otherwise + = do res <- findImportedModule hsc_env mod_name pkg_qual + case (res, is_boot) of + (Found loc mod, IsBoot) -> return (Found (addBootSuffixLocn loc) mod) + _ -> return res + +-- | Find 'GHC.Essentials' (allowing it to be a hidden module of its unit). +-- +-- See Note [Finding GHC.Essentials] in GHC.Builtin. +findEssentialsModule :: HscEnv -> IO FindResult +findEssentialsModule hsc_env = do + res <- findImportedModule hsc_env eSSENTIALS_NAME NoPkgQual + case res of + NotFound {} + | Just mod <- lookupModuleEvenIfHidden (hsc_units hsc_env) eSSENTIALS_NAME + -> do let im = fst (getModuleInstantiation mod) + r <- findExactModule hsc_env im NotBoot + return $ case r of + InstalledFound loc -> Found loc mod + InstalledNoPackage _ -> NoPackage (moduleUnit mod) + InstalledNotFound fps _ -> + NotFound { fr_paths = fmap unsafeDecodeUtf fps + , fr_pkg = Just (moduleUnit mod) + , fr_pkgs_hidden = [] + , fr_mods_hidden = [] + , fr_unusables = [] + , fr_suggestions = [] } _ -> return res findImportedModuleNoHsc ===================================== compiler/GHC/Unit/State.hs ===================================== @@ -32,12 +32,14 @@ module GHC.Unit.State ( listVisibleModuleNames, lookupModuleInAllUnits, lookupModuleWithSuggestions, + lookupModuleEvenIfHidden, lookupModulePackage, lookupPluginModuleWithSuggestions, requirementMerges, LookupResult(..), ModuleSuggestion(..), ModuleOrigin(..), + HiddenModuleUnit(..), UnusableUnit(..), UnusableUnitReason(..), pprReason, @@ -81,6 +83,7 @@ import GHC.Platform.Ways import GHC.Unit.Database import GHC.Unit.Info import GHC.Unit.Ppr +import GHC.Builtin.Modules( eSSENTIALS_NAME ) import GHC.Unit.Types import GHC.Unit.Module import GHC.Unit.Home @@ -168,10 +171,8 @@ import Control.Applicative -- it could have come into scope. Warning: don't use the record functions, -- they're partial! data ModuleOrigin = - -- | Module is hidden, and thus never will be available for import. - -- (But maybe the user didn't realize), so we'll still keep track - -- of these modules.) - ModHidden + -- | The module is hidden (thus not available for a user-written import). + ModHidden !HiddenModuleUnit -- | Module is unavailable because the unit is unusable. | ModUnusable !UnusableUnit @@ -193,6 +194,11 @@ data ModuleOrigin = , fromPackageFlag :: Bool } +-- | Is the unit providing a hidden module itself visible in this compilation? +data HiddenModuleUnit + = HiddenModInVisibleUnit + | HiddenModInHiddenUnit + -- | A unusable unit module origin data UnusableUnit = UnusableUnit { uuUnit :: !Unit -- ^ Unusable unit @@ -201,7 +207,7 @@ data UnusableUnit = UnusableUnit } instance Outputable ModuleOrigin where - ppr ModHidden = text "hidden module" + ppr (ModHidden {}) = text "hidden module" ppr (ModUnusable _) = text "unusable module" ppr (ModOrigin e res rhs f) = sep (punctuate comma ( (case e of @@ -255,7 +261,7 @@ instance Monoid ModuleOrigin where -- | Is the name from the import actually visible? (i.e. does it cause -- ambiguity, or is it only relevant when we're making suggestions?) originVisible :: ModuleOrigin -> Bool -originVisible ModHidden = False +originVisible (ModHidden {}) = False originVisible (ModUnusable _) = False originVisible (ModOrigin b res _ f) = b == Just True || not (null res) || f @@ -1819,7 +1825,11 @@ mkModuleNameProvidersMap logger cfg pkg_map vis_map = esmap = listToUFM (es False) -- parameter here doesn't matter, orig will -- be overwritten - hiddens = [(m, mkModMap pk m ModHidden) | m <- hidden_mods] + hiddens = [(m, mkModMap pk m (ModHidden hidden_mod_unit)) | m <- hidden_mods] + + hidden_mod_unit + | b || not (null rns) = HiddenModInVisibleUnit + | otherwise = HiddenModInHiddenUnit pk = mkUnit pkg unit_lookup uid = lookupUnit' (unitConfigAllowVirtual cfg) pkg_map uid @@ -1940,8 +1950,36 @@ lookupModulePackage pkgs mn mfs = _ -> Nothing + -- If we implicitly depend on GHC.Essentials, mark the unit providing it + -- as used. See (FindEssentials4) in Note [Finding GHC.Essentials] in GHC.Builtin. + LookupHidden {} + | mn == eSSENTIALS_NAME + -> (\m -> [m]) <$> (lookupUnit pkgs . moduleUnit =<< lookupModuleEvenIfHidden pkgs mn) + _ -> Nothing +-- | Look up the module of this name provided by a /visible/ unit, even when +-- that module is hidden, i.e. is not in its unit's @exposed-modules@. +-- +-- This consults unit metadata only. Unlike "GHC.Unit.Finder", it does not +-- look for the module's interface file on disk, so it can answer \"which unit +-- provides this module?\" without requiring that unit to have been built yet. +-- +-- An exposed module always takes precedence over a hidden one, and a module +-- of a hidden unit is never returned. +lookupModuleEvenIfHidden :: UnitState -> ModuleName -> Maybe Module +lookupModuleEvenIfHidden pkgs mod_name = + case lookupModuleWithSuggestions pkgs mod_name NoPkgQual of + LookupFound m _ -> Just m + LookupHidden _ mods_hidden + | [m] <- [ m | (m, ModHidden HiddenModInVisibleUnit) <- mods_hidden ] + -> Just m + | otherwise + -> Nothing + LookupMultiple {} -> Nothing + LookupUnusable {} -> Nothing + LookupNotFound {} -> Nothing + lookupPluginModuleWithSuggestions :: UnitState -> ModuleName -> PkgQual @@ -1970,7 +2008,7 @@ lookupModuleWithSuggestions' pkgs mod_map name mb_pn let origin = filterOrigin mb_pn (mod_unit m) origin0 x = (m, origin) in case origin of - ModHidden + ModHidden {} -> (hidden_pkg, x:hidden_mod, unusable, exposed) ModUnusable _ -> (hidden_pkg, hidden_mod, x:unusable, exposed) @@ -2003,8 +2041,8 @@ lookupModuleWithSuggestions' pkgs mod_map name mb_pn filterOrigin (OtherPkg u) pkg o = let match_pkg p = u == unitId p in case o of - ModHidden - | match_pkg pkg -> ModHidden + ModHidden {} + | match_pkg pkg -> o | otherwise -> mempty ModUnusable _ | match_pkg pkg -> o ===================================== libraries/base/base.cabal.in ===================================== @@ -219,7 +219,6 @@ Library , GHC.Integer.Logarithms , GHC.IsList , GHC.Ix - , GHC.Essentials , GHC.List , GHC.Maybe , GHC.MVar @@ -307,6 +306,7 @@ Library other-modules: Data.List.NubOrdSet + GHC.Essentials System.CPUTime.Unsupported System.CPUTime.Utils if os(windows) ===================================== testsuite/tests/interface-stability/base-exports.stdout ===================================== @@ -5295,10 +5295,6 @@ module GHC.Err where errorWithoutStackTrace :: forall (r :: GHC.Internal.Types.RuntimeRep) (a :: TYPE r). [GHC.Internal.Types.Char] -> a undefined :: forall (r :: GHC.Internal.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => a -module GHC.Essentials where - --- ignored - module GHC.Event where -- Safety: Safe ===================================== testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs ===================================== @@ -5295,10 +5295,6 @@ module GHC.Err where errorWithoutStackTrace :: forall (r :: GHC.Internal.Types.RuntimeRep) (a :: TYPE r). [GHC.Internal.Types.Char] -> a undefined :: forall (r :: GHC.Internal.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => a -module GHC.Essentials where - --- ignored - module GHC.Event where -- Safety: Safe ===================================== testsuite/tests/interface-stability/base-exports.stdout-mingw32 ===================================== @@ -5340,10 +5340,6 @@ module GHC.Err where errorWithoutStackTrace :: forall (r :: GHC.Internal.Types.RuntimeRep) (a :: TYPE r). [GHC.Internal.Types.Char] -> a undefined :: forall (r :: GHC.Internal.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => a -module GHC.Essentials where - --- ignored - module GHC.Event.TimeOut where -- Safety: None ===================================== utils/dump-decls/Main.hs ===================================== @@ -68,7 +68,6 @@ ignoredModules = map mkModuleName $ concat [ unstableModules , platformDependentModules - , internalModules ] where unstableModules = @@ -81,8 +80,6 @@ ignoredModules = , "GHC.Num.Backend" , "GHC.Num.Backend.Selected" ] - internalModules = - [ "GHC.Essentials" ] ignoredOccNames :: [OccName] ignoredOccNames = View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/1575eb10deeedd07a263d476e37d33ad... -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/1575eb10deeedd07a263d476e37d33ad... You're receiving this email because of your account on gitlab.haskell.org. Manage all notifications: https://gitlab.haskell.org/-/profile/notifications | Help: https://gitlab.haskell.org/help