GitLab

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:

@@ -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

No preview for this file type

testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs

No preview for this file type

testsuite/tests/interface-stability/base-exports.stdout-mingw32

No preview for this file type

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 =