    {-# LANGUAGE FlexibleContexts  #-}
    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE RankNTypes        #-}
    {-# LANGUAGE TypeFamilies      #-}
    {-# LANGUAGE TupleSections     #-}

    module GHC.Tc.Gen.Export (rnExports, exports_from_avail, classifyGREs) where

    import GHC.Prelude

    import GHC.Hs
    import GHC.Builtin.Names
    import GHC.Tc.Errors.Types
    import GHC.Tc.Utils.Monad
    import GHC.Tc.Utils.Env
        ( TyThing(AConLike, AnId), tcLookupGlobal, tcLookupTyCon )
    import GHC.Tc.Utils.TcType
    import GHC.Rename.Doc
    import GHC.Rename.Module
    import GHC.Rename.Names
    import GHC.Rename.Env
    import GHC.Rename.Unbound ( reportUnboundName )
    import GHC.Utils.Error
    import GHC.Unit.Module
    import GHC.Unit.Module.Imported
    import GHC.Unit.Module.Warnings
    import GHC.Core.TyCon
    import GHC.Utils.Outputable
    import GHC.Utils.Panic
    import GHC.Core.ConLike
    import GHC.Core.PatSyn
    import GHC.Data.Maybe
    import GHC.Data.FastString (fsLit)
    import GHC.Driver.Env
    import GHC.Driver.DynFlags
    import GHC.Parser.PostProcess ( setRdrNameSpace )
    import qualified GHC.LanguageExtensions as LangExt

    import GHC.Types.Unique.Map
    import GHC.Types.SrcLoc as SrcLoc
    import GHC.Types.Name
    import GHC.Types.Name.Env
    import GHC.Types.Name.Set
    import GHC.Types.Avail
    import GHC.Types.SourceFile
    import GHC.Types.Id
    import GHC.Types.Id.Info
    import GHC.Types.Name.Reader

    import Control.Arrow ( first )
    import Control.Monad ( when )
    import qualified Data.List.NonEmpty as NE
    import Data.Traversable   ( for )
    import Data.List ( sortBy )

    {-
    ************************************************************************
    *                                                                      *
    \subsection{Export list processing}
    *                                                                      *
    ************************************************************************

    Processing the export list.

    You might think that we should record things that appear in the export
    list as ``occurrences'' (using @addOccurrenceName@), but you'd be
    wrong.  We do check (here) that they are in scope, but there is no
    need to slurp in their actual declaration (which is what
    @addOccurrenceName@ forces).

    Indeed, doing so would big trouble when compiling @PrelBase@, because
    it re-exports @GHC@, which includes @takeMVar#@, whose type includes
    @ConcBase.StateAndSynchVar#@, and so on...

    Note [Exports of data families]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Suppose you see (#5306)
            module M where
              import X( F )
              data instance F Int = FInt
    What does M export?  AvailTC F [FInt]
                      or AvailTC F [F,FInt]?
    The former is strictly right because F isn't defined in this module.
    But then you can never do an explicit import of M, thus
        import M( F( FInt ) )
    because F isn't exported by M.  Nor can you import FInt alone from here
        import M( FInt )
    because we don't have syntax to support that.  (It looks like an import of
    the type FInt.)

    At one point I implemented a compromise:
      * When constructing exports with no export list, or with module M(
        module M ), we add the parent to the exports as well.
      * But not when you see module M( f ), even if f is a
        class method with a parent.
      * Nor when you see module M( module N ), with N /= M.

    But the compromise seemed too much of a hack, so we backed it out.
    You just have to use an explicit export list:
        module M( F(..) ) where ...

    Note [Avails of associated data families]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Suppose you have (#16077)

        {-# LANGUAGE TypeFamilies #-}
        module A (module A) where

        class    C a  where { data T a }
        instance C () where { data T () = D }

    Because @A@ is exported explicitly, GHC tries to produce an export list
    from the @GlobalRdrEnv@. In this case, it pulls out the following:

        [ C defined at A.hs:4:1
        , T parent:C defined at A.hs:4:23
        , D parent:T defined at A.hs:5:35 ]

    If map these directly into avails, (via 'availFromGRE'), we get
    @[C{C;}, C{T;}, T{D;}]@, which eventually gets merged into @[C{C, T;}, T{D;}]@.
    That's not right, because @T{D;}@ violates the AvailTC invariant: @T@ is
    exported, but it isn't the first entry in the avail!

    We work around this issue by expanding GREs where the parent and child
    are both type constructors into two GRES.

        T parent:C defined at A.hs:4:23

          =>

        [ T parent:C defined at A.hs:4:23
        , T defined at A.hs:4:23 ]

    Then, we get  @[C{C;}, C{T;}, T{T;}, T{D;}]@, which eventually gets merged
    into @[C{C, T;}, T{T, D;}]@ (which satisfies the AvailTC invariant).
    -}

    data ExportAccum        -- The type of the accumulating parameter of
                            -- the main worker function in rnExports
         = ExportAccum {
             ExportAccum -> ExportOccMap
    expacc_exp_occs :: ExportOccMap,
               -- ^ Tracks exported occurrence names
             ExportAccum -> UniqMap ModuleName [Name]
    expacc_mods :: UniqMap ModuleName [Name],
               -- ^ Tracks (re-)exported module names
               --   and the names they re-export
             ExportAccum -> ExportWarnSpanNames
    expacc_warn_spans :: ExportWarnSpanNames,
               -- ^ Information about warnings for names
             ExportAccum -> DontWarnExportNames
    expacc_dont_warn :: DontWarnExportNames
               -- ^ What names not to export warnings for
               --   (because they are exported without a warning)
         }

    emptyExportAccum :: ExportAccum
    emptyExportAccum :: ExportAccum
    emptyExportAccum = ExportOccMap
    -> UniqMap ModuleName [Name]
    -> ExportWarnSpanNames
    -> DontWarnExportNames
    -> ExportAccum
    ExportAccum ExportOccMap
    forall a. OccEnv a
    emptyOccEnv UniqMap ModuleName [Name]
    forall k a. UniqMap k a
    emptyUniqMap [] DontWarnExportNames
    forall a. NameEnv a
    emptyNameEnv

    accumExports :: (ExportAccum -> x -> TcRn (ExportAccum, Maybe y))
                 -> [x]
                 -> TcRn ([y], ExportWarnSpanNames, DontWarnExportNames)
    accumExports :: forall x y.
    (ExportAccum -> x -> TcRn (ExportAccum, Maybe y))
    -> [x] -> TcRn ([y], ExportWarnSpanNames, DontWarnExportNames)
    accumExports ExportAccum -> x -> TcRn (ExportAccum, Maybe y)
    f [x]
    xs = do
      (ExportAccum _ _ export_warn_spans dont_warn_export, ys)
        <- (ExportAccum -> x -> TcRn (ExportAccum, Maybe y))
    -> ExportAccum
    -> [x]
    -> IOEnv (Env TcGblEnv TcLclEnv) (ExportAccum, [Maybe y])
    forall (m :: * -> *) (t :: * -> *) acc x y.
    (Monad m, Traversable t) =>
    (acc -> x -> m (acc, y)) -> acc -> t x -> m (acc, t y)
    mapAccumLM ExportAccum -> x -> TcRn (ExportAccum, Maybe y)
    f' ExportAccum
    emptyExportAccum [x]
    xs
      return ( catMaybes ys
             , export_warn_spans
             , dont_warn_export )
      where f' :: ExportAccum -> x -> TcRn (ExportAccum, Maybe y)
    f' ExportAccum
    acc x
    x
              = (ExportAccum, Maybe y)
    -> Maybe (ExportAccum, Maybe y) -> (ExportAccum, Maybe y)
    forall a. a -> Maybe a -> a
    fromMaybe (ExportAccum
    acc, Maybe y
    forall a. Maybe a
    Nothing) (Maybe (ExportAccum, Maybe y) -> (ExportAccum, Maybe y))
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (ExportAccum, Maybe y))
    -> TcRn (ExportAccum, Maybe y)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TcRn (ExportAccum, Maybe y)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (ExportAccum, Maybe y))
    forall r. TcRn r -> TcRn (Maybe r)
    attemptM (ExportAccum -> x -> TcRn (ExportAccum, Maybe y)
    f ExportAccum
    acc x
    x)

    type ExportOccMap = OccEnv (Name, IE GhcPs)
            -- Tracks what a particular exported OccName
            --   in an export list refers to, and which item
            --   it came from.  It's illegal to export two distinct things
            --   that have the same occurrence name

    rnExports :: Bool       -- False => no 'module M(..) where' header at all
              -> Maybe (LocatedL [LIE GhcPs]) -- Nothing => no explicit export list
              -> RnM TcGblEnv

            -- Complains if two distinct exports have same OccName
            -- Warns about identical exports.
            -- Complains about exports items not in scope

    rnExports :: Bool -> Maybe (LocatedL [LIE GhcPs]) -> RnM TcGblEnv
    rnExports Bool
    explicit_mod Maybe (LocatedL [LIE GhcPs])
    exports
     = RnM TcGblEnv -> RnM TcGblEnv
    forall r. TcM r -> TcM r
    checkNoErrs (RnM TcGblEnv -> RnM TcGblEnv) -> RnM TcGblEnv -> RnM TcGblEnv
    forall a b. (a -> b) -> a -> b
    $   -- Fail if anything in rnExports finds
                       -- an error fails, to avoid error cascade
       do   { hsc_env <- TcRnIf TcGblEnv TcLclEnv HscEnv
    forall gbl lcl. TcRnIf gbl lcl HscEnv
    getTopEnv
            ; tcg_env <- getGblEnv
            ; let dflags = HscEnv -> DynFlags
    hsc_dflags HscEnv
    hsc_env
                  TcGblEnv { tcg_mod     = this_mod
                           , tcg_rdr_env = rdr_env
                           , tcg_imports = imports
                           , tcg_warns   = warns
                           , tcg_src     = hsc_src } = tcg_env
                  default_main | HomeUnitEnv -> Module
    mainModIs (HscEnv -> HomeUnitEnv
    hsc_HUE HscEnv
    hsc_env) Module -> Module -> Bool
    forall a. Eq a => a -> a -> Bool
    == Module
    this_mod
                               , Just String
    main_fun <- DynFlags -> Maybe String
    mainFunIs DynFlags
    dflags
                               = NameSpace -> FastString -> RdrName
    mkUnqual NameSpace
    varName (String -> FastString
    fsLit String
    main_fun)
                               | Bool
    otherwise
                               = RdrName
    main_RDR_Unqual
            ; has_main <- (not . null) <$> lookupInfoOccRn default_main -- #17832

            -- If a module has no explicit header, and it has one or more main
            -- functions in scope, then add a header like
            -- "module Main(main) where ..."                               #13839
            -- See Note [Modules without a module header]
            ; let real_exports
                     | Bool
    explicit_mod = Maybe (LocatedL [LIE GhcPs])
    exports
                     | Bool
    has_main
                              = GenLocated SrcSpanAnnL [GenLocated SrcSpanAnnA (IE GhcPs)]
    -> Maybe
         (GenLocated SrcSpanAnnL [GenLocated SrcSpanAnnA (IE GhcPs)])
    forall a. a -> Maybe a
    Just ([GenLocated SrcSpanAnnA (IE GhcPs)]
    -> GenLocated SrcSpanAnnL [GenLocated SrcSpanAnnA (IE GhcPs)]
    forall e a. HasAnnotation e => a -> GenLocated e a
    noLocA [IE GhcPs -> GenLocated SrcSpanAnnA (IE GhcPs)
    forall e a. HasAnnotation e => a -> GenLocated e a
    noLocA (XIEVar GhcPs
    -> LIEWrappedName GhcPs -> Maybe (ExportDoc GhcPs) -> IE GhcPs
    forall pass.
    XIEVar pass
    -> LIEWrappedName pass -> Maybe (ExportDoc pass) -> IE pass
    IEVar Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcPs))
    XIEVar GhcPs
    forall a. Maybe a
    Nothing
                                         (IEWrappedName GhcPs -> GenLocated SrcSpanAnnA (IEWrappedName GhcPs)
    forall e a. HasAnnotation e => a -> GenLocated e a
    noLocA (XIEName GhcPs -> LIdP GhcPs -> IEWrappedName GhcPs
    forall p. XIEName p -> LIdP p -> IEWrappedName p
    IEName XIEName GhcPs
    NoExtField
    noExtField (LIdP GhcPs -> IEWrappedName GhcPs)
    -> LIdP GhcPs -> IEWrappedName GhcPs
    forall a b. (a -> b) -> a -> b
    $ RdrName -> GenLocated SrcSpanAnnN RdrName
    forall e a. HasAnnotation e => a -> GenLocated e a
    noLocA RdrName
    default_main)) Maybe (ExportDoc GhcPs)
    forall a. Maybe a
    Nothing)])
                            -- ToDo: the 'noLoc' here is unhelpful if 'main'
                            --       turns out to be out of scope
                     | Bool
    otherwise = Maybe (LocatedL [LIE GhcPs])
    Maybe (GenLocated SrcSpanAnnL [GenLocated SrcSpanAnnA (IE GhcPs)])
    forall a. Maybe a
    Nothing

            -- Rename the export list
            ; let do_it = Maybe (LocatedL [LIE GhcPs])
    -> GlobalRdrEnv
    -> ImportAvails
    -> Module
    -> RnM
         (Maybe [(LIE GhcRn, [AvailInfo])], [AvailInfo],
          ExportWarnNames GhcRn)
    exports_from_avail Maybe (LocatedL [LIE GhcPs])
    real_exports GlobalRdrEnv
    rdr_env ImportAvails
    imports Module
    this_mod
            ; (rn_exports, final_avails, new_export_warns)
                <- if hsc_src == HsigFile
                    then do (mb_r, msgs) <- tryTc do_it
                            case mb_r of
                                Just (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
     [AvailInfo], ExportWarnNames GhcRn)
    r  -> (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
     [AvailInfo], ExportWarnNames GhcRn)
    -> TcRn
         (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
          [AvailInfo], ExportWarnNames GhcRn)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
     [AvailInfo], ExportWarnNames GhcRn)
    r
                                Maybe
      (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
       [AvailInfo], ExportWarnNames GhcRn)
    Nothing -> Messages TcRnMessage -> TcRn ()
    addMessages Messages TcRnMessage
    msgs TcRn ()
    -> TcRn
         (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
          [AvailInfo], ExportWarnNames GhcRn)
    -> TcRn
         (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
          [AvailInfo], ExportWarnNames GhcRn)
    forall a b.
    IOEnv (Env TcGblEnv TcLclEnv) a
    -> IOEnv (Env TcGblEnv TcLclEnv) b
    -> IOEnv (Env TcGblEnv TcLclEnv) b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> TcRn
      (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
       [AvailInfo], ExportWarnNames GhcRn)
    forall env a. IOEnv env a
    failM
                    else checkNoErrs do_it

            -- Final processing
            ; let final_ns = [AvailInfo] -> NameSet
    availsToNameSet [AvailInfo]
    final_avails

            ; traceRn "rnExports: Exports:" (ppr final_avails)

            ; return (tcg_env { tcg_exports    = final_avails
                              , tcg_rn_exports = case tcg_rn_exports tcg_env of
                                                    Maybe [(LIE GhcRn, [AvailInfo])]
    Nothing -> Maybe [(LIE GhcRn, [AvailInfo])]
    Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
    forall a. Maybe a
    Nothing
                                                    Just [(LIE GhcRn, [AvailInfo])]
    _  -> Maybe [(LIE GhcRn, [AvailInfo])]
    Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
    rn_exports
                              , tcg_dus = tcg_dus tcg_env `plusDU`
                                          usesOnly final_ns
                              , tcg_warns = insertWarnExports
                                            warns new_export_warns}) }

    -- | List of names and the information about their warnings
    --   (warning, export list item span)
    type ExportWarnSpanNames = [(Name, WarningTxt GhcRn, SrcSpan)]

    -- | Map from names that should not have export warnings to
    --   the spans of export list items that are missing those warnings
    type DontWarnExportNames = NameEnv (NE.NonEmpty SrcSpan)

    exports_from_avail :: Maybe (LocatedL [LIE GhcPs])
                             -- ^ 'Nothing' means no explicit export list
                       -> GlobalRdrEnv
                       -> ImportAvails
                             -- ^ Imported modules; this is used to test if a
                             -- @module Foo@ export is valid (it's not valid
                             -- if we didn't import @Foo@!)
                       -> Module
                       -> RnM (Maybe [(LIE GhcRn, Avails)], Avails, ExportWarnNames GhcRn)
                             -- (Nothing, _, _) <=> no explicit export list
                             -- if explicit export list is present it contains
                             -- each renamed export item together with its exported
                             -- names.

    exports_from_avail :: Maybe (LocatedL [LIE GhcPs])
    -> GlobalRdrEnv
    -> ImportAvails
    -> Module
    -> RnM
         (Maybe [(LIE GhcRn, [AvailInfo])], [AvailInfo],
          ExportWarnNames GhcRn)
    exports_from_avail Maybe (LocatedL [LIE GhcPs])
    Nothing GlobalRdrEnv
    rdr_env ImportAvails
    _imports Module
    _this_mod
       -- The same as (module M) where M is the current module name,
       -- so that's how we handle it, except we also export the data family
       -- when a data instance is exported.
      = do {
        ; TcRnMessage -> TcRn ()
    addDiagnostic
            (ModuleName -> TcRnMessage
    TcRnMissingExportList (ModuleName -> TcRnMessage) -> ModuleName -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ Module -> ModuleName
    forall unit. GenModule unit -> ModuleName
    moduleName Module
    _this_mod)
        ; let avails :: [AvailInfo]
    avails =
                (AvailInfo -> AvailInfo) -> [AvailInfo] -> [AvailInfo]
    forall a b. (a -> b) -> [a] -> [b]
    map AvailInfo -> AvailInfo
    fix_faminst ([AvailInfo] -> [AvailInfo])
    -> (GlobalRdrEnv -> [AvailInfo]) -> GlobalRdrEnv -> [AvailInfo]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [GlobalRdrEltX GREInfo] -> [AvailInfo]
    forall info. [GlobalRdrEltX info] -> [AvailInfo]
    gresToAvailInfo
                  ([GlobalRdrEltX GREInfo] -> [AvailInfo])
    -> (GlobalRdrEnv -> [GlobalRdrEltX GREInfo])
    -> GlobalRdrEnv
    -> [AvailInfo]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (GlobalRdrEltX GREInfo -> Bool)
    -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo]
    forall a. (a -> Bool) -> [a] -> [a]
    filter GlobalRdrEltX GREInfo -> Bool
    forall info. GlobalRdrEltX info -> Bool
    isLocalGRE ([GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo])
    -> (GlobalRdrEnv -> [GlobalRdrEltX GREInfo])
    -> GlobalRdrEnv
    -> [GlobalRdrEltX GREInfo]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GlobalRdrEnv -> [GlobalRdrEltX GREInfo]
    forall info. GlobalRdrEnvX info -> [GlobalRdrEltX info]
    globalRdrEnvElts (GlobalRdrEnv -> [AvailInfo]) -> GlobalRdrEnv -> [AvailInfo]
    forall a b. (a -> b) -> a -> b
    $ GlobalRdrEnv
    rdr_env
        ; (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
     [AvailInfo], ExportWarnNames GhcRn)
    -> TcRn
         (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
          [AvailInfo], ExportWarnNames GhcRn)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
    forall a. Maybe a
    Nothing, [AvailInfo]
    avails, []) }
      where
        -- #11164: when we define a data instance
        -- but not data family, re-export the family
        -- Even though we don't check whether this is actually a data family
        -- only data families can locally define subordinate things (`ns` here)
        -- without locally defining (and instead importing) the parent (`n`)
        fix_faminst :: AvailInfo -> AvailInfo
    fix_faminst avail :: AvailInfo
    avail@(AvailTC Name
    n [Name]
    ns)
          | AvailInfo -> Bool
    availExportsDecl AvailInfo
    avail
          = AvailInfo
    avail
          | Bool
    otherwise
          = Name -> [Name] -> AvailInfo
    AvailTC Name
    n (Name
    nName -> [Name] -> [Name]
    forall a. a -> [a] -> [a]
    :[Name]
    ns)
        fix_faminst AvailInfo
    avail = AvailInfo
    avail

    exports_from_avail (Just (L SrcSpanAnnL
    _ [LIE GhcPs]
    rdr_items)) GlobalRdrEnv
    rdr_env ImportAvails
    imports Module
    this_mod
      = do (ie_avails, export_warn_spans, dont_warn_export)
             <- (ExportAccum
     -> GenLocated SrcSpanAnnA (IE GhcPs)
     -> TcRn
          (ExportAccum,
           Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])))
    -> [GenLocated SrcSpanAnnA (IE GhcPs)]
    -> TcRn
         ([(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
          ExportWarnSpanNames, DontWarnExportNames)
    forall x y.
    (ExportAccum -> x -> TcRn (ExportAccum, Maybe y))
    -> [x] -> TcRn ([y], ExportWarnSpanNames, DontWarnExportNames)
    accumExports ExportAccum
    -> LIE GhcPs -> RnM (ExportAccum, Maybe (LIE GhcRn, [AvailInfo]))
    ExportAccum
    -> GenLocated SrcSpanAnnA (IE GhcPs)
    -> TcRn
         (ExportAccum,
          Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    do_litem [LIE GhcPs]
    [GenLocated SrcSpanAnnA (IE GhcPs)]
    rdr_items
           let final_exports = [AvailInfo] -> [AvailInfo]
    nubAvails (((GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]) -> [AvailInfo])
    -> [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
    -> [AvailInfo]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]) -> [AvailInfo]
    forall a b. (a, b) -> b
    snd [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
    ie_avails) -- Combine families
           export_warn_names <- aggregate_warnings export_warn_spans dont_warn_export
           return (Just ie_avails, final_exports, export_warn_names)
      where
        do_litem :: ExportAccum -> LIE GhcPs
                 -> RnM (ExportAccum, Maybe (LIE GhcRn, Avails))
        do_litem :: ExportAccum
    -> LIE GhcPs -> RnM (ExportAccum, Maybe (LIE GhcRn, [AvailInfo]))
    do_litem ExportAccum
    acc LIE GhcPs
    lie = SrcSpan
    -> TcRn
         (ExportAccum,
          Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    -> TcRn
         (ExportAccum,
          Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan (GenLocated SrcSpanAnnA (IE GhcPs) -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA LIE GhcPs
    GenLocated SrcSpanAnnA (IE GhcPs)
    lie) (ExportAccum
    -> LIE GhcPs -> RnM (ExportAccum, Maybe (LIE GhcRn, [AvailInfo]))
    exports_from_item ExportAccum
    acc LIE GhcPs
    lie)

        -- Maps a parent to its in-scope children
        kids_env :: NameEnv [GlobalRdrElt]
        kids_env :: NameEnv [GlobalRdrEltX GREInfo]
    kids_env = [GlobalRdrEltX GREInfo] -> NameEnv [GlobalRdrEltX GREInfo]
    mkChildEnv (GlobalRdrEnv -> [GlobalRdrEltX GREInfo]
    forall info. GlobalRdrEnvX info -> [GlobalRdrEltX info]
    globalRdrEnvElts GlobalRdrEnv
    rdr_env)

        -- See Note [Avails of associated data families]
        expand_tyty_gre :: GlobalRdrElt -> [GlobalRdrElt]
        expand_tyty_gre :: GlobalRdrEltX GREInfo -> [GlobalRdrEltX GREInfo]
    expand_tyty_gre (gre :: GlobalRdrEltX GREInfo
    gre@GRE { gre_par :: forall info. GlobalRdrEltX info -> Parent
    gre_par = ParentIs Name
    p })
          | Name -> Bool
    isTyConName Name
    p
          , Name -> Bool
    isTyConName (GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    gre)
          = [GlobalRdrEltX GREInfo
    gre, GlobalRdrEltX GREInfo
    gre{ gre_par = NoParent }]
        expand_tyty_gre GlobalRdrEltX GREInfo
    gre
          = [GlobalRdrEltX GREInfo
    gre]

        imported_modules :: [ModuleName]
    imported_modules = [ ImportedModsVal -> ModuleName
    imv_name ImportedModsVal
    imv
                           | [ImportedBy]
    xs <- ModuleEnv [ImportedBy] -> [[ImportedBy]]
    forall a. ModuleEnv a -> [a]
    moduleEnvElts (ModuleEnv [ImportedBy] -> [[ImportedBy]])
    -> ModuleEnv [ImportedBy] -> [[ImportedBy]]
    forall a b. (a -> b) -> a -> b
    $ ImportAvails -> ModuleEnv [ImportedBy]
    imp_mods ImportAvails
    imports
                           , ImportedModsVal
    imv <- [ImportedBy] -> [ImportedModsVal]
    importedByUser [ImportedBy]
    xs ]

        exports_from_item :: ExportAccum -> LIE GhcPs
                          -> RnM (ExportAccum, Maybe (LIE GhcRn, Avails))
        exports_from_item :: ExportAccum
    -> LIE GhcPs -> RnM (ExportAccum, Maybe (LIE GhcRn, [AvailInfo]))
    exports_from_item expacc :: ExportAccum
    expacc@ExportAccum{
                            expacc_exp_occs :: ExportAccum -> ExportOccMap
    expacc_exp_occs   = ExportOccMap
    occs,
                            expacc_mods :: ExportAccum -> UniqMap ModuleName [Name]
    expacc_mods       = UniqMap ModuleName [Name]
    earlier_mods,
                            expacc_warn_spans :: ExportAccum -> ExportWarnSpanNames
    expacc_warn_spans = ExportWarnSpanNames
    export_warn_spans,
                            expacc_dont_warn :: ExportAccum -> DontWarnExportNames
    expacc_dont_warn  = DontWarnExportNames
    dont_warn_export
                          } (L SrcSpanAnnA
    loc ie :: IE GhcPs
    ie@(IEModuleContents (Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcPs))
    warn_txt_ps, [AddEpAnn]
    _) lmod :: XRec GhcPs ModuleName
    lmod@(L SrcSpanAnnA
    _ ModuleName
    mod)))
          | Just [Name]
    exported_names <- UniqMap ModuleName [Name] -> ModuleName -> Maybe [Name]
    forall k a. Uniquable k => UniqMap k a -> k -> Maybe a
    lookupUniqMap UniqMap ModuleName [Name]
    earlier_mods ModuleName
    mod  -- Duplicate export of M
          = do { TcRnMessage -> TcRn ()
    addDiagnostic (ModuleName -> TcRnMessage
    TcRnDupeModuleExport ModuleName
    mod)
               ; (export_warn_spans', dont_warn_export', _) <-
                    ExportWarnSpanNames
    -> DontWarnExportNames
    -> [Name]
    -> Maybe (LWarningTxt GhcPs)
    -> SrcSpan
    -> RnM
         (ExportWarnSpanNames, DontWarnExportNames,
          Maybe (LWarningTxt GhcRn))
    process_warning ExportWarnSpanNames
    export_warn_spans
                                    DontWarnExportNames
    dont_warn_export
                                    [Name]
    exported_names
                                    Maybe (LWarningTxt GhcPs)
    Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcPs))
    warn_txt_ps
                                    (SrcSpanAnnA -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA SrcSpanAnnA
    loc)
                       -- Checks if all the names are exported with the same warning message
                       -- or if they should not be warned about
               ; return ( expacc{ expacc_warn_spans = export_warn_spans'
                                , expacc_dont_warn  = dont_warn_export' }
                        , Nothing ) }

          | Bool
    otherwise
          = do { let { exportValid :: Bool
    exportValid    = (ModuleName
    mod ModuleName -> [ModuleName] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [ModuleName]
    imported_modules)
                                      Bool -> Bool -> Bool
    || (Module -> ModuleName
    forall unit. GenModule unit -> ModuleName
    moduleName Module
    this_mod ModuleName -> ModuleName -> Bool
    forall a. Eq a => a -> a -> Bool
    == ModuleName
    mod)
                     ; gre_prs :: [(GlobalRdrEltX GREInfo, GlobalRdrEltX GREInfo)]
    gre_prs        = ModuleName
    -> [GlobalRdrEltX GREInfo]
    -> [(GlobalRdrEltX GREInfo, GlobalRdrEltX GREInfo)]
    forall info.
    ModuleName
    -> [GlobalRdrEltX info]
    -> [(GlobalRdrEltX info, GlobalRdrEltX info)]
    pickGREsModExp ModuleName
    mod (GlobalRdrEnv -> [GlobalRdrEltX GREInfo]
    forall info. GlobalRdrEnvX info -> [GlobalRdrEltX info]
    globalRdrEnvElts GlobalRdrEnv
    rdr_env)
                     ; new_gres :: [GlobalRdrEltX GREInfo]
    new_gres       = [ GlobalRdrEltX GREInfo
    gre'
                                        | (GlobalRdrEltX GREInfo
    gre, GlobalRdrEltX GREInfo
    _) <- [(GlobalRdrEltX GREInfo, GlobalRdrEltX GREInfo)]
    gre_prs
                                        , GlobalRdrEltX GREInfo
    gre' <- GlobalRdrEltX GREInfo -> [GlobalRdrEltX GREInfo]
    expand_tyty_gre GlobalRdrEltX GREInfo
    gre ]
                     ; new_exports :: [AvailInfo]
    new_exports    = (GlobalRdrEltX GREInfo -> AvailInfo)
    -> [GlobalRdrEltX GREInfo] -> [AvailInfo]
    forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrEltX GREInfo -> AvailInfo
    forall info. GlobalRdrEltX info -> AvailInfo
    availFromGRE [GlobalRdrEltX GREInfo]
    new_gres
                     ; all_gres :: [GlobalRdrEltX GREInfo]
    all_gres       = ((GlobalRdrEltX GREInfo, GlobalRdrEltX GREInfo)
     -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo])
    -> [GlobalRdrEltX GREInfo]
    -> [(GlobalRdrEltX GREInfo, GlobalRdrEltX GREInfo)]
    -> [GlobalRdrEltX GREInfo]
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\(GlobalRdrEltX GREInfo
    gre1,GlobalRdrEltX GREInfo
    gre2) [GlobalRdrEltX GREInfo]
    gres -> GlobalRdrEltX GREInfo
    gre1 GlobalRdrEltX GREInfo
    -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo]
    forall a. a -> [a] -> [a]
    : GlobalRdrEltX GREInfo
    gre2 GlobalRdrEltX GREInfo
    -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo]
    forall a. a -> [a] -> [a]
    : [GlobalRdrEltX GREInfo]
    gres) [] [(GlobalRdrEltX GREInfo, GlobalRdrEltX GREInfo)]
    gre_prs
                     ; exported_names :: [Name]
    exported_names = (GlobalRdrEltX GREInfo -> Name)
    -> [GlobalRdrEltX GREInfo] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName [GlobalRdrEltX GREInfo]
    new_gres
                     ; mods :: UniqMap ModuleName [Name]
    mods           = UniqMap ModuleName [Name]
    -> ModuleName -> [Name] -> UniqMap ModuleName [Name]
    forall k a. Uniquable k => UniqMap k a -> k -> a -> UniqMap k a
    addToUniqMap UniqMap ModuleName [Name]
    earlier_mods ModuleName
    mod [Name]
    exported_names
                     }

                ; Bool -> TcRnMessage -> TcRn ()
    checkErr Bool
    exportValid (ModuleName -> TcRnMessage
    TcRnExportedModNotImported ModuleName
    mod)
                ; Bool -> TcRnMessage -> TcRn ()
    warnIf (Bool
    exportValid Bool -> Bool -> Bool
    && [(GlobalRdrEltX GREInfo, GlobalRdrEltX GREInfo)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [(GlobalRdrEltX GREInfo, GlobalRdrEltX GREInfo)]
    gre_prs) (ModuleName -> TcRnMessage
    TcRnNullExportedModule ModuleName
    mod)

                ; String -> SDoc -> TcRn ()
    traceRn String
    "efa" (ModuleName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ModuleName
    mod SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ [GlobalRdrEltX GREInfo] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [GlobalRdrEltX GREInfo]
    all_gres)
                ; DeprecationWarnings -> [GlobalRdrEltX GREInfo] -> TcRn ()
    addUsedGREs DeprecationWarnings
    ExportDeprecationWarnings [GlobalRdrEltX GREInfo]
    all_gres

                ; occs' <- ExportOccMap
    -> IE GhcPs -> [GlobalRdrEltX GREInfo] -> RnM ExportOccMap
    check_occs ExportOccMap
    occs IE GhcPs
    ie [GlobalRdrEltX GREInfo]
    new_gres
                              -- This check_occs not only finds conflicts
                              -- between this item and others, but also
                              -- internally within this item.  That is, if
                              -- 'M.x' is in scope in several ways, we'll have
                              -- several members of mod_avails with the same
                              -- OccName.
                ; (export_warn_spans', dont_warn_export', warn_txt_rn) <-
                    process_warning export_warn_spans
                                    dont_warn_export
                                    exported_names
                                    warn_txt_ps
                                    (locA loc)

                ; traceRn "export_mod"
                          (vcat [ ppr mod
                                , ppr new_exports ])
                ; return ( ExportAccum { expacc_exp_occs   = occs'
                                       , expacc_mods       = mods
                                       , expacc_warn_spans = export_warn_spans'
                                       , expacc_dont_warn  = dont_warn_export' }
                         , Just (L loc (IEModuleContents warn_txt_rn lmod), new_exports) ) }

        exports_from_item ExportAccum
    acc LIE GhcPs
    lie = do
            m_doc_ie <- LIE GhcPs -> RnM (Maybe (LIE GhcRn))
    lookup_doc_ie LIE GhcPs
    lie
            case m_doc_ie of
              Just GenLocated SrcSpanAnnA (IE GhcRn)
    new_ie -> (ExportAccum,
     Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    -> TcRn
         (ExportAccum,
          Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ExportAccum
    acc, (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])
    -> Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])
    forall a. a -> Maybe a
    Just (GenLocated SrcSpanAnnA (IE GhcRn)
    new_ie, []))
              Maybe (GenLocated SrcSpanAnnA (IE GhcRn))
    Nothing -> do
                m_ie <- ExportAccum
    -> LIE GhcPs -> RnM (Maybe (ExportAccum, LIE GhcRn, AvailInfo))
    lookup_ie ExportAccum
    acc LIE GhcPs
    lie
                case m_ie of
                  Maybe (ExportAccum, GenLocated SrcSpanAnnA (IE GhcRn), AvailInfo)
    Nothing -> (ExportAccum,
     Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    -> TcRn
         (ExportAccum,
          Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ExportAccum
    acc, Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])
    forall a. Maybe a
    Nothing)
                  Just (ExportAccum
    acc', GenLocated SrcSpanAnnA (IE GhcRn)
    new_ie, AvailInfo
    avail)
                    -> (ExportAccum,
     Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    -> TcRn
         (ExportAccum,
          Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo]))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ExportAccum
    acc', (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])
    -> Maybe (GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])
    forall a. a -> Maybe a
    Just (GenLocated SrcSpanAnnA (IE GhcRn)
    new_ie, [AvailInfo
    avail]))

        -------------
        lookup_ie :: ExportAccum -> LIE GhcPs -> RnM (Maybe (ExportAccum, LIE GhcRn, AvailInfo))
        lookup_ie :: ExportAccum
    -> LIE GhcPs -> RnM (Maybe (ExportAccum, LIE GhcRn, AvailInfo))
    lookup_ie expacc :: ExportAccum
    expacc@ExportAccum{
                expacc_exp_occs :: ExportAccum -> ExportOccMap
    expacc_exp_occs   = ExportOccMap
    occs,
                expacc_warn_spans :: ExportAccum -> ExportWarnSpanNames
    expacc_warn_spans = ExportWarnSpanNames
    export_warn_spans,
                expacc_dont_warn :: ExportAccum -> DontWarnExportNames
    expacc_dont_warn  = DontWarnExportNames
    dont_warn_export
              } (L SrcSpanAnnA
    loc ie :: IE GhcPs
    ie@(IEVar XIEVar GhcPs
    warn_txt_ps LIEWrappedName GhcPs
    l Maybe (ExportDoc GhcPs)
    doc))
            = do mb_gre <- RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo))
    lookupGreAvailRn (RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo)))
    -> RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo))
    forall a b. (a -> b) -> a -> b
    $ LIEWrappedName GhcPs -> IdP GhcPs
    forall (p :: Pass). LIEWrappedName (GhcPass p) -> IdP (GhcPass p)
    lieWrappedName LIEWrappedName GhcPs
    l
                 for mb_gre $ \ GlobalRdrEltX GREInfo
    gre -> do
                   let avail :: AvailInfo
    avail = GlobalRdrEltX GREInfo -> AvailInfo
    forall info. GlobalRdrEltX info -> AvailInfo
    availFromGRE GlobalRdrEltX GREInfo
    gre
                       name :: Name
    name = GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    gre

                   occs' <- ExportOccMap
    -> IE GhcPs -> [GlobalRdrEltX GREInfo] -> RnM ExportOccMap
    check_occs ExportOccMap
    occs IE GhcPs
    ie [GlobalRdrEltX GREInfo
    gre]
                   (export_warn_spans', dont_warn_export', warn_txt_rn)
                     <- process_warning export_warn_spans
                                        dont_warn_export
                                        [name]
                                        warn_txt_ps
                                        (locA loc)

                   doc' <- traverse rnLHsDoc doc
                   return ( expacc{ expacc_exp_occs   = occs'
                                  , expacc_warn_spans = export_warn_spans'
                                  , expacc_dont_warn  = dont_warn_export' }
                          , L loc (IEVar warn_txt_rn (replaceLWrappedName l name) doc')
                          , avail )

        lookup_ie expacc :: ExportAccum
    expacc@ExportAccum{
                expacc_exp_occs :: ExportAccum -> ExportOccMap
    expacc_exp_occs   = ExportOccMap
    occs,
                expacc_warn_spans :: ExportAccum -> ExportWarnSpanNames
    expacc_warn_spans = ExportWarnSpanNames
    export_warn_spans,
                expacc_dont_warn :: ExportAccum -> DontWarnExportNames
    expacc_dont_warn  = DontWarnExportNames
    dont_warn_export
              } (L SrcSpanAnnA
    loc ie :: IE GhcPs
    ie@(IEThingAbs (Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcPs))
    warn_txt_ps, [AddEpAnn]
    ann) LIEWrappedName GhcPs
    l Maybe (ExportDoc GhcPs)
    doc))
            = do mb_gre <- RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo))
    lookupGreAvailRn (RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo)))
    -> RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo))
    forall a b. (a -> b) -> a -> b
    $ LIEWrappedName GhcPs -> IdP GhcPs
    forall (p :: Pass). LIEWrappedName (GhcPass p) -> IdP (GhcPass p)
    lieWrappedName LIEWrappedName GhcPs
    l
                 for mb_gre $ \ GlobalRdrEltX GREInfo
    gre -> do
                   let avail :: AvailInfo
    avail = GlobalRdrEltX GREInfo -> AvailInfo
    forall info. GlobalRdrEltX info -> AvailInfo
    availFromGRE GlobalRdrEltX GREInfo
    gre
                       name :: Name
    name = GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    gre

                   occs' <- ExportOccMap
    -> IE GhcPs -> [GlobalRdrEltX GREInfo] -> RnM ExportOccMap
    check_occs ExportOccMap
    occs IE GhcPs
    ie [GlobalRdrEltX GREInfo
    gre]
                   (export_warn_spans', dont_warn_export', warn_txt_rn)
                     <- process_warning export_warn_spans
                                        dont_warn_export
                                        [name]
                                        warn_txt_ps
                                        (locA loc)

                   doc' <- traverse rnLHsDoc doc
                   return ( expacc{ expacc_exp_occs   = occs'
                                  , expacc_warn_spans = export_warn_spans'
                                  , expacc_dont_warn  = dont_warn_export' }
                          , L loc (IEThingAbs (warn_txt_rn, ann) (replaceLWrappedName l name) doc')
                          , avail )

        lookup_ie expacc :: ExportAccum
    expacc@ExportAccum{
                expacc_exp_occs :: ExportAccum -> ExportOccMap
    expacc_exp_occs   = ExportOccMap
    occs,
                expacc_warn_spans :: ExportAccum -> ExportWarnSpanNames
    expacc_warn_spans = ExportWarnSpanNames
    export_warn_spans,
                expacc_dont_warn :: ExportAccum -> DontWarnExportNames
    expacc_dont_warn  = DontWarnExportNames
    dont_warn_export
              } (L SrcSpanAnnA
    loc ie :: IE GhcPs
    ie@(IEThingAll (Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcPs))
    warn_txt_ps, [AddEpAnn]
    ann) LIEWrappedName GhcPs
    l Maybe (ExportDoc GhcPs)
    doc))
            = do mb_gre <- RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo))
    lookupGreAvailRn (RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo)))
    -> RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo))
    forall a b. (a -> b) -> a -> b
    $ LIEWrappedName GhcPs -> IdP GhcPs
    forall (p :: Pass). LIEWrappedName (GhcPass p) -> IdP (GhcPass p)
    lieWrappedName LIEWrappedName GhcPs
    l
                 for mb_gre $ \ GlobalRdrEltX GREInfo
    par -> do
                   all_kids <- IE GhcPs
    -> LIEWrappedName GhcPs
    -> GlobalRdrEltX GREInfo
    -> RnM [GlobalRdrEltX GREInfo]
    lookup_ie_kids_all IE GhcPs
    ie LIEWrappedName GhcPs
    l GlobalRdrEltX GREInfo
    par
                   let name = GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    par
                       all_gres = GlobalRdrEltX GREInfo
    par GlobalRdrEltX GREInfo
    -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo]
    forall a. a -> [a] -> [a]
    : [GlobalRdrEltX GREInfo]
    all_kids
                       all_names = (GlobalRdrEltX GREInfo -> Name)
    -> [GlobalRdrEltX GREInfo] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName [GlobalRdrEltX GREInfo]
    all_gres

                   occs' <- check_occs occs ie all_gres
                   (export_warn_spans', dont_warn_export', warn_txt_rn)
                     <- process_warning export_warn_spans
                                        dont_warn_export
                                        all_names
                                        warn_txt_ps
                                        (locA loc)

                   doc' <- traverse rnLHsDoc doc
                   return ( expacc{ expacc_exp_occs   = occs'
                                  , expacc_warn_spans = export_warn_spans'
                                  , expacc_dont_warn  = dont_warn_export' }
                          , L loc (IEThingAll (warn_txt_rn, ann) (replaceLWrappedName l name) doc')
                          , AvailTC name all_names )

        lookup_ie expacc :: ExportAccum
    expacc@ExportAccum{
                expacc_exp_occs :: ExportAccum -> ExportOccMap
    expacc_exp_occs   = ExportOccMap
    occs,
                expacc_warn_spans :: ExportAccum -> ExportWarnSpanNames
    expacc_warn_spans = ExportWarnSpanNames
    export_warn_spans,
                expacc_dont_warn :: ExportAccum -> DontWarnExportNames
    expacc_dont_warn  = DontWarnExportNames
    dont_warn_export
              } (L SrcSpanAnnA
    loc ie :: IE GhcPs
    ie@(IEThingWith (Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcPs))
    warn_txt_ps, [AddEpAnn]
    ann) LIEWrappedName GhcPs
    l IEWildcard
    wc [LIEWrappedName GhcPs]
    sub_rdrs Maybe (ExportDoc GhcPs)
    doc))
            = do mb_gre <- IE GhcPs
    -> RnM (Maybe (GlobalRdrEltX GREInfo))
    -> RnM (Maybe (GlobalRdrEltX GREInfo))
    forall (p :: Pass) a.
    OutputableBndrId p =>
    IE (GhcPass p) -> TcM a -> TcM a
    addExportErrCtxt IE GhcPs
    ie
                         (RnM (Maybe (GlobalRdrEltX GREInfo))
     -> RnM (Maybe (GlobalRdrEltX GREInfo)))
    -> RnM (Maybe (GlobalRdrEltX GREInfo))
    -> RnM (Maybe (GlobalRdrEltX GREInfo))
    forall a b. (a -> b) -> a -> b
    $ RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo))
    lookupGreAvailRn (RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo)))
    -> RdrName -> RnM (Maybe (GlobalRdrEltX GREInfo))
    forall a b. (a -> b) -> a -> b
    $ LIEWrappedName GhcPs -> IdP GhcPs
    forall (p :: Pass). LIEWrappedName (GhcPass p) -> IdP (GhcPass p)
    lieWrappedName LIEWrappedName GhcPs
    l
                 for mb_gre $ \ GlobalRdrEltX GREInfo
    par -> do
                   (subs, with_kids)
                     <- IE GhcPs
    -> TcM ([LIEWrappedName GhcRn], [GlobalRdrEltX GREInfo])
    -> TcM ([LIEWrappedName GhcRn], [GlobalRdrEltX GREInfo])
    forall (p :: Pass) a.
    OutputableBndrId p =>
    IE (GhcPass p) -> TcM a -> TcM a
    addExportErrCtxt IE GhcPs
    ie
                      (TcM ([LIEWrappedName GhcRn], [GlobalRdrEltX GREInfo])
     -> TcM ([LIEWrappedName GhcRn], [GlobalRdrEltX GREInfo]))
    -> TcM ([LIEWrappedName GhcRn], [GlobalRdrEltX GREInfo])
    -> TcM ([LIEWrappedName GhcRn], [GlobalRdrEltX GREInfo])
    forall a b. (a -> b) -> a -> b
    $ GlobalRdrEltX GREInfo
    -> [LIEWrappedName GhcPs]
    -> TcM ([LIEWrappedName GhcRn], [GlobalRdrEltX GREInfo])
    lookup_ie_kids_with GlobalRdrEltX GREInfo
    par [LIEWrappedName GhcPs]
    sub_rdrs

                   wc_kids <-
                     case wc of
                       IEWildcard
    NoIEWildcard -> [GlobalRdrEltX GREInfo] -> RnM [GlobalRdrEltX GREInfo]
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return []
                       IEWildcard Int
    _ -> IE GhcPs
    -> LIEWrappedName GhcPs
    -> GlobalRdrEltX GREInfo
    -> RnM [GlobalRdrEltX GREInfo]
    lookup_ie_kids_all IE GhcPs
    ie LIEWrappedName GhcPs
    l GlobalRdrEltX GREInfo
    par

                   let name = GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    par
                       all_kids = [GlobalRdrEltX GREInfo]
    with_kids [GlobalRdrEltX GREInfo]
    -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo]
    forall a. [a] -> [a] -> [a]
    ++ [GlobalRdrEltX GREInfo]
    wc_kids
                       all_gres = GlobalRdrEltX GREInfo
    par GlobalRdrEltX GREInfo
    -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo]
    forall a. a -> [a] -> [a]
    : [GlobalRdrEltX GREInfo]
    all_kids
                       all_names = (GlobalRdrEltX GREInfo -> Name)
    -> [GlobalRdrEltX GREInfo] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName [GlobalRdrEltX GREInfo]
    all_gres

                   occs' <- check_occs occs ie all_gres
                   (export_warn_spans', dont_warn_export', warn_txt_rn)
                     <- process_warning export_warn_spans
                                        dont_warn_export
                                        all_names
                                        warn_txt_ps
                                        (locA loc)

                   doc' <- traverse rnLHsDoc doc
                   return ( expacc{ expacc_exp_occs   = occs'
                                  , expacc_warn_spans = export_warn_spans'
                                  , expacc_dont_warn  = dont_warn_export' }
                          , L loc (IEThingWith (warn_txt_rn, ann) (replaceLWrappedName l name) wc subs doc')
                          , AvailTC name all_names )

        lookup_ie ExportAccum
    _ LIE GhcPs
    _ = String
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (Maybe (ExportAccum, GenLocated SrcSpanAnnA (IE GhcRn), AvailInfo))
    forall a. HasCallStack => String -> a
    panic String
    "lookup_ie"    -- Other cases covered earlier

        lookup_ie_kids_with :: GlobalRdrElt -> [LIEWrappedName GhcPs]
                       -> RnM ([LIEWrappedName GhcRn], [GlobalRdrElt])
        lookup_ie_kids_with :: GlobalRdrEltX GREInfo
    -> [LIEWrappedName GhcPs]
    -> TcM ([LIEWrappedName GhcRn], [GlobalRdrEltX GREInfo])
    lookup_ie_kids_with GlobalRdrEltX GREInfo
    gre [LIEWrappedName GhcPs]
    sub_rdrs =
          do { let name :: Name
    name = GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    gre
             ; kids <- Name
    -> [LIEWrappedName GhcPs]
    -> RnM [(LIEWrappedName GhcRn, GlobalRdrEltX GREInfo)]
    lookupChildrenExport Name
    name [LIEWrappedName GhcPs]
    sub_rdrs
             ; return (map fst kids, map snd kids) }

        lookup_ie_kids_all :: IE GhcPs -> LIEWrappedName GhcPs -> GlobalRdrElt
                      -> RnM [GlobalRdrElt]
        lookup_ie_kids_all :: IE GhcPs
    -> LIEWrappedName GhcPs
    -> GlobalRdrEltX GREInfo
    -> RnM [GlobalRdrEltX GREInfo]
    lookup_ie_kids_all IE GhcPs
    ie (L SrcSpanAnnA
    _ IEWrappedName GhcPs
    rdr) GlobalRdrEltX GREInfo
    gre =
          do { let name :: Name
    name = GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    gre
                   gres :: [GlobalRdrEltX GREInfo]
    gres = NameEnv [GlobalRdrEltX GREInfo] -> Name -> [GlobalRdrEltX GREInfo]
    forall a. NameEnv [a] -> Name -> [a]
    findChildren NameEnv [GlobalRdrEltX GREInfo]
    kids_env Name
    name
             ; RdrName -> [GlobalRdrEltX GREInfo] -> TcRn ()
    addUsedKids (IEWrappedName GhcPs -> IdP GhcPs
    forall (p :: Pass). IEWrappedName (GhcPass p) -> IdP (GhcPass p)
    ieWrappedName IEWrappedName GhcPs
    rdr) [GlobalRdrEltX GREInfo]
    gres
             ; Bool -> TcRn () -> TcRn ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when ([GlobalRdrEltX GREInfo] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [GlobalRdrEltX GREInfo]
    gres) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                if Name -> Bool
    isTyConName Name
    name
                then TcRnMessage -> TcRn ()
    addTcRnDiagnostic (GlobalRdrEltX GREInfo -> TcRnMessage
    TcRnDodgyExports GlobalRdrEltX GREInfo
    gre)
                else -- This occurs when you export T(..), but
                     -- only import T abstractly, or T is a synonym.
                     TcRnMessage -> TcRn ()
    addErr (IE GhcPs -> TcRnMessage
    TcRnExportHiddenComponents IE GhcPs
    ie)
             ; [GlobalRdrEltX GREInfo] -> RnM [GlobalRdrEltX GREInfo]
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [GlobalRdrEltX GREInfo]
    gres }

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

        -- Runs for every Name
        -- - If there is no new warning, flags that the old warning should not be
        --     included (since a warning should only be emitted if all
        --     of the export statements have a warning)
        -- - If the Name already has a warning, adds it
        process_warning :: ExportWarnSpanNames       -- Old aggregate data about warnins
                        -> DontWarnExportNames       -- Old names not to warn about
                        -> [Name]                              -- Names to warn about
                        -> Maybe (LWarningTxt GhcPs) -- Warning
                        -> SrcSpan                             -- Span of the export list item
                        -> RnM (ExportWarnSpanNames, -- Aggregate data about the warnings
                                DontWarnExportNames, -- Names not to warn about in the end
                                                     -- (when there was a non-warned export)
                                Maybe (LWarningTxt GhcRn)) -- Renamed warning
        process_warning :: ExportWarnSpanNames
    -> DontWarnExportNames
    -> [Name]
    -> Maybe (LWarningTxt GhcPs)
    -> SrcSpan
    -> RnM
         (ExportWarnSpanNames, DontWarnExportNames,
          Maybe (LWarningTxt GhcRn))
    process_warning ExportWarnSpanNames
    export_warn_spans
                        DontWarnExportNames
    dont_warn_export
                        [Name]
    names Maybe (LWarningTxt GhcPs)
    Nothing SrcSpan
    loc
          = (ExportWarnSpanNames, DontWarnExportNames,
     Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcRn)))
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (ExportWarnSpanNames, DontWarnExportNames,
          Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcRn)))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ( ExportWarnSpanNames
    export_warn_spans
                   , (Name -> DontWarnExportNames -> DontWarnExportNames)
    -> DontWarnExportNames -> [Name] -> DontWarnExportNames
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr Name -> DontWarnExportNames -> DontWarnExportNames
    update_dont_warn_export
                           DontWarnExportNames
    dont_warn_export [Name]
    names
                   , Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcRn))
    forall a. Maybe a
    Nothing )
          where
            update_dont_warn_export :: Name -> DontWarnExportNames -> DontWarnExportNames
            update_dont_warn_export :: Name -> DontWarnExportNames -> DontWarnExportNames
    update_dont_warn_export Name
    name DontWarnExportNames
    dont_warn_export'
              = (SrcSpan -> NonEmpty SrcSpan -> NonEmpty SrcSpan)
    -> (SrcSpan -> NonEmpty SrcSpan)
    -> DontWarnExportNames
    -> Name
    -> SrcSpan
    -> DontWarnExportNames
    forall a b.
    (a -> b -> b) -> (a -> b) -> NameEnv b -> Name -> a -> NameEnv b
    extendNameEnv_Acc SrcSpan -> NonEmpty SrcSpan -> NonEmpty SrcSpan
    forall a. a -> NonEmpty a -> NonEmpty a
    (NE.<|)
                                  SrcSpan -> NonEmpty SrcSpan
    forall a. a -> NonEmpty a
    NE.singleton
                                  DontWarnExportNames
    dont_warn_export'
                                  Name
    name
                                  SrcSpan
    loc

        process_warning ExportWarnSpanNames
    export_warn_spans
                        DontWarnExportNames
    dont_warn_export
                        [Name]
    names (Just LWarningTxt GhcPs
    warn_txt_ps) SrcSpan
    loc
          = do
              warn_txt_rn <- LWarningTxt GhcPs -> RnM (LWarningTxt GhcRn)
    rnLWarningTxt LWarningTxt GhcPs
    warn_txt_ps
              let new_export_warn_spans = (Name -> (Name, WarningTxt GhcRn, SrcSpan))
    -> [Name] -> ExportWarnSpanNames
    forall a b. (a -> b) -> [a] -> [b]
    map (, GenLocated SrcSpanAnnP (WarningTxt GhcRn) -> WarningTxt GhcRn
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnP (WarningTxt GhcRn)
    warn_txt_rn, SrcSpan
    loc) [Name]
    names
              return ( new_export_warn_spans ++ export_warn_spans
                     , dont_warn_export
                     , Just warn_txt_rn )

        -- For each name exported with any warnings throws an error
        --   if there are any exports of that name with a different warning
        aggregate_warnings :: ExportWarnSpanNames
                           -> DontWarnExportNames
                           -> RnM (ExportWarnNames GhcRn)
        aggregate_warnings :: ExportWarnSpanNames
    -> DontWarnExportNames -> RnM (ExportWarnNames GhcRn)
    aggregate_warnings ExportWarnSpanNames
    export_warn_spans DontWarnExportNames
    dont_warn_export
          = ([Maybe (Name, WarningTxt GhcRn)] -> ExportWarnNames GhcRn)
    -> IOEnv (Env TcGblEnv TcLclEnv) [Maybe (Name, WarningTxt GhcRn)]
    -> RnM (ExportWarnNames GhcRn)
    forall a b.
    (a -> b)
    -> IOEnv (Env TcGblEnv TcLclEnv) a
    -> IOEnv (Env TcGblEnv TcLclEnv) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Maybe (Name, WarningTxt GhcRn)] -> ExportWarnNames GhcRn
    forall a. [Maybe a] -> [a]
    catMaybes
          (IOEnv (Env TcGblEnv TcLclEnv) [Maybe (Name, WarningTxt GhcRn)]
     -> RnM (ExportWarnNames GhcRn))
    -> IOEnv (Env TcGblEnv TcLclEnv) [Maybe (Name, WarningTxt GhcRn)]
    -> RnM (ExportWarnNames GhcRn)
    forall a b. (a -> b) -> a -> b
    $ (NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
     -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn)))
    -> [NonEmpty (Name, WarningTxt GhcRn, SrcSpan)]
    -> IOEnv (Env TcGblEnv TcLclEnv) [Maybe (Name, WarningTxt GhcRn)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((Name, NonEmpty (WarningTxt GhcRn, SrcSpan))
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn))
    aggregate_single ((Name, NonEmpty (WarningTxt GhcRn, SrcSpan))
     -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn)))
    -> (NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
        -> (Name, NonEmpty (WarningTxt GhcRn, SrcSpan)))
    -> NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
    -> (Name, NonEmpty (WarningTxt GhcRn, SrcSpan))
    extract_name)
          ([NonEmpty (Name, WarningTxt GhcRn, SrcSpan)]
     -> IOEnv (Env TcGblEnv TcLclEnv) [Maybe (Name, WarningTxt GhcRn)])
    -> [NonEmpty (Name, WarningTxt GhcRn, SrcSpan)]
    -> IOEnv (Env TcGblEnv TcLclEnv) [Maybe (Name, WarningTxt GhcRn)]
    forall a b. (a -> b) -> a -> b
    $ ((Name, WarningTxt GhcRn, SrcSpan)
     -> (Name, WarningTxt GhcRn, SrcSpan) -> Bool)
    -> ExportWarnSpanNames
    -> [NonEmpty (Name, WarningTxt GhcRn, SrcSpan)]
    forall (f :: * -> *) a.
    Foldable f =>
    (a -> a -> Bool) -> f a -> [NonEmpty a]
    NE.groupBy (\(Name
    n1, WarningTxt GhcRn
    _, SrcSpan
    _) (Name
    n2, WarningTxt GhcRn
    _, SrcSpan
    _) -> Name
    n1 Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    n2)
          (ExportWarnSpanNames
     -> [NonEmpty (Name, WarningTxt GhcRn, SrcSpan)])
    -> ExportWarnSpanNames
    -> [NonEmpty (Name, WarningTxt GhcRn, SrcSpan)]
    forall a b. (a -> b) -> a -> b
    $ ((Name, WarningTxt GhcRn, SrcSpan)
     -> (Name, WarningTxt GhcRn, SrcSpan) -> Ordering)
    -> ExportWarnSpanNames -> ExportWarnSpanNames
    forall a. (a -> a -> Ordering) -> [a] -> [a]
    sortBy (\(Name
    n1, WarningTxt GhcRn
    _, SrcSpan
    _) (Name
    n2, WarningTxt GhcRn
    _, SrcSpan
    _) -> Name
    n1 Name -> Name -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` Name
    n2) ExportWarnSpanNames
    export_warn_spans
          where
            extract_name :: NE.NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
                         -> (Name, NE.NonEmpty (WarningTxt GhcRn, SrcSpan))
            extract_name :: NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
    -> (Name, NonEmpty (WarningTxt GhcRn, SrcSpan))
    extract_name l :: NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
    l@((Name
    name, WarningTxt GhcRn
    _, SrcSpan
    _) NE.:| ExportWarnSpanNames
    _)
              = (Name
    name, ((Name, WarningTxt GhcRn, SrcSpan) -> (WarningTxt GhcRn, SrcSpan))
    -> NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
    -> NonEmpty (WarningTxt GhcRn, SrcSpan)
    forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
    NE.map (\(Name
    _, WarningTxt GhcRn
    warn_txt, SrcSpan
    span) -> (WarningTxt GhcRn
    warn_txt, SrcSpan
    span)) NonEmpty (Name, WarningTxt GhcRn, SrcSpan)
    l)

            aggregate_single :: (Name, NE.NonEmpty (WarningTxt GhcRn, SrcSpan))
                             -> RnM (Maybe (Name, WarningTxt GhcRn))
            aggregate_single :: (Name, NonEmpty (WarningTxt GhcRn, SrcSpan))
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn))
    aggregate_single (Name
    name, (WarningTxt GhcRn
    warn_txt_rn, SrcSpan
    loc) NE.:| [(WarningTxt GhcRn, SrcSpan)]
    warn_spans)
              = do
                  -- Emit an error if the warnings differ
                  case [SrcSpan] -> Maybe (NonEmpty SrcSpan)
    forall a. [a] -> Maybe (NonEmpty a)
    NE.nonEmpty [SrcSpan]
    spans_different of
                    Maybe (NonEmpty SrcSpan)
    Nothing -> () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
                    Just NonEmpty SrcSpan
    spans_different
                      -> SrcSpan -> TcRnMessage -> TcRn ()
    addErrAt SrcSpan
    loc (Name -> NonEmpty SrcSpan -> TcRnMessage
    TcRnDifferentExportWarnings Name
    name NonEmpty SrcSpan
    spans_different)
                  -- Emit a warning if some export list items do not have a warning
                  case DontWarnExportNames -> Name -> Maybe (NonEmpty SrcSpan)
    forall a. NameEnv a -> Name -> Maybe a
    lookupNameEnv DontWarnExportNames
    dont_warn_export Name
    name of
                    Maybe (NonEmpty SrcSpan)
    Nothing -> Maybe (Name, WarningTxt GhcRn)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (Name, WarningTxt GhcRn)
     -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn)))
    -> Maybe (Name, WarningTxt GhcRn)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn))
    forall a b. (a -> b) -> a -> b
    $ (Name, WarningTxt GhcRn) -> Maybe (Name, WarningTxt GhcRn)
    forall a. a -> Maybe a
    Just (Name
    name, WarningTxt GhcRn
    warn_txt_rn)
                    Just NonEmpty SrcSpan
    not_warned_spans -> do
                      SrcSpan -> TcRnMessage -> TcRn ()
    addDiagnosticAt SrcSpan
    loc (Name -> NonEmpty SrcSpan -> TcRnMessage
    TcRnIncompleteExportWarnings Name
    name NonEmpty SrcSpan
    not_warned_spans)
                      Maybe (Name, WarningTxt GhcRn)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (Name, WarningTxt GhcRn))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Name, WarningTxt GhcRn)
    forall a. Maybe a
    Nothing
              where
                spans_different :: [SrcSpan]
    spans_different = ((WarningTxt GhcRn, SrcSpan) -> SrcSpan)
    -> [(WarningTxt GhcRn, SrcSpan)] -> [SrcSpan]
    forall a b. (a -> b) -> [a] -> [b]
    map (WarningTxt GhcRn, SrcSpan) -> SrcSpan
    forall a b. (a, b) -> b
    snd ([(WarningTxt GhcRn, SrcSpan)] -> [SrcSpan])
    -> [(WarningTxt GhcRn, SrcSpan)] -> [SrcSpan]
    forall a b. (a -> b) -> a -> b
    $ ((WarningTxt GhcRn, SrcSpan) -> Bool)
    -> [(WarningTxt GhcRn, SrcSpan)] -> [(WarningTxt GhcRn, SrcSpan)]
    forall a. (a -> Bool) -> [a] -> [a]
    filter (Bool -> Bool
    not (Bool -> Bool)
    -> ((WarningTxt GhcRn, SrcSpan) -> Bool)
    -> (WarningTxt GhcRn, SrcSpan)
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WarningTxt GhcRn -> WarningTxt GhcRn -> Bool
    forall p1 p2. WarningTxt p1 -> WarningTxt p2 -> Bool
    warningTxtSame WarningTxt GhcRn
    warn_txt_rn (WarningTxt GhcRn -> Bool)
    -> ((WarningTxt GhcRn, SrcSpan) -> WarningTxt GhcRn)
    -> (WarningTxt GhcRn, SrcSpan)
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (WarningTxt GhcRn, SrcSpan) -> WarningTxt GhcRn
    forall a b. (a, b) -> a
    fst) [(WarningTxt GhcRn, SrcSpan)]
    warn_spans

        -------------
        lookup_doc_ie :: LIE GhcPs -> RnM (Maybe (LIE GhcRn))
        lookup_doc_ie :: LIE GhcPs -> RnM (Maybe (LIE GhcRn))
    lookup_doc_ie (L SrcSpanAnnA
    loc (IEGroup XIEGroup GhcPs
    _ Int
    lev ExportDoc GhcPs
    doc)) = do
          doc' <- ExportDoc GhcPs -> IOEnv (Env TcGblEnv TcLclEnv) (LHsDoc GhcRn)
    rnLHsDoc ExportDoc GhcPs
    doc
          pure $ Just (L loc (IEGroup noExtField lev doc'))
        lookup_doc_ie (L SrcSpanAnnA
    loc (IEDoc XIEDoc GhcPs
    _ ExportDoc GhcPs
    doc))       = do
          doc' <- ExportDoc GhcPs -> IOEnv (Env TcGblEnv TcLclEnv) (LHsDoc GhcRn)
    rnLHsDoc ExportDoc GhcPs
    doc
          pure $ Just (L loc (IEDoc noExtField doc'))
        lookup_doc_ie (L SrcSpanAnnA
    loc (IEDocNamed XIEDocNamed GhcPs
    _ String
    str))
          = Maybe (LIE GhcRn) -> RnM (Maybe (LIE GhcRn))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Maybe (LIE GhcRn) -> RnM (Maybe (LIE GhcRn)))
    -> Maybe (LIE GhcRn) -> RnM (Maybe (LIE GhcRn))
    forall a b. (a -> b) -> a -> b
    $ GenLocated SrcSpanAnnA (IE GhcRn)
    -> Maybe (GenLocated SrcSpanAnnA (IE GhcRn))
    forall a. a -> Maybe a
    Just (SrcSpanAnnA -> IE GhcRn -> GenLocated SrcSpanAnnA (IE GhcRn)
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnA
    loc (XIEDocNamed GhcRn -> String -> IE GhcRn
    forall pass. XIEDocNamed pass -> String -> IE pass
    IEDocNamed XIEDocNamed GhcRn
    NoExtField
    noExtField String
    str))
        lookup_doc_ie LIE GhcPs
    _ = Maybe (GenLocated SrcSpanAnnA (IE GhcRn))
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (Maybe (GenLocated SrcSpanAnnA (IE GhcRn)))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (GenLocated SrcSpanAnnA (IE GhcRn))
    forall a. Maybe a
    Nothing

        -- In an export item M.T(A,B,C), we want to treat the uses of
        -- A,B,C as if they were M.A, M.B, M.C
        -- Happily pickGREs does just the right thing
        addUsedKids :: RdrName -> [GlobalRdrElt] -> RnM ()
        addUsedKids :: RdrName -> [GlobalRdrEltX GREInfo] -> TcRn ()
    addUsedKids RdrName
    parent_rdr [GlobalRdrEltX GREInfo]
    kid_gres
          = DeprecationWarnings -> [GlobalRdrEltX GREInfo] -> TcRn ()
    addUsedGREs DeprecationWarnings
    ExportDeprecationWarnings (RdrName -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo]
    forall info.
    RdrName -> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
    pickGREs RdrName
    parent_rdr [GlobalRdrEltX GREInfo]
    kid_gres)

    -- Renaming and typechecking of exports happens after everything else has
    -- been typechecked.

    {-
    Note [Modules without a module header]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The Haskell 2010 report says in section 5.1:

    >> An abbreviated form of module, consisting only of the module body, is
    >> permitted. If this is used, the header is assumed to be
    >> ‘module Main(main) where’.

    For modules without a module header, this is implemented the
    following way:

    If the module has a main function in scope:
       Then create a module header and export the main function,
       as if a module header like ‘module Main(main) where...’ would exist.
       This has the effect to mark the main function and all top level
       functions called directly or indirectly via main as 'used',
       and later on, unused top-level functions can be reported correctly.
       There is no distinction between GHC and GHCi.
    If the module has several main functions in scope:
       Then generate a header as above. The ambiguity is reported later in
       module  `GHC.Tc.Module` function `check_main`.
    If the module has NO main function:
       Then export all top-level functions. This marks all top level
       functions as 'used'.
       In GHCi this has the effect, that we don't get any 'non-used' warnings.
       In GHC, however, the 'has-main-module' check in GHC.Tc.Module.checkMain
       fires, and we get the error:
          The IO action ‘main’ is not defined in module ‘Main’
    -}

    -- Renaming exports lists is a minefield. Five different things can appear in
    -- children export lists ( T(A, B, C) ).
    -- 1. Record selectors
    -- 2. Type constructors
    -- 3. Data constructors
    -- 4. Pattern Synonyms
    -- 5. Pattern Synonym Selectors
    --
    -- However, things get put into weird name spaces.
    -- 1. Some type constructors are parsed as variables (-.->) for example.
    -- 2. All data constructors are parsed as type constructors
    -- 3. When there is ambiguity, we default type constructors to data
    -- constructors and require the explicit `type` keyword for type
    -- constructors.
    --
    -- This function first establishes the possible namespaces that an
    -- identifier might be in (`choosePossibleNameSpaces`).
    --
    -- Then for each namespace in turn, tries to find the correct identifier
    -- there returning the first positive result or the first terminating
    -- error.
    --

    lookupChildrenExport :: Name -> [LIEWrappedName GhcPs]
                         -> RnM ([(LIEWrappedName GhcRn, GlobalRdrElt)])
    lookupChildrenExport :: Name
    -> [LIEWrappedName GhcPs]
    -> RnM [(LIEWrappedName GhcRn, GlobalRdrEltX GREInfo)]
    lookupChildrenExport Name
    spec_parent [LIEWrappedName GhcPs]
    rdr_items = (GenLocated SrcSpanAnnA (IEWrappedName GhcPs)
     -> TcRn
          (GenLocated SrcSpanAnnA (IEWrappedName GhcRn),
           GlobalRdrEltX GREInfo))
    -> [GenLocated SrcSpanAnnA (IEWrappedName GhcPs)]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [(GenLocated SrcSpanAnnA (IEWrappedName GhcRn),
           GlobalRdrEltX GREInfo)]
    forall a b. (a -> TcRn b) -> [a] -> TcRn [b]
    mapAndReportM LIEWrappedName GhcPs
    -> RnM (LIEWrappedName GhcRn, GlobalRdrEltX GREInfo)
    GenLocated SrcSpanAnnA (IEWrappedName GhcPs)
    -> TcRn
         (GenLocated SrcSpanAnnA (IEWrappedName GhcRn),
          GlobalRdrEltX GREInfo)
    doOne [LIEWrappedName GhcPs]
    [GenLocated SrcSpanAnnA (IEWrappedName GhcPs)]
    rdr_items
        where
            -- Process an individual child
            doOne :: LIEWrappedName GhcPs
                  -> RnM (LIEWrappedName GhcRn, GlobalRdrElt)
            doOne :: LIEWrappedName GhcPs
    -> RnM (LIEWrappedName GhcRn, GlobalRdrEltX GREInfo)
    doOne LIEWrappedName GhcPs
    n = do

              let bareName :: RdrName
    bareName = (IEWrappedName GhcPs -> IdP GhcPs
    IEWrappedName GhcPs -> RdrName
    forall (p :: Pass). IEWrappedName (GhcPass p) -> IdP (GhcPass p)
    ieWrappedName (IEWrappedName GhcPs -> RdrName)
    -> (GenLocated SrcSpanAnnA (IEWrappedName GhcPs)
        -> IEWrappedName GhcPs)
    -> GenLocated SrcSpanAnnA (IEWrappedName GhcPs)
    -> RdrName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (IEWrappedName GhcPs) -> IEWrappedName GhcPs
    forall l e. GenLocated l e -> e
    unLoc) LIEWrappedName GhcPs
    GenLocated SrcSpanAnnA (IEWrappedName GhcPs)
    n
                  what_lkup :: LookupChild
                  what_lkup :: LookupChild
    what_lkup =
                    LookupChild
                      { wantedParent :: Name
    wantedParent       = Name
    spec_parent
                      , lookupDataConFirst :: Bool
    lookupDataConFirst = Bool
    True
                      , prioritiseParent :: Bool
    prioritiseParent   = Bool
    False -- See T11970.
                      }

                    -- Do not report export list declaration deprecations
              name <-  Bool
    -> DeprecationWarnings
    -> Name
    -> RdrName
    -> LookupChild
    -> RnM ChildLookupResult
    lookupSubBndrOcc_helper Bool
    False DeprecationWarnings
    ExportDeprecationWarnings
                            Name
    spec_parent RdrName
    bareName LookupChild
    what_lkup
              traceRn "lookupChildrenExport" (ppr name)
              -- Default to data constructors for slightly better error
              -- messages
              let unboundName :: RdrName
                  unboundName = if RdrName -> NameSpace
    rdrNameSpace RdrName
    bareName NameSpace -> NameSpace -> Bool
    forall a. Eq a => a -> a -> Bool
    == NameSpace
    varName
                                then RdrName
    bareName
                                else RdrName -> NameSpace -> RdrName
    setRdrNameSpace RdrName
    bareName NameSpace
    dataName

              case name of
                ChildLookupResult
    NameNotFound ->
                  do { ub <- RdrName -> RnM Name
    reportUnboundName RdrName
    unboundName
                     ; let l = GenLocated SrcSpanAnnA (IEWrappedName GhcPs) -> SrcSpanAnnA
    forall l e. GenLocated l e -> l
    getLoc LIEWrappedName GhcPs
    GenLocated SrcSpanAnnA (IEWrappedName GhcPs)
    n
                           gre = GREInfo -> Parent -> Name -> GlobalRdrEltX GREInfo
    mkLocalGRE GREInfo
    UnboundGRE Parent
    NoParent Name
    ub
                     ; return (L l (IEName noExtField (L (l2l l) ub)), gre)}
                FoundChild child :: GlobalRdrEltX GREInfo
    child@(GRE { gre_name :: forall info. GlobalRdrEltX info -> Name
    gre_name = Name
    child_nm, gre_par :: forall info. GlobalRdrEltX info -> Parent
    gre_par = Parent
    par }) ->
                  do { Name -> Parent -> Name -> TcRn ()
    checkPatSynParent Name
    spec_parent Parent
    par Name
    child_nm
                     ; (GenLocated SrcSpanAnnA (IEWrappedName GhcRn),
     GlobalRdrEltX GREInfo)
    -> TcRn
         (GenLocated SrcSpanAnnA (IEWrappedName GhcRn),
          GlobalRdrEltX GREInfo)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (LIEWrappedName GhcPs -> IdP GhcRn -> LIEWrappedName GhcRn
    replaceLWrappedName LIEWrappedName GhcPs
    n IdP GhcRn
    Name
    child_nm, GlobalRdrEltX GREInfo
    child)
                     }
                IncorrectParent Name
    p GlobalRdrEltX GREInfo
    c [Name]
    gs -> Name
    -> Name
    -> [Name]
    -> TcRn
         (GenLocated SrcSpanAnnA (IEWrappedName GhcRn),
          GlobalRdrEltX GREInfo)
    forall a. Name -> Name -> [Name] -> TcM a
    failWithDcErr Name
    p (GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    c) [Name]
    gs

    -- Note [Typing Pattern Synonym Exports]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -- It proved quite a challenge to precisely specify which pattern synonyms
    -- should be allowed to be bundled with which type constructors.
    -- In the end it was decided to be quite liberal in what we allow. Below is
    -- how Simon described the implementation.
    --
    -- "Personally I think we should Keep It Simple.  All this talk of
    --  satisfiability makes me shiver.  I suggest this: allow T( P ) in all
    --   situations except where `P`'s type is ''visibly incompatible'' with
    --   `T`.
    --
    --    What does "visibly incompatible" mean?  `P` is visibly incompatible
    --    with
    --     `T` if
    --       * `P`'s type is of form `... -> S t1 t2`
    --       * `S` is a data/newtype constructor distinct from `T`
    --
    --  Nothing harmful happens if we allow `P` to be exported with
    --  a type it can't possibly be useful for, but specifying a tighter
    --  relationship is very awkward as you have discovered."
    --
    -- Note that this allows *any* pattern synonym to be bundled with any
    -- datatype type constructor. For example, the following pattern `P` can be
    -- bundled with any type.
    --
    -- ```
    -- pattern P :: (A ~ f) => f
    -- ```
    --
    -- So we provide basic type checking in order to help the user out, most
    -- pattern synonyms are defined with definite type constructors, but don't
    -- actually prevent a library author completely confusing their users if
    -- they want to.
    --
    -- So, we check for exactly four things
    -- 1. The name arises from a pattern synonym definition. (Either a pattern
    --    synonym constructor or a pattern synonym selector)
    -- 2. The pattern synonym is only bundled with a datatype or newtype.
    -- 3. Check that the head of the result type constructor is an actual type
    --    constructor and not a type variable. (See above example)
    -- 4. Is so, check that this type constructor is the same as the parent
    --    type constructor.
    --
    --
    -- Note [Types of TyCon]
    -- ~~~~~~~~~~~~~~~~~~~~~
    -- This check appears to be overly complicated, Richard asked why it
    -- is not simply just `isAlgTyCon`. The answer for this is that
    -- a classTyCon is also an `AlgTyCon` which we explicitly want to disallow.
    -- (It is either a newtype or data depending on the number of methods)
    --

    -- | Given a resolved name in the children export list and a parent. Decide
    -- whether we are allowed to export the child with the parent.
    -- Invariant: gre_par == NoParent
    -- See Note [Typing Pattern Synonym Exports]
    checkPatSynParent :: Name    -- ^ Alleged parent type constructor
                                 -- User wrote T( P, Q )
                      -> Parent  -- The parent of P we discovered
                      -> Name
                           -- ^ Either a
                           --   a) Pattern Synonym Constructor
                           --   b) A pattern synonym selector
                      -> TcM ()  -- Fails if wrong parent
    checkPatSynParent :: Name -> Parent -> Name -> TcRn ()
    checkPatSynParent Name
    _ (ParentIs {}) Name
    _
      = () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    checkPatSynParent Name
    parent Parent
    NoParent Name
    nm
      | Name -> Bool
    isUnboundName Name
    parent -- Avoid an error cascade
      = () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

      | Bool
    otherwise
      = do { parent_ty_con  <- Name -> TcM TyCon
    tcLookupTyCon  Name
    parent
           ; mpat_syn_thing <- tcLookupGlobal nm

            -- 1. Check that the Id was actually from a thing associated with patsyns
           ; case mpat_syn_thing of
                AnId Id
    i | Id -> Bool
    isId Id
    i
                       , RecSelId { sel_tycon :: IdDetails -> RecSelParent
    sel_tycon = RecSelPatSyn PatSyn
    p } <- Id -> IdDetails
    idDetails Id
    i
                       -> SDoc -> TyCon -> PatSyn -> TcRn ()
    handle_pat_syn (Name -> SDoc
    selErr Name
    nm) TyCon
    parent_ty_con PatSyn
    p

                AConLike (PatSynCon PatSyn
    p) -> SDoc -> TyCon -> PatSyn -> TcRn ()
    handle_pat_syn (PatSyn -> SDoc
    psErr PatSyn
    p) TyCon
    parent_ty_con PatSyn
    p

                TyThing
    _ -> Name -> Name -> [Name] -> TcRn ()
    forall a. Name -> Name -> [Name] -> TcM a
    failWithDcErr Name
    parent Name
    nm [] }
      where
        psErr :: PatSyn -> SDoc
    psErr  = String -> PatSyn -> SDoc
    forall o. Outputable o => String -> o -> SDoc
    exportErrCtxt String
    "pattern synonym"
        selErr :: Name -> SDoc
    selErr = String -> Name -> SDoc
    forall o. Outputable o => String -> o -> SDoc
    exportErrCtxt String
    "pattern synonym record selector"

        handle_pat_syn :: SDoc
                       -> TyCon      -- Parent TyCon
                       -> PatSyn     -- Corresponding bundled PatSyn
                                     -- and pretty printed origin
                       -> TcM ()
        handle_pat_syn :: SDoc -> TyCon -> PatSyn -> TcRn ()
    handle_pat_syn SDoc
    doc TyCon
    ty_con PatSyn
    pat_syn

          -- 2. See Note [Types of TyCon]
          | Bool -> Bool
    not (Bool -> Bool) -> Bool -> Bool
    forall a b. (a -> b) -> a -> b
    $ TyCon -> Bool
    isTyConWithSrcDataCons TyCon
    ty_con
          = SDoc -> TcRn () -> TcRn ()
    forall a. SDoc -> TcM a -> TcM a
    addErrCtxt SDoc
    doc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWithTc TcRnMessage
    TcRnPatSynBundledWithNonDataCon

          -- 3. Is the head a type variable?
          | Maybe TyCon
    Nothing <- Maybe TyCon
    mtycon
          = () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
          -- 4. Ok. Check they are actually the same type constructor.

          | Just TyCon
    p_ty_con <- Maybe TyCon
    mtycon, TyCon
    p_ty_con TyCon -> TyCon -> Bool
    forall a. Eq a => a -> a -> Bool
    /= TyCon
    ty_con
          = SDoc -> TcRn () -> TcRn ()
    forall a. SDoc -> TcM a -> TcM a
    addErrCtxt SDoc
    doc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWithTc
              (Type -> Type -> TcRnMessage
    TcRnPatSynBundledWithWrongType Type
    expected_res_ty Type
    res_ty)

          -- 5. We passed!
          | Bool
    otherwise
          = () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

          where
            expected_res_ty :: Type
    expected_res_ty = TyCon -> [Type] -> Type
    mkTyConApp TyCon
    ty_con ([Id] -> [Type]
    mkTyVarTys (TyCon -> [Id]
    tyConTyVars TyCon
    ty_con))
            ([Id]
    _, [Type]
    _, [Id]
    _, [Type]
    _, [Scaled Type]
    _, Type
    res_ty) = PatSyn -> ([Id], [Type], [Id], [Type], [Scaled Type], Type)
    patSynSig PatSyn
    pat_syn
            mtycon :: Maybe TyCon
    mtycon = (TyCon, [Type]) -> TyCon
    forall a b. (a, b) -> a
    fst ((TyCon, [Type]) -> TyCon) -> Maybe (TyCon, [Type]) -> Maybe TyCon
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> HasCallStack => Type -> Maybe (TyCon, [Type])
    Type -> Maybe (TyCon, [Type])
    tcSplitTyConApp_maybe Type
    res_ty

    {-===========================================================================-}

    -- | Insert the given 'GlobalRdrElt's into the 'ExportOccMap', checking that
    -- each of the given 'GlobalRdrElt's does not appear multiple times in
    -- the 'ExportOccMap', as per Note [Exporting duplicate declarations].
    check_occs :: ExportOccMap -> IE GhcPs -> [GlobalRdrElt] -> RnM ExportOccMap
    check_occs :: ExportOccMap
    -> IE GhcPs -> [GlobalRdrEltX GREInfo] -> RnM ExportOccMap
    check_occs ExportOccMap
    occs IE GhcPs
    ie [GlobalRdrEltX GREInfo]
    gres
      -- 'gres' are the entities specified by 'ie'
      = do { drf <- Extension -> IOEnv (Env TcGblEnv TcLclEnv) Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.DuplicateRecordFields
           ; foldlM (check drf) occs gres }
      where

        -- Check for distinct children exported with the same OccName (an error) or
        -- for duplicate exports of the same child (a warning).
        --
        -- See Note [Exporting duplicate declarations].
        check :: Bool -> ExportOccMap -> GlobalRdrElt -> RnM ExportOccMap
        check :: Bool -> ExportOccMap -> GlobalRdrEltX GREInfo -> RnM ExportOccMap
    check Bool
    drf_enabled ExportOccMap
    occs GlobalRdrEltX GREInfo
    gre
          = case ExportOccMap
    -> GlobalRdrEltX GREInfo -> Either (Name, IE GhcPs) ExportOccMap
    try_insert ExportOccMap
    occs GlobalRdrEltX GREInfo
    gre of
              Right ExportOccMap
    occs'
                -- If DuplicateRecordFields is not enabled, also make sure
                -- that we are not exporting two fields with the same occNameFS
                -- under different namespaces.
                --
                -- See Note [Exporting duplicate record fields].
                | Bool
    drf_enabled Bool -> Bool -> Bool
    || Bool -> Bool
    not (OccName -> Bool
    isFieldOcc OccName
    child_occ)
                -> ExportOccMap -> RnM ExportOccMap
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ExportOccMap
    occs'
                | Bool
    otherwise
                -> do { let flds :: [(Name, IE GhcPs)]
    flds = ((Name, IE GhcPs) -> Bool)
    -> [(Name, IE GhcPs)] -> [(Name, IE GhcPs)]
    forall a. (a -> Bool) -> [a] -> [a]
    filter (\(Name
    _,IE GhcPs
    ie') -> Bool -> Bool
    not (Bool -> Bool) -> Bool -> Bool
    forall a b. (a -> b) -> a -> b
    $ IE GhcPs -> IE GhcPs -> Bool
    dupFieldExport_ok IE GhcPs
    ie IE GhcPs
    ie')
                                 ([(Name, IE GhcPs)] -> [(Name, IE GhcPs)])
    -> [(Name, IE GhcPs)] -> [(Name, IE GhcPs)]
    forall a b. (a -> b) -> a -> b
    $ ExportOccMap -> FastString -> [(Name, IE GhcPs)]
    forall a. OccEnv a -> FastString -> [a]
    lookupFieldsOccEnv ExportOccMap
    occs (OccName -> FastString
    occNameFS OccName
    child_occ)
                      ; case [(Name, IE GhcPs)]
    flds of { [] -> ExportOccMap -> RnM ExportOccMap
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ExportOccMap
    occs'; (Name, IE GhcPs)
    clash1:[(Name, IE GhcPs)]
    clashes ->
                   do { (GlobalRdrEltX GREInfo, IE GhcPs)
    -> NonEmpty (Name, IE GhcPs) -> TcRn ()
    addDuplicateFieldExportErr (GlobalRdrEltX GREInfo
    gre,IE GhcPs
    ie) ((Name, IE GhcPs)
    clash1 (Name, IE GhcPs) -> [(Name, IE GhcPs)] -> NonEmpty (Name, IE GhcPs)
    forall a. a -> [a] -> NonEmpty a
    NE.:| [(Name, IE GhcPs)]
    clashes)
                      ; ExportOccMap -> RnM ExportOccMap
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ExportOccMap
    occs } } }

              Left (Name
    child', IE GhcPs
    ie')
                | Name
    child Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    child' -- Duplicate export of a single Name: a warning.
                -> do { Bool -> TcRnMessage -> TcRn ()
    warnIf (Bool -> Bool
    not (Name -> IE GhcPs -> IE GhcPs -> Bool
    dupExport_ok Name
    child IE GhcPs
    ie IE GhcPs
    ie')) (GlobalRdrEltX GREInfo -> IE GhcPs -> IE GhcPs -> TcRnMessage
    TcRnDuplicateExport GlobalRdrEltX GREInfo
    gre IE GhcPs
    ie IE GhcPs
    ie')
                      ; ExportOccMap -> RnM ExportOccMap
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ExportOccMap
    occs }

                | Bool
    otherwise       -- Same OccName but different Name: an error.
                ->  do { global_env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv
                       ; addErr (exportClashErr global_env child' child ie' ie)
                       ; return occs }
          where
            child :: Name
    child = GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    gre
            child_occ :: OccName
    child_occ = Name -> OccName
    forall name. HasOccName name => name -> OccName
    occName Name
    child

        -- Try to insert a child into the map, returning Left if there is something
        -- already exported with the same OccName.
        try_insert :: ExportOccMap -> GlobalRdrElt -> Either (Name, IE GhcPs) ExportOccMap
        try_insert :: ExportOccMap
    -> GlobalRdrEltX GREInfo -> Either (Name, IE GhcPs) ExportOccMap
    try_insert ExportOccMap
    occs GlobalRdrEltX GREInfo
    child
          = case ExportOccMap -> OccName -> Maybe (Name, IE GhcPs)
    forall a. OccEnv a -> OccName -> Maybe a
    lookupOccEnv ExportOccMap
    occs OccName
    occ of
              Maybe (Name, IE GhcPs)
    Nothing -> ExportOccMap -> Either (Name, IE GhcPs) ExportOccMap
    forall a b. b -> Either a b
    Right (ExportOccMap -> OccName -> (Name, IE GhcPs) -> ExportOccMap
    forall a. OccEnv a -> OccName -> a -> OccEnv a
    extendOccEnv ExportOccMap
    occs OccName
    occ (GlobalRdrEltX GREInfo -> Name
    forall info. GlobalRdrEltX info -> Name
    greName GlobalRdrEltX GREInfo
    child, IE GhcPs
    ie))
              Just (Name, IE GhcPs)
    x  -> (Name, IE GhcPs) -> Either (Name, IE GhcPs) ExportOccMap
    forall a b. a -> Either a b
    Left (Name, IE GhcPs)
    x
          where
            occ :: OccName
    occ = GlobalRdrEltX GREInfo -> OccName
    forall info. GlobalRdrEltX info -> OccName
    greOccName GlobalRdrEltX GREInfo
    child

    -- | Is it OK for the given name to be exported by both export items?
    --
    -- See Note [Exporting duplicate declarations].
    dupExport_ok :: Name -> IE GhcPs -> IE GhcPs -> Bool
    dupExport_ok :: Name -> IE GhcPs -> IE GhcPs -> Bool
    dupExport_ok Name
    child IE GhcPs
    ie1 IE GhcPs
    ie2
      = Bool -> Bool
    not (  IE GhcPs -> Bool
    forall {pass}. IE pass -> Bool
    single IE GhcPs
    ie1 Bool -> Bool -> Bool
    || IE GhcPs -> Bool
    forall {pass}. IE pass -> Bool
    single IE GhcPs
    ie2
            Bool -> Bool -> Bool
    || (IE GhcPs -> Bool
    explicit_in IE GhcPs
    ie1 Bool -> Bool -> Bool
    && IE GhcPs -> Bool
    explicit_in IE GhcPs
    ie2) )
      where
        explicit_in :: IE GhcPs -> Bool
    explicit_in (IEModuleContents {}) = Bool
    False                   -- module M
        explicit_in (IEThingAll XIEThingAll GhcPs
    _ LIEWrappedName GhcPs
    r Maybe (ExportDoc GhcPs)
    _)
          = Name -> OccName
    forall name. HasOccName name => name -> OccName
    occName Name
    child OccName -> OccName -> Bool
    forall a. Eq a => a -> a -> Bool
    == RdrName -> OccName
    rdrNameOcc (IEWrappedName GhcPs -> IdP GhcPs
    forall (p :: Pass). IEWrappedName (GhcPass p) -> IdP (GhcPass p)
    ieWrappedName (IEWrappedName GhcPs -> IdP GhcPs)
    -> IEWrappedName GhcPs -> IdP GhcPs
    forall a b. (a -> b) -> a -> b
    $ GenLocated SrcSpanAnnA (IEWrappedName GhcPs) -> IEWrappedName GhcPs
    forall l e. GenLocated l e -> e
    unLoc LIEWrappedName GhcPs
    GenLocated SrcSpanAnnA (IEWrappedName GhcPs)
    r)  -- T(..)
        explicit_in IE GhcPs
    _              = Bool
    True

        single :: IE pass -> Bool
    single IEVar {}      = Bool
    True
        single IEThingAbs {} = Bool
    True
        single IE pass
    _             = Bool
    False

    exportErrCtxt :: Outputable o => String -> o -> SDoc
    exportErrCtxt :: forall o. Outputable o => String -> o -> SDoc
    exportErrCtxt String
    herald o
    exp =
      String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "In the" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text (String
    herald String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ":") SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> o -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr o
    exp

    addExportErrCtxt :: (OutputableBndrId p)
                     => IE (GhcPass p) -> TcM a -> TcM a
    addExportErrCtxt :: forall (p :: Pass) a.
    OutputableBndrId p =>
    IE (GhcPass p) -> TcM a -> TcM a
    addExportErrCtxt IE (GhcPass p)
    ie = SDoc -> TcM a -> TcM a
    forall a. SDoc -> TcM a -> TcM a
    addErrCtxt SDoc
    exportCtxt
      where
        exportCtxt :: SDoc
    exportCtxt = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "In the export:" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> IE (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IE (GhcPass p)
    ie

    failWithDcErr :: Name -> Name -> [Name] -> TcM a
    failWithDcErr :: forall a. Name -> Name -> [Name] -> TcM a
    failWithDcErr Name
    parent Name
    child [Name]
    parents = do
      ty_thing <- Name -> TcM TyThing
    tcLookupGlobal Name
    child
      failWithTc $ TcRnExportedParentChildMismatch parent ty_thing child parents

    exportClashErr :: GlobalRdrEnv
                   -> Name -> Name
                   -> IE GhcPs -> IE GhcPs
                   -> TcRnMessage
    exportClashErr :: GlobalRdrEnv -> Name -> Name -> IE GhcPs -> IE GhcPs -> TcRnMessage
    exportClashErr GlobalRdrEnv
    global_env Name
    child1 Name
    child2 IE GhcPs
    ie1 IE GhcPs
    ie2
      = OccName
    -> GlobalRdrEltX GREInfo
    -> IE GhcPs
    -> GlobalRdrEltX GREInfo
    -> IE GhcPs
    -> TcRnMessage
    TcRnConflictingExports OccName
    occ GlobalRdrEltX GREInfo
    gre1' IE GhcPs
    ie1' GlobalRdrEltX GREInfo
    gre2' IE GhcPs
    ie2'
      where
        occ :: OccName
    occ = Name -> OccName
    forall name. HasOccName name => name -> OccName
    occName Name
    child1
        -- get_gre finds a GRE for the Name, so that we can show its provenance
        gre1 :: GlobalRdrEltX GREInfo
    gre1 = Name -> GlobalRdrEltX GREInfo
    get_gre Name
    child1
        gre2 :: GlobalRdrEltX GREInfo
    gre2 = Name -> GlobalRdrEltX GREInfo
    get_gre Name
    child2
        get_gre :: Name -> GlobalRdrEltX GREInfo
    get_gre Name
    child
            = GlobalRdrEltX GREInfo
    -> Maybe (GlobalRdrEltX GREInfo) -> GlobalRdrEltX GREInfo
    forall a. a -> Maybe a -> a
    fromMaybe (String -> SDoc -> GlobalRdrEltX GREInfo
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "exportClashErr" (Name -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Name
    child))
                        (GlobalRdrEnv -> Name -> Maybe (GlobalRdrEltX GREInfo)
    forall info.
    Outputable info =>
    GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
    lookupGRE_Name GlobalRdrEnv
    global_env Name
    child)
        (GlobalRdrEltX GREInfo
    gre1', IE GhcPs
    ie1', GlobalRdrEltX GREInfo
    gre2', IE GhcPs
    ie2') =
          case SrcSpan -> SrcSpan -> Ordering
    SrcLoc.leftmost_smallest (GlobalRdrEltX GREInfo -> SrcSpan
    forall info. Outputable info => GlobalRdrEltX info -> SrcSpan
    greSrcSpan GlobalRdrEltX GREInfo
    gre1) (GlobalRdrEltX GREInfo -> SrcSpan
    forall info. Outputable info => GlobalRdrEltX info -> SrcSpan
    greSrcSpan GlobalRdrEltX GREInfo
    gre2) of
            Ordering
    LT -> (GlobalRdrEltX GREInfo
    gre1, IE GhcPs
    ie1, GlobalRdrEltX GREInfo
    gre2, IE GhcPs
    ie2)
            Ordering
    GT -> (GlobalRdrEltX GREInfo
    gre2, IE GhcPs
    ie2, GlobalRdrEltX GREInfo
    gre1, IE GhcPs
    ie1)
            Ordering
    EQ -> String
    -> (GlobalRdrEltX GREInfo, IE GhcPs, GlobalRdrEltX GREInfo,
        IE GhcPs)
    forall a. HasCallStack => String -> a
    panic String
    "exportClashErr: clashing exports have identical location"

    addDuplicateFieldExportErr :: (GlobalRdrElt, IE GhcPs)
                               -> NE.NonEmpty (Name, IE GhcPs)
                               -> RnM ()
    addDuplicateFieldExportErr :: (GlobalRdrEltX GREInfo, IE GhcPs)
    -> NonEmpty (Name, IE GhcPs) -> TcRn ()
    addDuplicateFieldExportErr (GlobalRdrEltX GREInfo, IE GhcPs)
    gre NonEmpty (Name, IE GhcPs)
    others
      = do { rdr_env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv
           ; let lkup = String -> Maybe (GlobalRdrEltX GREInfo) -> GlobalRdrEltX GREInfo
    forall a. HasCallStack => String -> Maybe a -> a
    expectJust String
    "addDuplicateFieldExportErr" (Maybe (GlobalRdrEltX GREInfo) -> GlobalRdrEltX GREInfo)
    -> (Name -> Maybe (GlobalRdrEltX GREInfo))
    -> Name
    -> GlobalRdrEltX GREInfo
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GlobalRdrEnv -> Name -> Maybe (GlobalRdrEltX GREInfo)
    forall info.
    Outputable info =>
    GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
    lookupGRE_Name GlobalRdrEnv
    rdr_env
                 other_gres = ((Name, IE GhcPs) -> (GlobalRdrEltX GREInfo, IE GhcPs))
    -> NonEmpty (Name, IE GhcPs)
    -> NonEmpty (GlobalRdrEltX GREInfo, IE GhcPs)
    forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((Name -> GlobalRdrEltX GREInfo)
    -> (Name, IE GhcPs) -> (GlobalRdrEltX GREInfo, IE GhcPs)
    forall b c d. (b -> c) -> (b, d) -> (c, d)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first Name -> GlobalRdrEltX GREInfo
    lkup) NonEmpty (Name, IE GhcPs)
    others
           ; addErr (TcRnDuplicateFieldExport gre other_gres) }

    -- | Is it OK to export two clashing duplicate record fields coming from the
    -- given export items, with @-XDisambiguateRecordFields@ disabled?
    --
    -- See Note [Exporting duplicate record fields].
    dupFieldExport_ok :: IE GhcPs -> IE GhcPs -> Bool
    dupFieldExport_ok :: IE GhcPs -> IE GhcPs -> Bool
    dupFieldExport_ok IE GhcPs
    ie1 IE GhcPs
    ie2
      | IEModuleContents {} <- IE GhcPs
    ie1
      , IE GhcPs
    ie2 IE GhcPs -> IE GhcPs -> Bool
    forall a. Eq a => a -> a -> Bool
    == IE GhcPs
    ie1
      = Bool
    True
      | Bool
    otherwise
      = Bool
    False

    {- Note [Exporting duplicate declarations]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    We want to check that two different export items don't have both attempt to export
    the same thing. What do we mean precisely? There are three main situations to consider:

      1. We export two distinct Names with identical OccNames. This is an error.
      2. We export the same Name in two different export items. This is usually
         a warning, but see below.
      3. We export a duplicate record field, and DuplicateRecordFields is not enabled.
         See Note [Exporting duplicate record fields].

    Concerning (2), we sometimes want to allow a duplicate export of a given Name,
    as #4478 points out. The logic, as implemented in dupExport_ok, is that we
    do not allow a given Name to be exported by two IEs iff either:

      - the Name is mentioned explicitly in both IEs, or
      - one of the IEs mentions the name *alone*.

    Examples:

      NOT OK: module M( f, f )

        f is mentioned explicitly in both

      NOT OK: module M( fmap, Functor(..) )
      NOT OK: module M( module Data.Functor, fmap )

        One of the import items mentions fmap alone, which is also
        exported by the other export item.

      OK:
        module M( module A, module B ) where
          import A( f )
          import B( f )

      OK: (#2436)
        module M( C(..), T(..) ) where
          class C a where { data T a }
          instance C Int where { data T Int = TInt }

      OK: (#2436)
        module Foo ( T ) where
          data family T a
        module Bar ( T(..), module Foo ) where
          import Foo
          data instance T Int = TInt

    Note [Exporting duplicate record fields]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Record fields belonging to different datatypes belong to different namespaces,
    as explained in Note [Record field namespacing] in GHC.Types.Name.Occurrence.
    However, when the DuplicateRecordFields extension is NOT enabled, we want to
    prevent users from exporting record fields that share the same underlying occNameFS.

    To enforce this, in check_occs, when inserting a new record field into the ExportOccMap
    and DuplicateRecordFields is not enabled, we also look up any clashing record fields,
    and report an error.

    Note however that the clash check has an extra wrinkle, similar to dupExport_ok,
    as we want to allow the following:

      {-# LANGUAGE DuplicateRecordFields #-}
      module M1 where
        data D1 = MkD1 { foo :: Int }
        data D2 = MkD2 { foo :: Bool }

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

       module M2 ( module M1 ) where
         import M1

    That is, we should be allowed to re-export the whole module M1, without reporting
    any nameclashes, even though M1 exports duplicate record fields and we have not
    enabled -XDuplicateRecordFields in M2. This logic is implemented in
    dupFieldExport_ok. See test case NoDRFModuleExport.

    Note that this logic only applies to whole-module imports, as we don't want
    to allow the following:

      module N0 where
        data family D a
      module N1 where
        import N0
        data instance D Int = MkDInt { foo :: Int }
      module N2 where
        import N0
        data instance D Bool = MkDBool { foo :: Int }

      module N (D(..)) where
        import N1
        import N2

    Here, the single export item D(..) of N exports both record fields,
    `$fld:MkDInt:foo` and `$fld:MkDBool:foo`, so we have to reject the program.
    See test overloadedrecfldsfail10.
    -}