This is a big reason for (KnownOccNameInvariant): an export list cannot have two

   entities with the same OccName.

 * There are three flags that control the treatment of known entities:

     -frebindable-known-names

 * 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 )`.

 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

     `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`).

 -}

 {-

 import GHC.Types.PkgQual

 import GHC.Types.Basic

 import GHC.Unit

 import GHC.Unit.Env

 import GHC.Unit.Finder

     -- happen relative to it

     hsc_env   = hscSetActiveHomeUnit home_unit hsc_env'

     find_it = do

         case found of

              Found location mod

                 | moduleUnitId mod `Set.member` hsc_all_home_unit_ids hsc_env ->

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

                   provenance (ModUnusable _) = empty

                   provenance (ModOrigin{ fromOrigUnit = e,

                                          fromExposedReexport = res,

                           <+> ppr mod)

                     | otherwise = empty

           pp_sugg (SuggestHidden m mod o) = ppr m <+> provenance o

                   provenance (ModUnusable _) = empty

                   provenance (ModOrigin{ fromOrigUnit = e,

                                          fromHiddenReexport = rhs })

   where

     pprMod (m, o) = text "it is bound as" <+> ppr m <+>

                                 text "by" <+> pprOrigin m o

     pprOrigin _ (ModUnusable _) = panic "cantFindErr: bound by mod unusable"

     pprOrigin m (ModOrigin e res _ f) = sep $ punctuate comma (

       if e == Just True

     -- We don't have a KnownKeyOccMap yet, so create it

     -- from the interface file for KnownKeyName

     do { hsc_env <- getTopEnv

   where

     doc = text "Need interface for KnownKeyNames"

 -- | Lookup the module exporting the canonical known-entities definitions (GHC.Essentials)

 lookupKnownKeysModule :: HscEnv -> DynFlags {-^ Module dyn flags -} -> IO (Maybe Module)

 {- *********************************************************************

 *                                                                      *

                 convImport (L _ (i :: ImportDecl GhcPs))     = (convImportLevel (ideclLevelSpec i), ideclPkgQual i, reLoc $ ideclName i)

                 convImport_src (L _ (i :: ImportDecl GhcPs)) = (reLoc $ ideclName i)

                   | rebindable_kn = []

                   | otherwise = [(NormalLevel, NoRawPkgQual, noLoc eSSENTIALS_NAME)]

               in

     FinderCache(..),

     initFinderCache,

     findImportedModule,

     findImportedModuleWithIsBoot,

     findPluginModule,

     findExactModule,

   return hash

 -- -----------------------------------------------------------------------------

 -- | Locate a module that was imported by the user.  We have the

 -- module's name, and possibly a package name.  Without a package

 -- name, this function will use the search path and the known exposed

 -- packages to find the module, if a package is specified then only

 -- that package is searched for the module.

 findImportedModule :: HscEnv -> ModuleName -> PkgQual -> IO FindResult

   let fc           = hsc_FC hsc_env

       mb_home_unit = hsc_home_unit_maybe hsc_env

       dflags       = hsc_dflags hsc_env

       fopts        = initFinderOpts dflags

   in do

     let home_module_name_providers_map = mgHomeModuleNameProvidersMap (hsc_mod_graph hsc_env)

 findImportedModuleWithIsBoot :: HscEnv -> ModuleName -> IsBootInterface -> PkgQual -> IO FindResult

 findImportedModuleWithIsBoot hsc_env mod is_boot pkg_qual = do

     _ -> return res

 findImportedModuleNoHsc

   -> FinderOpts

   -> UnitEnv

   -> HomeModuleNameProvidersMap

   -> ModuleName

   -> PkgQual

   -> IO FindResult

   case mb_pkg of

     NoPkgQual  -> unqual_import

     ThisPkg uid | (homeUnitId <$> mb_home_unit) == Just uid -> home_import

                           NoPackage (panic "findImportedModule: no home-unit")

     home_pkg_import :: (UnitId, FinderOpts) -> IO FindResult

     pkg_import :: IO FindResult

     unqual_import :: IO FindResult

                         home_module_name_providers_map mb_home_unit mod_name

     unit_state :: UnitState

   -> ModuleName

   -> IO FindResult

 findPluginModuleNoHsc fc fopts ue home_module_name_providers_map mb_home_unit@(Just home_unit) mod_name =

                             mb_home_unit mod_name

     `orIfNotFound`

     findExposedPluginPackageModule fc fopts unit_state mod_name

 -- | Search for @mod_name@ in the given home unit.

 findHomeUnitDepModule

   -> UnitEnv

   -> HomeModuleNameProvidersMap

   -> ModuleName

   -> (UnitId, FinderOpts)

   -> IO FindResult

     -- If the module is reexported, then look for it as if it was from the

     -- perspective of the package which reexports it.

     | Just real_mod_name

           <- lookupUniqMap (finder_reexportedModules opts) mod_name

               (Just $ DefiniteHomeUnit uid Nothing)

               real_mod_name

         = return (mkHomeHidden uid)

     | otherwise

         = findHomePackageModule fc opts uid mod_name

 -- reexports along the way (see 'findHomeUnitDepModule'). Yields the first

 -- successful result.

 findHomeModuleAmongDeps

   -> FinderOpts

   -> UnitEnv

   -> HomeModuleNameProvidersMap

   -> Maybe HomeUnit

   -> ModuleName

   -> IO FindResult

     foldr1 orIfNotFound (home_import :| map home_pkg_import other_fopts)

     -- Do not try to be smart and change this to `foldr orIfNotFound home_import

     -- (map home_pkg_import other_fopts)`, as that would not be the same.

         Just home_unit -> findHomeModule fc fopts home_unit mod_name

         Nothing        -> pure $

                           NoPackage (panic "findHomeModuleAmongDeps: no home-unit")

     unit_state = case homeUnitId <$> mb_home_unit of

         Nothing           -> ue_homeUnitState ue

 -- | Search the home-unit graph and otherwise the regular exposed package

 -- database.

 findHomeOrRegularPackageModule

   -> FinderOpts

   -> UnitEnv

   -> HomeModuleNameProvidersMap

   -> Maybe HomeUnit

   -> ModuleName

   -> IO FindResult

                             mb_home_unit mod_name

     `orIfNotFound`

   where

     unit_state = case homeUnitId <$> mb_home_unit of

         Nothing           -> ue_homeUnitState ue

   modLocationCache fc mod do_this

 findExposedPackageModule :: FinderCache -> FinderOpts -> UnitState -> ModuleName -> PkgQual -> IO FindResult

     $ lookupModuleWithSuggestions units mod_name mb_pkg

 findExposedPluginPackageModule :: FinderCache -> FinderOpts -> UnitState -> ModuleName -> IO FindResult

 findExposedPluginPackageModule fc fopts units mod_name =

     $ lookupPluginModuleWithSuggestions units mod_name NoPkgQual

      LookupMultiple rs ->

        return (FoundMultiple rs)

                        , fr_pkgs_hidden

                        , fr_mods_hidden = map (moduleUnit.fst) mod_hiddens

                        , fr_unusables = []

                        , fr_mods_hidden = []

                        , fr_unusables = []

                        , fr_suggestions = suggest' })

 modLocationCache :: FinderCache -> InstalledModule -> IO InstalledFindResult -> IO InstalledFindResult

 modLocationCache fc mod do_this = do

         LookupResult(..),

         ModuleSuggestion(..),

         ModuleOrigin(..),

         UnusableUnit(..),

         UnusableUnitReason(..),

         pprReason,

 -- it could have come into scope.  Warning: don't use the record functions,

 -- they're partial!

 data ModuleOrigin =

     -- | Module is unavailable because the unit is unusable.

   | ModUnusable !UnusableUnit

       , fromPackageFlag :: Bool

       }

 -- | A unusable unit module origin

 data UnusableUnit = UnusableUnit

   { uuUnit        :: !Unit               -- ^ Unusable unit

   }

 instance Outputable ModuleOrigin where

     ppr (ModUnusable _) = text "unusable module"

     ppr (ModOrigin e res rhs f) = sep (punctuate comma (

         (case e of

 -- | 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 (ModUnusable _) = False

 originVisible (ModOrigin b res _ f) = b == Just True || not (null res) || f

     esmap = listToUFM (es False) -- parameter here doesn't matter, orig will

                                  -- be overwritten

     pk = mkUnit pkg

     unit_lookup uid = lookupUnit' (unitConfigAllowVirtual cfg) pkg_map uid

       let origin = filterOrigin mb_pn (mod_unit m) origin0

           x = (m, origin)

       in case origin of

             -> (hidden_pkg, x:hidden_mod, unusable, exposed)

           ModUnusable _

             -> (hidden_pkg, hidden_mod, x:unusable, exposed)

     filterOrigin (OtherPkg u) pkg o =

       let match_pkg p = u == unitId p

       in case o of

             | otherwise     -> mempty

           ModUnusable _

             | match_pkg pkg -> o

         , GHC.Integer.Logarithms

         , GHC.IsList

         , GHC.Ix

         , GHC.List

         , GHC.Maybe

         , GHC.MVar

     other-modules:

         Data.List.NubOrdSet

         System.CPUTime.Unsupported

         System.CPUTime.Utils

     if os(windows)

     map mkModuleName $ concat

     [ unstableModules

     , platformDependentModules

     ]

   where

     unstableModules =

         , "GHC.Num.Backend"

         , "GHC.Num.Backend.Selected"

         ]

 ignoredOccNames :: [OccName]

 ignoredOccNames =