-- Synthesize the flags

             , packageFlags = packageFlags dflags ++ map (\(uid0, rn) ->

               let uid = unwireUnit unit_state

                         $ renameHoleUnit unit_state (listToUFM insts) uid0

               in ExposePackage

                 (showSDoc dflags

             TcSession -> return ()

             _ -> compileInclude (length deps0) (i, dep)

     mb_old_eps <- case session of

                     TcSession -> fmap Just getEpsGhc

               && not (isOneShot (ghcMode dflags))

             then return (Failed (HomeModError mod loc))

             else do

                 case r of

                   Failed err

                     -> return (Failed $ BadIfaceFile err)

                   Succeeded (iface,_fp)

                     -> do

                                                  (setDynamicNow dflags) wanted_mod

                                                  iface loc

                         case r2 of

                               err

 -- | Check if we need to try the dynamic interface for -dynamic-too

                        -> Module -> ModIface -> ModLocation

                        -> IO (MaybeErr MissingInterfaceError ())

   -- Indefinite interfaces are ALWAYS non-dynamic.

   | not (moduleIsDefinite (mi_module iface)) = return (Succeeded ())

   | otherwise = return (Succeeded ())

                  -> Module -> ModIface -> ModLocation

                  -> IO (MaybeErr MissingInterfaceError ())

     Succeeded (dynIface, _)

      | mi_mod_hash iface == mi_mod_hash dynIface

      -> return (Succeeded ())

           -> Module -> FilePath

           -> IO (MaybeErr ReadInterfaceError (ModIface, FilePath))

   -- Figure out what is recorded in mi_module.  If this is

   -- a fully definite interface, it'll match exactly, but

         case getModuleInstantiation wanted_mod of

             (_, Nothing) -> wanted_mod

             (_, Just indef_mod) ->

                 (uninstantiateInstantiatedModule indef_mod)

   read_result <- readIface hooks logger dflags name_cache wanted_mod' file_path

   case read_result of

         new_merged = case lookupUniqMap (requirementContext unit_state)

                           (ms_mod_name mod_summary) of

                         Nothing -> []

     if old_merged == new_merged

         then up_to_date logger (text "signatures to merge in unchanged" $$ ppr new_merged)

         else return $ needsRecompileBecause SigsMergeChanged

       (i.e. GHC doesn't correctly call `pprWithUnitState` before pretty-printing a

       UnitId), that's what will be shown to the user so it's no big deal.

 Note [Representation of module/name variables]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 In our ICFP'16, we use <A> to represent module holes, and {A.T} to represent

         -- * Reading the package config, and processing cmdline args

         UnitState(..),

         UnitDatabase (..),

         UnitErr (..),

         emptyUnitState,

         lookupPackageName,

         resolvePackageImport,

         searchPackageId,

         listVisibleModuleNames,

         lookupModuleInAllUnits,

 originEmpty (ModOrigin Nothing [] [] False) = True

 originEmpty _ = False

 -- | 'UniqFM' map from 'Unit' to a 'UnitVisibility'.

 type VisibilityMap = UniqMap Unit UnitVisibility

   -- may have the 'exposed' flag be 'False'.)

   unitInfoMap :: UnitInfoMap,

   -- | A mapping of 'PackageName' to 'UnitId'. If several units have the same

   -- package name (e.g. different instantiations), then we return one of them...

   -- This is used when users refer to packages in Backpack includes.

 emptyUnitState :: UnitState

 emptyUnitState = UnitState {

     unitInfoMap    = emptyUniqMap,

     packageNameMap = emptyUFM,

     wireMap        = emptyUniqMap,

     unwireMap      = emptyUniqMap,

 -- | Find the unit we know about with the given unit, if any

 lookupUnit :: UnitState -> Unit -> Maybe UnitInfo

 -- | A more specialized interface, which doesn't require a 'UnitState' (so it

 -- can be used while we're initializing 'DynFlags')

 -- Parameters:

 --    * a boolean specifying whether or not to look for on-the-fly renamed interfaces

 --    * a 'UnitInfoMap'

    HoleUnit   -> error "Hole unit"

    RealUnit i -> lookupUniqMap pkg_map (unDefinite i)

    VirtUnit i

       | allowOnTheFlyInst

       -> -- lookup UnitInfo of the indefinite unit to be instantiated and

          -- instantiate it on-the-fly

            (lookupUniqMap pkg_map (instUnitInstanceOf i))

       | otherwise

 applyPackageFlag

    :: UnitPrecedenceMap

    -> UnitInfoMap

    -> UnusableUnits

    -> Bool -- if False, if you expose a package, it implicitly hides

            -- any previously exposed packages with the same name

    -> PackageFlag             -- flag to apply

    -> MaybeErr UnitErr VisibilityMap -- Now exposed

   case flag of

     ExposePackage _ arg (ModRenaming b rns) ->

          Left ps     -> Failed (PackageFlagErr flag ps)

          Right (p:_) -> Succeeded vm'

           where

          _ -> panic "applyPackageFlag"

     HidePackage str ->

          Left ps  -> Failed (PackageFlagErr flag ps)

          Right ps -> Succeeded $ foldl' delFromUniqMap vm (map mkUnit ps)

 -- if the 'UnitArg' has a renaming associated with it.

 findPackages :: UnitPrecedenceMap

              -> UnitInfoMap

              -> PackageArg -> [UnitInfo]

              -> UnusableUnits

              -> Either [(UnitInfo, UnusableUnitReason)]

                 [UnitInfo]

   = let ps = mapMaybe (finder arg) pkgs

     in if null ps

         then Left (mapMaybe (\(x,y) -> finder arg x >>= \x' -> return (x',y))

             -> Just p

           VirtUnit inst

             | instUnitInstanceOf inst == unitId p

           _ -> Nothing

 selectPackages :: UnitPrecedenceMap -> PackageArg -> [UnitInfo]

         else Right (sortByPreference prec_map ps, rest)

 -- | Rename a 'UnitInfo' according to some module instantiation.

     let hsubst = listToUFM insts

         new_insts = map (\(k,v) -> (k,smod v)) (unitInstantiations conf)

     in conf {

         unitInstantiations = new_insts,

   -- user tries to enable an unusable package, we should let them know.

   --

   vis_map2 <- mayThrowUnitErr

                         (unitConfigHideAll cfg) pkgs1)

                             vis_map1 other_flags

                         | otherwise = vis_map2

                 plugin_vis_map2

                     <- mayThrowUnitErr

                                 hide_plugin_pkgs pkgs1)

                              plugin_vis_map1

                              (reverse (unitConfigFlagsPlugins cfg))

                     $ closeUnitDeps pkg_db

                     $ zip (map toUnitId preload3) (repeat Nothing)

       mod_map2 = mkUnusableModuleNameProvidersMap unusable

       mod_map = mod_map2 `plusUniqMap` mod_map1

          , explicitUnits                = explicit_pkgs

          , homeUnitDepends              = home_unit_deps

          , unitInfoMap                  = pkg_db

          , moduleNameProvidersMap       = mod_map

          , packageNameMap               = pkgname_map

          , wireMap                      = wired_map

          , unwireMap                    = listToUniqMap [ (v,k) | (k,v) <- nonDetUniqMapToList wired_map ]

   :: Logger

   -> UnitConfig

   -> UnitInfoMap

   -> VisibilityMap

   -> ModuleNameProvidersMap

     -- What should we fold on?  Both situations are awkward:

     --

     --    * Folding on the visibility map means that we won't create

     hiddens = [(m, mkModMap pk m ModHidden) | m <- hidden_mods]

     pk = mkUnit pkg

                         `orElse` pprPanic "unit_lookup" (ppr uid)

     exposed_mods = unitExposedModules pkg

    where

       PackageName fs = unitPackageName info

 -- | Check the database to see if we already have an installed unit that

 -- corresponds to the given 'InstantiatedUnit'.

 --

 -- references a matching installed unit.

 --

 -- See Note [VirtUnit to RealUnit improvement]

     -- NB: suppose that we want to compare the instantiated

     -- unit p[H=impl:H] against p+abcd (where p+abcd

     -- happens to be the existing, installed version of

     -- p[H=impl:H].  If we *only* wrap in p[H=impl:H]

     -- VirtUnit, they won't compare equal; only

     -- after improvement will the equality hold.

 -- | Substitution on module variables, mapping module names to module

 -- @p[A=\<A>]:B@ maps to @p[A=q():A]:B@ with @A=q():A@;

 -- similarly, @\<A>@ maps to @q():A@.

 renameHoleModule :: UnitState -> ShHoleSubst -> Module -> Module

 -- | Substitutes holes in a 'Unit', suitable for renaming when

 -- an include occurs; see Note [Representation of module/name variables].

 --

 -- @p[A=\<A>]@ maps to @p[A=\<B>]@ with @A=\<B>@.

 renameHoleUnit :: UnitState -> ShHoleSubst -> Unit -> Unit

 -- so it can be used by "GHC.Unit.State".

   | not (isHoleModule m) =

         in mkModule uid (moduleName m)

   | Just m' <- lookupUFM env (moduleName m) = m'

   -- NB m = <Blah>, that's what's in scope.

   | otherwise = m

 -- so it can be used by "GHC.Unit.State".

     case uid of

       (VirtUnit

         InstantiatedUnit{ instUnitInstanceOf = cid

           -> if isNullUFM (intersectUFM_C const (udfmToUfm (getUniqDSet fh)) env)

                 then uid

                 -- Functorially apply the substitution to the instantiation,

                 -- a compiled version of this 'InstantiatedUnit' we can improve to.

                 -- See Note [VirtUnit to RealUnit improvement]

       _ -> uid

 -- | Injects an 'InstantiatedModule' to 'Module' (see also

 -- 'instUnitToUnit'.

 -- | Print unit-ids with UnitInfo found in the given UnitState

 pprWithUnitState :: UnitState -> SDoc -> SDoc