-- Synthesize the flags

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

               let uid = unwireUnit unit_state

                         $ renameHoleUnit unit_state (listToUFM insts) uid0

               in ExposePackage

                 (showSDoc dflags

     -- The compilation dependencies are just the appropriately filled

     -- in unit IDs which must be compiled before we can compile.

     let hsubst = listToUFM insts

     -- Build dependencies OR make sure they make sense. BUT NOTE,

     -- we can only check the ones that are fully filled; the rest

     -- we have to defer until we've typechecked our local signature.

     -- TODO: work this into GHC.Driver.Make!!

         case session of

             TcSession -> return ()

     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,

 import GHC.Types.Unique.FM

 import GHC.Types.Unique.DFM

 import GHC.Types.Unique.DSet

 import GHC.Types.Unique.Map

 import GHC.Types.Unique

 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

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

                         , instUnitHoles      = fh })

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

                 then uid

       _ -> uid

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

 -- 'instUnitToUnit'.

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

 pprWithUnitState :: UnitState -> SDoc -> SDoc

 --

 -- This unit may be indefinite or not (i.e. with remaining holes or not). If it

 -- is definite, we don't know if it has already been compiled and installed in a

 --

 -- An indefinite unit identifier pretty-prints to something like

 -- @p[H=<H>,A=aimpl:A>]@ (@p@ is the 'UnitId', and the