    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE TypeFamilies     #-}

    {-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}
    {-

    This module contains miscellaneous functions related to renaming.

    -}

    module GHC.Rename.Utils (
            checkDupRdrNames, checkDupRdrNamesN, checkShadowedRdrNames,
            checkDupNames, checkDupAndShadowedNames, dupNamesErr,
            checkTupSize, checkCTupSize,
            addFvRn, mapFvRn, mapMaybeFvRn,
            warnUnusedMatches, warnUnusedTypePatterns,
            warnUnusedTopBinds, warnUnusedLocalBinds,
            warnForallIdentifier,
            checkUnusedRecordWildcard,
            mkFieldEnv,
            badQualBndrErr, typeAppErr, badFieldConErr,
            wrapGenSpan, genHsVar, genLHsVar, genHsApp, genHsApps, genAppType,
            genHsIntegralLit, genHsTyLit,

            newLocalBndrRn, newLocalBndrsRn,

            bindLocalNames, bindLocalNamesFV,

            addNameClashErrRn,

            checkInferredVars,
            noNestedForallsContextsErr, addNoNestedForallsContextsErr
    )

    where

    import GHC.Prelude

    import GHC.Core.Type
    import GHC.Hs
    import GHC.Types.Name.Reader
    import GHC.Tc.Errors.Types
    import GHC.Tc.Errors.Ppr (withHsDocContext)
    import GHC.Tc.Utils.Env
    import GHC.Tc.Utils.Monad
    import GHC.Types.Error
    import GHC.Types.Name
    import GHC.Types.Name.Set
    import GHC.Types.Name.Env
    import GHC.Core.DataCon
    import GHC.Types.SrcLoc as SrcLoc
    import GHC.Types.SourceFile
    import GHC.Types.SourceText ( SourceText(..), IntegralLit )
    import GHC.Utils.Outputable
    import GHC.Utils.Panic
    import GHC.Utils.Misc
    import GHC.Types.Basic  ( TopLevelFlag(..) )
    import GHC.Data.List.SetOps ( removeDups )
    import GHC.Data.Maybe ( whenIsJust )
    import GHC.Driver.Session
    import GHC.Data.FastString
    import Control.Monad
    import Data.List (find, sortBy)
    import GHC.Settings.Constants ( mAX_TUPLE_SIZE, mAX_CTUPLE_SIZE )
    import qualified Data.List.NonEmpty as NE
    import qualified GHC.LanguageExtensions as LangExt
    import GHC.Data.Bag

    {-
    *********************************************************
    *                                                      *
    \subsection{Binding}
    *                                                      *
    *********************************************************
    -}

    newLocalBndrRn :: LocatedN RdrName -> RnM Name
    -- Used for non-top-level binders.  These should
    -- never be qualified.
    newLocalBndrRn :: GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RnM Name
    newLocalBndrRn (L SrcSpanAnn' (EpAnn NameAnn)
    loc RdrName
    rdr_name)
      | Just Name
    name <- RdrName -> Maybe Name
    isExact_maybe RdrName
    rdr_name
      = Name -> RnM Name
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name -- This happens in code generated by Template Haskell
                    -- See Note [Binders in Template Haskell] in "GHC.ThToHs"
      | Bool
    otherwise
      = do { Bool
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (RdrName -> Bool
    isUnqual RdrName
    rdr_name)
                    (SrcSpan -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErrAt (SrcSpanAnn' (EpAnn NameAnn) -> SrcSpan
    forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnn' (EpAnn NameAnn)
    loc) (RdrName -> TcRnMessage
    badQualBndrErr RdrName
    rdr_name))
           ; Unique
    uniq <- TcRnIf TcGblEnv TcLclEnv Unique
    forall gbl lcl. TcRnIf gbl lcl Unique
    newUnique
           ; Name -> RnM Name
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Unique -> OccName -> SrcSpan -> Name
    mkInternalName Unique
    uniq (RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name) (SrcSpanAnn' (EpAnn NameAnn) -> SrcSpan
    forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnn' (EpAnn NameAnn)
    loc)) }

    newLocalBndrsRn :: [LocatedN RdrName] -> RnM [Name]
    newLocalBndrsRn :: [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName] -> RnM [Name]
    newLocalBndrsRn = (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RnM Name)
    -> [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName] -> RnM [Name]
    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 GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RnM Name
    newLocalBndrRn

    bindLocalNames :: [Name] -> RnM a -> RnM a
    bindLocalNames :: forall a. [Name] -> RnM a -> RnM a
    bindLocalNames [Name]
    names
      = (TcLclEnv -> TcLclEnv)
    -> TcRnIf TcGblEnv TcLclEnv a -> TcRnIf TcGblEnv TcLclEnv a
    forall lcl gbl a.
    (lcl -> lcl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
    updLclEnv ((TcLclEnv -> TcLclEnv)
     -> TcRnIf TcGblEnv TcLclEnv a -> TcRnIf TcGblEnv TcLclEnv a)
    -> (TcLclEnv -> TcLclEnv)
    -> TcRnIf TcGblEnv TcLclEnv a
    -> TcRnIf TcGblEnv TcLclEnv a
    forall a b. (a -> b) -> a -> b
    $ \ TcLclEnv
    lcl_env ->
        let th_level :: Int
    th_level  = ThStage -> Int
    thLevel (TcLclEnv -> ThStage
    tcl_th_ctxt TcLclEnv
    lcl_env)
            th_bndrs' :: NameEnv (TopLevelFlag, Int)
    th_bndrs' = NameEnv (TopLevelFlag, Int)
    -> [(Name, (TopLevelFlag, Int))] -> NameEnv (TopLevelFlag, Int)
    forall a. NameEnv a -> [(Name, a)] -> NameEnv a
    extendNameEnvList (TcLclEnv -> NameEnv (TopLevelFlag, Int)
    tcl_th_bndrs TcLclEnv
    lcl_env)
                        [ (Name
    n, (TopLevelFlag
    NotTopLevel, Int
    th_level)) | Name
    n <- [Name]
    names ]
            rdr_env' :: LocalRdrEnv
    rdr_env'  = LocalRdrEnv -> [Name] -> LocalRdrEnv
    extendLocalRdrEnvList (TcLclEnv -> LocalRdrEnv
    tcl_rdr TcLclEnv
    lcl_env) [Name]
    names
        in TcLclEnv
    lcl_env { tcl_th_bndrs :: NameEnv (TopLevelFlag, Int)
    tcl_th_bndrs = NameEnv (TopLevelFlag, Int)
    th_bndrs'
                   , tcl_rdr :: LocalRdrEnv
    tcl_rdr      = LocalRdrEnv
    rdr_env' }

    bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
    bindLocalNamesFV :: forall a. [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
    bindLocalNamesFV [Name]
    names RnM (a, FreeVars)
    enclosed_scope
      = do  { (a
    result, FreeVars
    fvs) <- [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
    forall a. [Name] -> RnM a -> RnM a
    bindLocalNames [Name]
    names RnM (a, FreeVars)
    enclosed_scope
            ; (a, FreeVars) -> RnM (a, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    result, [Name] -> FreeVars -> FreeVars
    delFVs [Name]
    names FreeVars
    fvs) }

    -------------------------------------
    checkDupRdrNames :: [LocatedN RdrName] -> RnM ()
    -- Check for duplicated names in a binding group
    checkDupRdrNames :: [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkDupRdrNames [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    rdr_names_w_loc
      = (NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> [NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ ((GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> SrcSpan)
    -> NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall n.
    Outputable n =>
    (n -> SrcSpan) -> NonEmpty n -> IOEnv (Env TcGblEnv TcLclEnv) ()
    dupNamesErr GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> SrcSpan
    forall a e. GenLocated (SrcSpanAnn' a) e -> SrcSpan
    getLocA) [NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)]
    dups
      where
        ([GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    _, [NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)]
    dups) = (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
     -> GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> Ordering)
    -> [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    -> ([GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName],
        [NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)])
    forall a. (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
    removeDups (\GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    n1 GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    n2 -> GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    n1 RdrName -> RdrName -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    n2) [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    rdr_names_w_loc

    checkDupRdrNamesN :: [LocatedN RdrName] -> RnM ()
    -- Check for duplicated names in a binding group
    checkDupRdrNamesN :: [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkDupRdrNamesN [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    rdr_names_w_loc
      = (NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> [NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ ((GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> SrcSpan)
    -> NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall n.
    Outputable n =>
    (n -> SrcSpan) -> NonEmpty n -> IOEnv (Env TcGblEnv TcLclEnv) ()
    dupNamesErr GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> SrcSpan
    forall a e. GenLocated (SrcSpanAnn' a) e -> SrcSpan
    getLocA) [NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)]
    dups
      where
        ([GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    _, [NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)]
    dups) = (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
     -> GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> Ordering)
    -> [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    -> ([GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName],
        [NonEmpty (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName)])
    forall a. (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
    removeDups (\GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    n1 GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    n2 -> GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    n1 RdrName -> RdrName -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    n2) [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    rdr_names_w_loc

    checkDupNames :: [Name] -> RnM ()
    -- Check for duplicated names in a binding group
    checkDupNames :: [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkDupNames [Name]
    names = [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_dup_names ((Name -> Bool) -> [Name] -> [Name]
    forall a. (a -> Bool) -> [a] -> [a]
    filterOut Name -> Bool
    isSystemName [Name]
    names)
                    -- See Note [Binders in Template Haskell] in "GHC.ThToHs"

    check_dup_names :: [Name] -> RnM ()
    check_dup_names :: [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_dup_names [Name]
    names
      = (NonEmpty Name -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> [NonEmpty Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ ((Name -> SrcSpan)
    -> NonEmpty Name -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall n.
    Outputable n =>
    (n -> SrcSpan) -> NonEmpty n -> IOEnv (Env TcGblEnv TcLclEnv) ()
    dupNamesErr Name -> SrcSpan
    nameSrcSpan) [NonEmpty Name]
    dups
      where
        ([Name]
    _, [NonEmpty Name]
    dups) = (Name -> Name -> Ordering) -> [Name] -> ([Name], [NonEmpty Name])
    forall a. (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
    removeDups (\Name
    n1 Name
    n2 -> Name -> OccName
    nameOccName Name
    n1 OccName -> OccName -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` Name -> OccName
    nameOccName Name
    n2) [Name]
    names

    ---------------------
    checkShadowedRdrNames :: [LocatedN RdrName] -> RnM ()
    checkShadowedRdrNames :: [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkShadowedRdrNames [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    loc_rdr_names
      = do { (GlobalRdrEnv, LocalRdrEnv)
    envs <- TcRn (GlobalRdrEnv, LocalRdrEnv)
    getRdrEnvs
           ; (GlobalRdrEnv, LocalRdrEnv)
    -> (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
        -> (SrcSpan, OccName))
    -> [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a.
    (GlobalRdrEnv, LocalRdrEnv)
    -> (a -> (SrcSpan, OccName))
    -> [a]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkShadowedOccs (GlobalRdrEnv, LocalRdrEnv)
    envs GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    -> (SrcSpan, OccName)
    forall {a}.
    GenLocated (SrcSpanAnn' a) RdrName -> (SrcSpan, OccName)
    get_loc_occ [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    filtered_rdrs }
      where
        filtered_rdrs :: [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    filtered_rdrs = (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> Bool)
    -> [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    -> [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    forall a. (a -> Bool) -> [a] -> [a]
    filterOut (RdrName -> Bool
    isExact (RdrName -> Bool)
    -> (GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RdrName)
    -> GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc) [GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName]
    loc_rdr_names
                    -- See Note [Binders in Template Haskell] in "GHC.ThToHs"
        get_loc_occ :: GenLocated (SrcSpanAnn' a) RdrName -> (SrcSpan, OccName)
    get_loc_occ (L SrcSpanAnn' a
    loc RdrName
    rdr) = (SrcSpanAnn' a -> SrcSpan
    forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnn' a
    loc,RdrName -> OccName
    rdrNameOcc RdrName
    rdr)

    checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
    checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv)
    -> [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkDupAndShadowedNames (GlobalRdrEnv, LocalRdrEnv)
    envs [Name]
    names
      = do { [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_dup_names [Name]
    filtered_names
           ; (GlobalRdrEnv, LocalRdrEnv)
    -> (Name -> (SrcSpan, OccName))
    -> [Name]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a.
    (GlobalRdrEnv, LocalRdrEnv)
    -> (a -> (SrcSpan, OccName))
    -> [a]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkShadowedOccs (GlobalRdrEnv, LocalRdrEnv)
    envs Name -> (SrcSpan, OccName)
    get_loc_occ [Name]
    filtered_names }
      where
        filtered_names :: [Name]
    filtered_names = (Name -> Bool) -> [Name] -> [Name]
    forall a. (a -> Bool) -> [a] -> [a]
    filterOut Name -> Bool
    isSystemName [Name]
    names
                    -- See Note [Binders in Template Haskell] in "GHC.ThToHs"
        get_loc_occ :: Name -> (SrcSpan, OccName)
    get_loc_occ Name
    name = (Name -> SrcSpan
    nameSrcSpan Name
    name, Name -> OccName
    nameOccName Name
    name)

    -------------------------------------
    checkShadowedOccs :: (GlobalRdrEnv, LocalRdrEnv)
                      -> (a -> (SrcSpan, OccName))
                      -> [a] -> RnM ()
    checkShadowedOccs :: forall a.
    (GlobalRdrEnv, LocalRdrEnv)
    -> (a -> (SrcSpan, OccName))
    -> [a]
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkShadowedOccs (GlobalRdrEnv
    global_env,LocalRdrEnv
    local_env) a -> (SrcSpan, OccName)
    get_loc_occ [a]
    ns
      = WarningFlag
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall gbl lcl.
    WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    whenWOptM WarningFlag
    Opt_WarnNameShadowing (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $
        do  { String -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    traceRn String
    "checkShadowedOccs:shadow" ([(SrcSpan, OccName)] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ((a -> (SrcSpan, OccName)) -> [a] -> [(SrcSpan, OccName)]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> (SrcSpan, OccName)
    get_loc_occ [a]
    ns))
            ; (a -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> [a] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ a -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_shadow [a]
    ns }
      where
        check_shadow :: a -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_shadow a
    n
            | OccName -> Bool
    startsWithUnderscore OccName
    occ = () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()  -- Do not report shadowing for "_x"
                                                    -- See #3262
            | Just Name
    n <- Maybe Name
    mb_local = ShadowedNameProvenance -> IOEnv (Env TcGblEnv TcLclEnv) ()
    complain (SrcLoc -> ShadowedNameProvenance
    ShadowedNameProvenanceLocal (Name -> SrcLoc
    nameSrcLoc Name
    n))
            | Bool
    otherwise = do { [GlobalRdrElt]
    gres' <- (GlobalRdrElt -> IOEnv (Env TcGblEnv TcLclEnv) Bool)
    -> [GlobalRdrElt] -> IOEnv (Env TcGblEnv TcLclEnv) [GlobalRdrElt]
    forall (m :: * -> *) a.
    Applicative m =>
    (a -> m Bool) -> [a] -> m [a]
    filterM GlobalRdrElt -> IOEnv (Env TcGblEnv TcLclEnv) Bool
    is_shadowed_gre [GlobalRdrElt]
    gres
                             ; Bool
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (Bool -> Bool
    not (Bool -> Bool)
    -> ([GlobalRdrElt] -> Bool) -> [GlobalRdrElt] -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [GlobalRdrElt] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null ([GlobalRdrElt] -> Bool) -> [GlobalRdrElt] -> Bool
    forall a b. (a -> b) -> a -> b
    $ [GlobalRdrElt]
    gres') (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ ShadowedNameProvenance -> IOEnv (Env TcGblEnv TcLclEnv) ()
    complain ([GlobalRdrElt] -> ShadowedNameProvenance
    ShadowedNameProvenanceGlobal [GlobalRdrElt]
    gres') }
            where
              (SrcSpan
    loc,OccName
    occ) = a -> (SrcSpan, OccName)
    get_loc_occ a
    n
              mb_local :: Maybe Name
    mb_local  = LocalRdrEnv -> OccName -> Maybe Name
    lookupLocalRdrOcc LocalRdrEnv
    local_env OccName
    occ
              gres :: [GlobalRdrElt]
    gres      = RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
    lookupGRE_RdrName (OccName -> RdrName
    mkRdrUnqual OccName
    occ) GlobalRdrEnv
    global_env
                    -- Make an Unqualified RdrName and look that up, so that
                    -- we don't find any GREs that are in scope qualified-only

              complain :: ShadowedNameProvenance -> IOEnv (Env TcGblEnv TcLclEnv) ()
    complain ShadowedNameProvenance
    provenance = SrcSpan -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addDiagnosticAt SrcSpan
    loc (OccName -> ShadowedNameProvenance -> TcRnMessage
    TcRnShadowedName OccName
    occ ShadowedNameProvenance
    provenance)

        is_shadowed_gre :: GlobalRdrElt -> RnM Bool
            -- Returns False for record selectors that are shadowed, when
            -- punning or wild-cards are on (cf #2723)
        is_shadowed_gre :: GlobalRdrElt -> IOEnv (Env TcGblEnv TcLclEnv) Bool
    is_shadowed_gre GlobalRdrElt
    gre | GlobalRdrElt -> Bool
    isRecFldGRE GlobalRdrElt
    gre
            = do { DynFlags
    dflags <- IOEnv (Env TcGblEnv TcLclEnv) DynFlags
    forall (m :: * -> *). HasDynFlags m => m DynFlags
    getDynFlags
                 ; Bool -> IOEnv (Env TcGblEnv TcLclEnv) Bool
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool -> IOEnv (Env TcGblEnv TcLclEnv) Bool)
    -> Bool -> IOEnv (Env TcGblEnv TcLclEnv) Bool
    forall a b. (a -> b) -> a -> b
    $ Bool -> Bool
    not (Extension -> DynFlags -> Bool
    xopt Extension
    LangExt.NamedFieldPuns DynFlags
    dflags
                                 Bool -> Bool -> Bool
    || Extension -> DynFlags -> Bool
    xopt Extension
    LangExt.RecordWildCards DynFlags
    dflags) }
        is_shadowed_gre GlobalRdrElt
    _other = Bool -> IOEnv (Env TcGblEnv TcLclEnv) Bool
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    True

    -------------------------------------
    -- | Throw an error message if a user attempts to quantify an inferred type
    -- variable in a place where specificity cannot be observed. For example,
    -- @forall {a}. [a] -> [a]@ would be rejected to the inferred type variable
    -- @{a}@, but @forall a. [a] -> [a]@ would be accepted.
    -- See @Note [Unobservably inferred type variables]@.
    checkInferredVars :: HsDocContext
                      -> Maybe SDoc
                      -- ^ The error msg if the signature is not allowed to contain
                      --   manually written inferred variables.
                      -> LHsSigType GhcPs
                      -> RnM ()
    checkInferredVars :: HsDocContext
    -> Maybe SDoc
    -> LHsSigType GhcPs
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkInferredVars HsDocContext
    _    Maybe SDoc
    Nothing    LHsSigType GhcPs
    _  = () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
    checkInferredVars HsDocContext
    ctxt (Just SDoc
    msg) LHsSigType GhcPs
    ty =
      let bndrs :: [HsTyVarBndr Specificity GhcPs]
    bndrs = LHsSigType GhcPs -> [HsTyVarBndr Specificity GhcPs]
    sig_ty_bndrs LHsSigType GhcPs
    ty
      in case (HsTyVarBndr Specificity GhcPs -> Bool)
    -> [HsTyVarBndr Specificity GhcPs]
    -> Maybe (HsTyVarBndr Specificity GhcPs)
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
    find (Specificity -> Specificity -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) Specificity
    InferredSpec (Specificity -> Bool)
    -> (HsTyVarBndr Specificity GhcPs -> Specificity)
    -> HsTyVarBndr Specificity GhcPs
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsTyVarBndr Specificity GhcPs -> Specificity
    forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> flag
    hsTyVarBndrFlag) [HsTyVarBndr Specificity GhcPs]
    bndrs of
        Maybe (HsTyVarBndr Specificity GhcPs)
    Nothing -> () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
        Just HsTyVarBndr Specificity GhcPs
    _  -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr (TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (HsDocContext -> SDoc -> SDoc
    withHsDocContext HsDocContext
    ctxt SDoc
    msg)
      where
        sig_ty_bndrs :: LHsSigType GhcPs -> [HsTyVarBndr Specificity GhcPs]
        sig_ty_bndrs :: LHsSigType GhcPs -> [HsTyVarBndr Specificity GhcPs]
    sig_ty_bndrs (L SrcSpanAnnA
    _ (HsSig{sig_bndrs :: forall pass. HsSigType pass -> HsOuterSigTyVarBndrs pass
    sig_bndrs = HsOuterSigTyVarBndrs GhcPs
    outer_bndrs}))
          = (GenLocated SrcSpanAnnA (HsTyVarBndr Specificity GhcPs)
     -> HsTyVarBndr Specificity GhcPs)
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr Specificity GhcPs)]
    -> [HsTyVarBndr Specificity GhcPs]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated SrcSpanAnnA (HsTyVarBndr Specificity GhcPs)
    -> HsTyVarBndr Specificity GhcPs
    forall l e. GenLocated l e -> e
    unLoc (HsOuterSigTyVarBndrs GhcPs
    -> [LHsTyVarBndr Specificity (NoGhcTc GhcPs)]
    forall flag (p :: Pass).
    HsOuterTyVarBndrs flag (GhcPass p)
    -> [LHsTyVarBndr flag (NoGhcTc (GhcPass p))]
    hsOuterExplicitBndrs HsOuterSigTyVarBndrs GhcPs
    outer_bndrs)

    {-
    Note [Unobservably inferred type variables]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    While GHC's parser allows the use of inferred type variables
    (e.g., `forall {a}. <...>`) just about anywhere that type variable binders can
    appear, there are some situations where the distinction between inferred and
    specified type variables cannot be observed. For example, consider this
    instance declaration:

      instance forall {a}. Eq (T a) where ...

    Making {a} inferred is pointless, as there is no way for user code to
    "apply" an instance declaration in a way where the inferred/specified
    distinction would make a difference. (Notably, there is no opportunity
    for visible type application of an instance declaration.) Anyone who
    writes such code is likely confused, so in an attempt to be helpful,
    we emit an error message if a user writes code like this. The
    checkInferredVars function is responsible for implementing this
    restriction.

    It turns out to be somewhat cumbersome to enforce this restriction in
    certain cases.  Specifically:

    * Quantified constraints. In the type `f :: (forall {a}. C a) => Proxy Int`,
      there is no way to observe that {a} is inferred. Nevertheless, actually
      rejecting this code would be tricky, as we would need to reject
      `forall {a}. <...>` as a constraint but *accept* other uses of
      `forall {a}. <...>` as a type (e.g., `g :: (forall {a}. a -> a) -> b -> b`).
      This is quite tedious to do in practice, so we don't bother.

    * Default method type signatures (#18432). These are tricky because inferred
      type variables can appear nested, e.g.,

        class C a where
          m         :: forall b. a -> b -> forall c.   c -> c
          default m :: forall b. a -> b -> forall {c}. c -> c
          m _ _ = id

      Robustly checking for nested, inferred type variables ends up being a pain,
      so we don't try to do this.

    For now, we simply allow inferred quantifiers to be specified here,
    even though doing so is pointless. All we lose is a warning.

    Aside from the places where we already use checkInferredVars, most of
    the other places where inferred vars don't make sense are in any case
    already prohibited from having foralls /at all/.  For example:

      instance forall a. forall {b}. Eq (Either a b) where ...

    Here the nested `forall {b}` is already prohibited. (See
    Note [No nested foralls or contexts in instance types] in GHC.Hs.Type).
    -}

    -- | Examines a non-outermost type for @forall@s or contexts, which are assumed
    -- to be nested. For example, in the following declaration:
    --
    -- @
    -- instance forall a. forall b. C (Either a b)
    -- @
    --
    -- The outermost @forall a@ is fine, but the nested @forall b@ is not. We
    -- invoke 'noNestedForallsContextsErr' on the type @forall b. C (Either a b)@
    -- to catch the nested @forall@ and create a suitable error message.
    -- 'noNestedForallsContextsErr' returns @'Just' err_msg@ if such a @forall@ or
    -- context is found, and returns @Nothing@ otherwise.
    --
    -- This is currently used in the following places:
    --
    -- * In GADT constructor types (in 'rnConDecl').
    --   See @Note [GADT abstract syntax] (Wrinkle: No nested foralls or contexts)@
    --   in "GHC.Hs.Type".
    --
    -- * In instance declaration types (in 'rnClsIntDecl' and 'rnSrcDerivDecl' in
    --   "GHC.Rename.Module" and 'renameSig' in "GHC.Rename.Bind").
    --   See @Note [No nested foralls or contexts in instance types]@ in
    --   "GHC.Hs.Type".
    noNestedForallsContextsErr :: SDoc -> LHsType GhcRn -> Maybe (SrcSpan, SDoc)
    noNestedForallsContextsErr :: SDoc -> LHsType GhcRn -> Maybe (SrcSpan, SDoc)
    noNestedForallsContextsErr SDoc
    what LHsType GhcRn
    lty =
      case LHsType GhcRn -> LHsType GhcRn
    forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p)
    ignoreParens LHsType GhcRn
    lty of
        L SrcSpanAnnA
    l (HsForAllTy { hst_tele :: forall pass. HsType pass -> HsForAllTelescope pass
    hst_tele = HsForAllTelescope GhcRn
    tele })
          |  HsForAllVis{} <- HsForAllTelescope GhcRn
    tele
             -- The only two places where this function is called correspond to
             -- types of terms, so we give a slightly more descriptive error
             -- message in the event that they contain visible dependent
             -- quantification (currently only allowed in kinds).
          -> (SrcSpan, SDoc) -> Maybe (SrcSpan, SDoc)
    forall a. a -> Maybe a
    Just (SrcSpanAnnA -> SrcSpan
    forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnA
    l, [SDoc] -> SDoc
    vcat [ String -> SDoc
    text String
    "Illegal visible, dependent quantification" SDoc -> SDoc -> SDoc
    <+>
                                  String -> SDoc
    text String
    "in the type of a term"
                                , String -> SDoc
    text String
    "(GHC does not yet support this)" ])
          |  HsForAllInvis{} <- HsForAllTelescope GhcRn
    tele
          -> (SrcSpan, SDoc) -> Maybe (SrcSpan, SDoc)
    forall a. a -> Maybe a
    Just (SrcSpanAnnA -> SrcSpan
    forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnA
    l, SDoc
    nested_foralls_contexts_err)
        L SrcSpanAnnA
    l (HsQualTy {})
          -> (SrcSpan, SDoc) -> Maybe (SrcSpan, SDoc)
    forall a. a -> Maybe a
    Just (SrcSpanAnnA -> SrcSpan
    forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnA
    l, SDoc
    nested_foralls_contexts_err)
        LHsType GhcRn
    _ -> Maybe (SrcSpan, SDoc)
    forall a. Maybe a
    Nothing
      where
        nested_foralls_contexts_err :: SDoc
    nested_foralls_contexts_err =
          SDoc
    what SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "cannot contain nested"
          SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes SDoc
    forAllLit SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    "s or contexts"

    -- | A common way to invoke 'noNestedForallsContextsErr'.
    addNoNestedForallsContextsErr :: HsDocContext -> SDoc -> LHsType GhcRn -> RnM ()
    addNoNestedForallsContextsErr :: HsDocContext
    -> SDoc -> LHsType GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addNoNestedForallsContextsErr HsDocContext
    ctxt SDoc
    what LHsType GhcRn
    lty =
      Maybe (SrcSpan, SDoc)
    -> ((SrcSpan, SDoc) -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenIsJust (SDoc -> LHsType GhcRn -> Maybe (SrcSpan, SDoc)
    noNestedForallsContextsErr SDoc
    what LHsType GhcRn
    lty) (((SrcSpan, SDoc) -> IOEnv (Env TcGblEnv TcLclEnv) ())
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> ((SrcSpan, SDoc) -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ \(SrcSpan
    l, SDoc
    err_msg) ->
        SrcSpan -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErrAt SrcSpan
    l (TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (HsDocContext -> SDoc -> SDoc
    withHsDocContext HsDocContext
    ctxt SDoc
    err_msg)

    {-
    ************************************************************************
    *                                                                      *
    \subsection{Free variable manipulation}
    *                                                                      *
    ************************************************************************
    -}

    -- A useful utility
    addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
    addFvRn :: forall thing.
    FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
    addFvRn FreeVars
    fvs1 RnM (thing, FreeVars)
    thing_inside = do { (thing
    res, FreeVars
    fvs2) <- RnM (thing, FreeVars)
    thing_inside
                                   ; (thing, FreeVars) -> RnM (thing, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (thing
    res, FreeVars
    fvs1 FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    fvs2) }

    mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
    mapFvRn :: forall a b. (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
    mapFvRn a -> RnM (b, FreeVars)
    f [a]
    xs = do [(b, FreeVars)]
    stuff <- (a -> RnM (b, FreeVars))
    -> [a] -> IOEnv (Env TcGblEnv TcLclEnv) [(b, FreeVars)]
    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 a -> RnM (b, FreeVars)
    f [a]
    xs
                      case [(b, FreeVars)] -> ([b], [FreeVars])
    forall a b. [(a, b)] -> ([a], [b])
    unzip [(b, FreeVars)]
    stuff of
                          ([b]
    ys, [FreeVars]
    fvs_s) -> ([b], FreeVars) -> RnM ([b], FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([b]
    ys, [FreeVars] -> FreeVars
    plusFVs [FreeVars]
    fvs_s)

    mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
    mapMaybeFvRn :: forall a b.
    (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
    mapMaybeFvRn a -> RnM (b, FreeVars)
    _ Maybe a
    Nothing = (Maybe b, FreeVars)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe b, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe b
    forall a. Maybe a
    Nothing, FreeVars
    emptyFVs)
    mapMaybeFvRn a -> RnM (b, FreeVars)
    f (Just a
    x) = do { (b
    y, FreeVars
    fvs) <- a -> RnM (b, FreeVars)
    f a
    x; (Maybe b, FreeVars)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe b, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (b -> Maybe b
    forall a. a -> Maybe a
    Just b
    y, FreeVars
    fvs) }

    {-
    ************************************************************************
    *                                                                      *
    \subsection{Envt utility functions}
    *                                                                      *
    ************************************************************************
    -}

    warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
    warnUnusedTopBinds :: [GlobalRdrElt] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedTopBinds [GlobalRdrElt]
    gres
        = WarningFlag
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall gbl lcl.
    WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    whenWOptM WarningFlag
    Opt_WarnUnusedTopBinds
        (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ do TcGblEnv
    env <- TcRnIf TcGblEnv TcLclEnv TcGblEnv
    forall gbl lcl. TcRnIf gbl lcl gbl
    getGblEnv
             let isBoot :: Bool
    isBoot = TcGblEnv -> HscSource
    tcg_src TcGblEnv
    env HscSource -> HscSource -> Bool
    forall a. Eq a => a -> a -> Bool
    == HscSource
    HsBootFile
             let noParent :: GlobalRdrElt -> Bool
    noParent GlobalRdrElt
    gre = case GlobalRdrElt -> Parent
    gre_par GlobalRdrElt
    gre of
                                Parent
    NoParent -> Bool
    True
                                Parent
    _        -> Bool
    False
                 -- Don't warn about unused bindings with parents in
                 -- .hs-boot files, as you are sometimes required to give
                 -- unused bindings (trac #3449).
                 -- HOWEVER, in a signature file, you are never obligated to put a
                 -- definition in the main text.  Thus, if you define something
                 -- and forget to export it, we really DO want to warn.
                 gres' :: [GlobalRdrElt]
    gres' = if Bool
    isBoot then (GlobalRdrElt -> Bool) -> [GlobalRdrElt] -> [GlobalRdrElt]
    forall a. (a -> Bool) -> [a] -> [a]
    filter GlobalRdrElt -> Bool
    noParent [GlobalRdrElt]
    gres
                                   else                 [GlobalRdrElt]
    gres
             [GlobalRdrElt] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedGREs [GlobalRdrElt]
    gres'

    -- | Checks to see if we need to warn for -Wunused-record-wildcards or
    -- -Wredundant-record-wildcards
    checkUnusedRecordWildcard :: SrcSpan
                              -> FreeVars
                              -> Maybe [Name]
                              -> RnM ()
    checkUnusedRecordWildcard :: SrcSpan
    -> FreeVars -> Maybe [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkUnusedRecordWildcard SrcSpan
    _ FreeVars
    _ Maybe [Name]
    Nothing     = () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
    checkUnusedRecordWildcard SrcSpan
    loc FreeVars
    _ (Just []) =
      -- Add a new warning if the .. pattern binds no variables
      SrcSpan
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan SrcSpan
    loc (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ IOEnv (Env TcGblEnv TcLclEnv) ()
    warnRedundantRecordWildcard
    checkUnusedRecordWildcard SrcSpan
    loc FreeVars
    fvs (Just [Name]
    dotdot_names) =
      SrcSpan
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan SrcSpan
    loc (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedRecordWildcard [Name]
    dotdot_names FreeVars
    fvs

    -- | Produce a warning when the `..` pattern binds no new
    -- variables.
    --
    -- @
    --   data P = P { x :: Int }
    --
    --   foo (P{x, ..}) = x
    -- @
    --
    -- The `..` here doesn't bind any variables as `x` is already bound.
    warnRedundantRecordWildcard :: RnM ()
    warnRedundantRecordWildcard :: IOEnv (Env TcGblEnv TcLclEnv) ()
    warnRedundantRecordWildcard =
      WarningFlag
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall gbl lcl.
    WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    whenWOptM WarningFlag
    Opt_WarnRedundantRecordWildcards (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $
        let msg :: TcRnMessage
    msg = DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $
                    DiagnosticReason -> [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainDiagnostic (WarningFlag -> DiagnosticReason
    WarningWithFlag WarningFlag
    Opt_WarnRedundantRecordWildcards)
                                      [GhcHint]
    noHints
                                      SDoc
    redundantWildcardWarning
        in TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addDiagnostic TcRnMessage
    msg

    -- | Produce a warning when no variables bound by a `..` pattern are used.
    --
    -- @
    --   data P = P { x :: Int }
    --
    --   foo (P{..}) = ()
    -- @
    --
    -- The `..` pattern binds `x` but it is not used in the RHS so we issue
    -- a warning.
    warnUnusedRecordWildcard :: [Name] -> FreeVars -> RnM ()
    warnUnusedRecordWildcard :: [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedRecordWildcard [Name]
    ns FreeVars
    used_names = do
      let used :: [Name]
    used = (Name -> Bool) -> [Name] -> [Name]
    forall a. (a -> Bool) -> [a] -> [a]
    filter (Name -> FreeVars -> Bool
    `elemNameSet` FreeVars
    used_names) [Name]
    ns
      String -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    traceRn String
    "warnUnused" ([Name] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [Name]
    ns SDoc -> SDoc -> SDoc
    $$ FreeVars -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr FreeVars
    used_names SDoc -> SDoc -> SDoc
    $$ [Name] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [Name]
    used)
      Bool -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnIf ([Name] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Name]
    used)
        TcRnMessage
    unusedRecordWildcardWarning

    warnUnusedLocalBinds, warnUnusedMatches, warnUnusedTypePatterns
      :: [Name] -> FreeVars -> RnM ()
    warnUnusedLocalBinds :: [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedLocalBinds   = WarningFlag
    -> [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_unused WarningFlag
    Opt_WarnUnusedLocalBinds
    warnUnusedMatches :: [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedMatches      = WarningFlag
    -> [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_unused WarningFlag
    Opt_WarnUnusedMatches
    warnUnusedTypePatterns :: [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedTypePatterns = WarningFlag
    -> [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_unused WarningFlag
    Opt_WarnUnusedTypePatterns

    check_unused :: WarningFlag -> [Name] -> FreeVars -> RnM ()
    check_unused :: WarningFlag
    -> [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    check_unused WarningFlag
    flag [Name]
    bound_names FreeVars
    used_names
      = WarningFlag
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall gbl lcl.
    WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    whenWOptM WarningFlag
    flag (WarningFlag -> [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnused WarningFlag
    flag ((Name -> Bool) -> [Name] -> [Name]
    forall a. (a -> Bool) -> [a] -> [a]
    filterOut (Name -> FreeVars -> Bool
    `elemNameSet` FreeVars
    used_names)
                                                   [Name]
    bound_names))

    warnForallIdentifier :: LocatedN RdrName -> RnM ()
    warnForallIdentifier :: GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnForallIdentifier (L SrcSpanAnn' (EpAnn NameAnn)
    l rdr_name :: RdrName
    rdr_name@(Unqual OccName
    occ))
      | FieldLabelString -> Bool
    isKw (String -> FieldLabelString
    fsLit String
    "forall") Bool -> Bool -> Bool
    || FieldLabelString -> Bool
    isKw (String -> FieldLabelString
    fsLit String
    "∀")
      = SrcSpan -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addDiagnosticAt (SrcSpanAnn' (EpAnn NameAnn) -> SrcSpan
    forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnn' (EpAnn NameAnn)
    l) (RdrName -> TcRnMessage
    TcRnForallIdentifier RdrName
    rdr_name)
      where isKw :: FieldLabelString -> Bool
    isKw = (OccName -> FieldLabelString
    occNameFS OccName
    occ FieldLabelString -> FieldLabelString -> Bool
    forall a. Eq a => a -> a -> Bool
    ==)
    warnForallIdentifier GenLocated (SrcSpanAnn' (EpAnn NameAnn)) RdrName
    _ = () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    -------------------------
    --      Helpers
    warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
    warnUnusedGREs :: [GlobalRdrElt] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedGREs [GlobalRdrElt]
    gres = (GlobalRdrElt -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> [GlobalRdrElt] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ GlobalRdrElt -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedGRE [GlobalRdrElt]
    gres

    -- NB the Names must not be the names of record fields!
    warnUnused :: WarningFlag -> [Name] -> RnM ()
    warnUnused :: WarningFlag -> [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnused WarningFlag
    flag [Name]
    names =
        (Name -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (WarningFlag -> GreName -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnused1 WarningFlag
    flag (GreName -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> (Name -> GreName) -> Name -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> GreName
    NormalGreName) [Name]
    names

    warnUnused1 :: WarningFlag -> GreName -> RnM ()
    warnUnused1 :: WarningFlag -> GreName -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnused1 WarningFlag
    flag GreName
    child
      = Bool
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (GreName -> Bool
    reportable GreName
    child) (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $
        WarningFlag
    -> OccName -> SrcSpan -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addUnusedWarning WarningFlag
    flag
                         (GreName -> OccName
    forall name. HasOccName name => name -> OccName
    occName GreName
    child) (GreName -> SrcSpan
    greNameSrcSpan GreName
    child)
                         (String -> SDoc
    text (String -> SDoc) -> String -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String
    "Defined but not used" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    opt_str)
      where
        opt_str :: String
    opt_str = case WarningFlag
    flag of
                    WarningFlag
    Opt_WarnUnusedTypePatterns -> String
    " on the right hand side"
                    WarningFlag
    _ -> String
    ""

    warnUnusedGRE :: GlobalRdrElt -> RnM ()
    warnUnusedGRE :: GlobalRdrElt -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedGRE gre :: GlobalRdrElt
    gre@(GRE { gre_lcl :: GlobalRdrElt -> Bool
    gre_lcl = Bool
    lcl, gre_imp :: GlobalRdrElt -> Bag ImportSpec
    gre_imp = Bag ImportSpec
    is })
      | Bool
    lcl       = WarningFlag -> GreName -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnused1 WarningFlag
    Opt_WarnUnusedTopBinds (GlobalRdrElt -> GreName
    gre_name GlobalRdrElt
    gre)
      | Bool
    otherwise = Bool
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (GreName -> Bool
    reportable (GlobalRdrElt -> GreName
    gre_name GlobalRdrElt
    gre)) ((ImportSpec -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> Bag ImportSpec -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ ImportSpec -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warn Bag ImportSpec
    is)
      where
        occ :: OccName
    occ = GlobalRdrElt -> OccName
    greOccName GlobalRdrElt
    gre
        warn :: ImportSpec -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warn ImportSpec
    spec = WarningFlag
    -> OccName -> SrcSpan -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addUnusedWarning WarningFlag
    Opt_WarnUnusedTopBinds OccName
    occ SrcSpan
    span SDoc
    msg
            where
               span :: SrcSpan
    span = ImportSpec -> SrcSpan
    importSpecLoc ImportSpec
    spec
               pp_mod :: SDoc
    pp_mod = SDoc -> SDoc
    quotes (ModuleName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (ImportSpec -> ModuleName
    importSpecModule ImportSpec
    spec))
               msg :: SDoc
    msg = String -> SDoc
    text String
    "Imported from" SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_mod SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "but not used"

    -- | Make a map from selector names to field labels and parent tycon
    -- names, to be used when reporting unused record fields.
    mkFieldEnv :: GlobalRdrEnv -> NameEnv (FieldLabelString, Parent)
    mkFieldEnv :: GlobalRdrEnv -> NameEnv (FieldLabelString, Parent)
    mkFieldEnv GlobalRdrEnv
    rdr_env = [(Name, (FieldLabelString, Parent))]
    -> NameEnv (FieldLabelString, Parent)
    forall a. [(Name, a)] -> NameEnv a
    mkNameEnv [ (GlobalRdrElt -> Name
    greMangledName GlobalRdrElt
    gre, (FieldLabel -> FieldLabelString
    flLabel FieldLabel
    fl, GlobalRdrElt -> Parent
    gre_par GlobalRdrElt
    gre))
                                   | [GlobalRdrElt]
    gres <- GlobalRdrEnv -> [[GlobalRdrElt]]
    forall a. OccEnv a -> [a]
    nonDetOccEnvElts GlobalRdrEnv
    rdr_env
                                   , GlobalRdrElt
    gre <- [GlobalRdrElt]
    gres
                                   , Just FieldLabel
    fl <- [GlobalRdrElt -> Maybe FieldLabel
    greFieldLabel GlobalRdrElt
    gre]
                                   ]

    -- | Should we report the fact that this 'Name' is unused? The
    -- 'OccName' may differ from 'nameOccName' due to
    -- DuplicateRecordFields.
    reportable :: GreName -> Bool
    reportable :: GreName -> Bool
    reportable GreName
    child
      | NormalGreName Name
    name <- GreName
    child
      , Name -> Bool
    isWiredInName Name
    name = Bool
    False    -- Don't report unused wired-in names
                                      -- Otherwise we get a zillion warnings
                                      -- from Data.Tuple
      | Bool
    otherwise = Bool -> Bool
    not (OccName -> Bool
    startsWithUnderscore (GreName -> OccName
    forall name. HasOccName name => name -> OccName
    occName GreName
    child))

    addUnusedWarning :: WarningFlag -> OccName -> SrcSpan -> SDoc -> RnM ()
    addUnusedWarning :: WarningFlag
    -> OccName -> SrcSpan -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addUnusedWarning WarningFlag
    flag OccName
    occ SrcSpan
    span SDoc
    msg = do
      let diag :: TcRnMessage
    diag = DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ DiagnosticReason -> [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainDiagnostic (WarningFlag -> DiagnosticReason
    WarningWithFlag WarningFlag
    flag) [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
            [SDoc] -> SDoc
    sep [SDoc
    msg SDoc -> SDoc -> SDoc
    <> SDoc
    colon,
                 Int -> SDoc -> SDoc
    nest Int
    2 (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ NameSpace -> SDoc
    pprNonVarNameSpace (OccName -> NameSpace
    occNameSpace OccName
    occ)
                                SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (OccName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr OccName
    occ)]
      SrcSpan -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addDiagnosticAt SrcSpan
    span TcRnMessage
    diag

    unusedRecordWildcardWarning :: TcRnMessage
    unusedRecordWildcardWarning :: TcRnMessage
    unusedRecordWildcardWarning =
      DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ DiagnosticReason -> [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainDiagnostic (WarningFlag -> DiagnosticReason
    WarningWithFlag WarningFlag
    Opt_WarnUnusedRecordWildcards) [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
        SDoc -> SDoc
    wildcardDoc (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "No variables bound in the record wildcard match are used"

    redundantWildcardWarning :: SDoc
    redundantWildcardWarning :: SDoc
    redundantWildcardWarning =
      SDoc -> SDoc
    wildcardDoc (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "Record wildcard does not bind any new variables"

    wildcardDoc :: SDoc -> SDoc
    wildcardDoc :: SDoc -> SDoc
    wildcardDoc SDoc
    herald =
      SDoc
    herald
        SDoc -> SDoc -> SDoc
    $$ Int -> SDoc -> SDoc
    nest Int
    2 (String -> SDoc
    text String
    "Possible fix" SDoc -> SDoc -> SDoc
    <> SDoc
    colon SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "omit the"
                                                SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    ".."))

    {-
    Note [Skipping ambiguity errors at use sites of local declarations]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In general, we do not report ambiguous occurrences at use sites where all the
    clashing names are defined locally, because the error will have been reported at
    the definition site, and we want to avoid an error cascade.

    However, when DuplicateRecordFields is enabled, it is possible to define the
    same field name multiple times, so we *do* need to report an error at the use
    site when there is ambiguity between multiple fields. Moreover, when
    NoFieldSelectors is enabled, it is possible to define a field with the same name
    as a non-field, so again we need to report ambiguity at the use site.

    We can skip reporting an ambiguity error whenever defining the GREs must have
    yielded a duplicate declarations error.  More precisely, we can skip if:

     * there are at least two non-fields amongst the GREs; or

     * there are at least two fields amongst the GREs, and DuplicateRecordFields is
       *disabled*; or

     * there is at least one non-field, at least one field, and NoFieldSelectors is
       *disabled*.

    These conditions ensure that a duplicate local declaration will have been
    reported.  See also Note [Reporting duplicate local declarations] in
    GHC.Rename.Names).

    -}

    addNameClashErrRn :: RdrName -> NE.NonEmpty GlobalRdrElt -> RnM ()
    addNameClashErrRn :: RdrName
    -> NonEmpty GlobalRdrElt -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addNameClashErrRn RdrName
    rdr_name NonEmpty GlobalRdrElt
    gres
      | (GlobalRdrElt -> Bool) -> NonEmpty GlobalRdrElt -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all GlobalRdrElt -> Bool
    isLocalGRE NonEmpty GlobalRdrElt
    gres Bool -> Bool -> Bool
    && Bool
    can_skip
      -- If there are two or more *local* defns, we'll usually have reported that
      -- already, and we don't want an error cascade.
      = () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
      | Bool
    otherwise
      = TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr (TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
        ([SDoc] -> SDoc
    vcat [ String -> SDoc
    text String
    "Ambiguous occurrence" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (RdrName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)
                     , String -> SDoc
    text String
    "It could refer to"
                     , Int -> SDoc -> SDoc
    nest Int
    3 ([SDoc] -> SDoc
    vcat (SDoc
    msg1 SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : [SDoc]
    msgs)) ])
      where
        GlobalRdrElt
    np1 NE.:| [GlobalRdrElt]
    nps = NonEmpty GlobalRdrElt
    gres
        msg1 :: SDoc
    msg1 =  String -> SDoc
    text String
    "either" SDoc -> SDoc -> SDoc
    <+> GlobalRdrElt -> SDoc
    ppr_gre GlobalRdrElt
    np1
        msgs :: [SDoc]
    msgs = [String -> SDoc
    text String
    "    or" SDoc -> SDoc -> SDoc
    <+> GlobalRdrElt -> SDoc
    ppr_gre GlobalRdrElt
    np | GlobalRdrElt
    np <- [GlobalRdrElt]
    nps]
        ppr_gre :: GlobalRdrElt -> SDoc
    ppr_gre GlobalRdrElt
    gre = [SDoc] -> SDoc
    sep [ GlobalRdrElt -> SDoc
    pp_greMangledName GlobalRdrElt
    gre SDoc -> SDoc -> SDoc
    <> SDoc
    comma
                          , GlobalRdrElt -> SDoc
    pprNameProvenance GlobalRdrElt
    gre]

        -- When printing the name, take care to qualify it in the same
        -- way as the provenance reported by pprNameProvenance, namely
        -- the head of 'gre_imp'.  Otherwise we get confusing reports like
        --   Ambiguous occurrence ‘null’
        --   It could refer to either ‘T15487a.null’,
        --                            imported from ‘Prelude’ at T15487.hs:1:8-13
        --                     or ...
        -- See #15487
        pp_greMangledName :: GlobalRdrElt -> SDoc
    pp_greMangledName gre :: GlobalRdrElt
    gre@(GRE { gre_name :: GlobalRdrElt -> GreName
    gre_name = GreName
    child
                             , gre_lcl :: GlobalRdrElt -> Bool
    gre_lcl = Bool
    lcl, gre_imp :: GlobalRdrElt -> Bag ImportSpec
    gre_imp = Bag ImportSpec
    iss }) =
          case GreName
    child of
            FieldGreName FieldLabel
    fl  -> String -> SDoc
    text String
    "the field" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (FieldLabel -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr FieldLabel
    fl)
            NormalGreName Name
    name -> SDoc -> SDoc
    quotes (Name -> SDoc
    pp_qual Name
    name SDoc -> SDoc -> SDoc
    <> SDoc
    dot SDoc -> SDoc -> SDoc
    <> OccName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (Name -> OccName
    nameOccName Name
    name))
          where
            pp_qual :: Name -> SDoc
    pp_qual Name
    name
                    | Bool
    lcl
                    = Module -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ((() :: Constraint) => Name -> Module
    Name -> Module
    nameModule Name
    name)
                    | Just ImportSpec
    imp  <- Bag ImportSpec -> Maybe ImportSpec
    forall a. Bag a -> Maybe a
    headMaybe Bag ImportSpec
    iss  -- This 'imp' is the one that
                                      -- pprNameProvenance chooses
                    , ImpDeclSpec { is_as :: ImpDeclSpec -> ModuleName
    is_as = ModuleName
    mod } <- ImportSpec -> ImpDeclSpec
    is_decl ImportSpec
    imp
                    = ModuleName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ModuleName
    mod
                    | Bool
    otherwise
                    = String -> SDoc -> SDoc
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "addNameClassErrRn" (GlobalRdrElt -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr GlobalRdrElt
    gre SDoc -> SDoc -> SDoc
    $$ Bag ImportSpec -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Bag ImportSpec
    iss)
                      -- Invariant: either 'lcl' is True or 'iss' is non-empty

        -- If all the GREs are defined locally, can we skip reporting an ambiguity
        -- error at use sites, because it will have been reported already? See
        -- Note [Skipping ambiguity errors at use sites of local declarations]
        can_skip :: Bool
    can_skip = Int
    num_non_flds Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    2
                Bool -> Bool -> Bool
    || (Int
    num_flds Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    2 Bool -> Bool -> Bool
    && Bool -> Bool
    not (GlobalRdrElt -> Bool
    isDuplicateRecFldGRE ([GlobalRdrElt] -> GlobalRdrElt
    forall a. HasCallStack => [a] -> a
    head [GlobalRdrElt]
    flds)))
                Bool -> Bool -> Bool
    || (Int
    num_non_flds Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    1 Bool -> Bool -> Bool
    && Int
    num_flds Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    1
                                      Bool -> Bool -> Bool
    && Bool -> Bool
    not (GlobalRdrElt -> Bool
    isNoFieldSelectorGRE ([GlobalRdrElt] -> GlobalRdrElt
    forall a. HasCallStack => [a] -> a
    head [GlobalRdrElt]
    flds)))
        ([GlobalRdrElt]
    flds, [GlobalRdrElt]
    non_flds) = (GlobalRdrElt -> Bool)
    -> NonEmpty GlobalRdrElt -> ([GlobalRdrElt], [GlobalRdrElt])
    forall a. (a -> Bool) -> NonEmpty a -> ([a], [a])
    NE.partition GlobalRdrElt -> Bool
    isRecFldGRE NonEmpty GlobalRdrElt
    gres
        num_flds :: Int
    num_flds     = [GlobalRdrElt] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [GlobalRdrElt]
    flds
        num_non_flds :: Int
    num_non_flds = [GlobalRdrElt] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [GlobalRdrElt]
    non_flds

    dupNamesErr :: Outputable n => (n -> SrcSpan) -> NE.NonEmpty n -> RnM ()
    dupNamesErr :: forall n.
    Outputable n =>
    (n -> SrcSpan) -> NonEmpty n -> IOEnv (Env TcGblEnv TcLclEnv) ()
    dupNamesErr n -> SrcSpan
    get_loc NonEmpty n
    names
      = SrcSpan -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErrAt SrcSpan
    big_loc (TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
        [SDoc] -> SDoc
    vcat [String -> SDoc
    text String
    "Conflicting definitions for" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (n -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (NonEmpty n -> n
    forall a. NonEmpty a -> a
    NE.head NonEmpty n
    names)),
              SDoc
    locations]
      where
        locs :: [SrcSpan]
    locs      = (n -> SrcSpan) -> [n] -> [SrcSpan]
    forall a b. (a -> b) -> [a] -> [b]
    map n -> SrcSpan
    get_loc (NonEmpty n -> [n]
    forall a. NonEmpty a -> [a]
    NE.toList NonEmpty n
    names)
        big_loc :: SrcSpan
    big_loc   = (SrcSpan -> SrcSpan -> SrcSpan) -> [SrcSpan] -> SrcSpan
    forall a. (a -> a -> a) -> [a] -> a
    forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
    foldr1 SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans [SrcSpan]
    locs
        locations :: SDoc
    locations = String -> SDoc
    text String
    "Bound at:" SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    vcat ((SrcSpan -> SDoc) -> [SrcSpan] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map SrcSpan -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ((SrcSpan -> SrcSpan -> Ordering) -> [SrcSpan] -> [SrcSpan]
    forall a. (a -> a -> Ordering) -> [a] -> [a]
    sortBy SrcSpan -> SrcSpan -> Ordering
    SrcLoc.leftmost_smallest [SrcSpan]
    locs))

    badQualBndrErr :: RdrName -> TcRnMessage
    badQualBndrErr :: RdrName -> TcRnMessage
    badQualBndrErr RdrName
    rdr_name
      = DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
      String -> SDoc
    text String
    "Qualified name in binding position:" SDoc -> SDoc -> SDoc
    <+> RdrName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name

    typeAppErr :: String -> LHsType GhcPs -> TcRnMessage
    typeAppErr :: String -> LHsType GhcPs -> TcRnMessage
    typeAppErr String
    what (L SrcSpanAnnA
    _ HsType GhcPs
    k)
      = DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
        SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Illegal visible" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    what SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "application"
                SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (Char -> SDoc
    char Char
    '@' SDoc -> SDoc -> SDoc
    <> HsType GhcPs -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HsType GhcPs
    k))
           Int
    2 (String -> SDoc
    text String
    "Perhaps you intended to use TypeApplications")

    badFieldConErr :: Name -> FieldLabelString -> TcRnMessage
    badFieldConErr :: Name -> FieldLabelString -> TcRnMessage
    badFieldConErr Name
    con FieldLabelString
    field
      = DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
        [SDoc] -> SDoc
    hsep [String -> SDoc
    text String
    "Constructor" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (Name -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Name
    con),
              String -> SDoc
    text String
    "does not have field", SDoc -> SDoc
    quotes (FieldLabelString -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr FieldLabelString
    field)]

    -- | Ensure that a boxed or unboxed tuple has arity no larger than
    -- 'mAX_TUPLE_SIZE'.
    checkTupSize :: Int -> TcM ()
    checkTupSize :: Int -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkTupSize Int
    tup_size
      | Int
    tup_size Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    mAX_TUPLE_SIZE
      = () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
      | Bool
    otherwise
      = TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr (TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
        [SDoc] -> SDoc
    sep [String -> SDoc
    text String
    "A" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    int Int
    tup_size SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    "-tuple is too large for GHC",
                     Int -> SDoc -> SDoc
    nest Int
    2 (SDoc -> SDoc
    parens (String -> SDoc
    text String
    "max size is" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    int Int
    mAX_TUPLE_SIZE)),
                     Int -> SDoc -> SDoc
    nest Int
    2 (String -> SDoc
    text String
    "Workaround: use nested tuples or define a data type")]

    -- | Ensure that a constraint tuple has arity no larger than 'mAX_CTUPLE_SIZE'.
    checkCTupSize :: Int -> TcM ()
    checkCTupSize :: Int -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkCTupSize Int
    tup_size
      | Int
    tup_size Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    mAX_CTUPLE_SIZE
      = () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
      | Bool
    otherwise
      = TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr (TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> TcRnMessage -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ DiagnosticMessage -> TcRnMessage
    forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
    TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
    -> DiagnosticMessage -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ [GhcHint] -> SDoc -> DiagnosticMessage
    mkPlainError [GhcHint]
    noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
    forall a b. (a -> b) -> a -> b
    $
        SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Constraint tuple arity too large:" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    int Int
    tup_size
                      SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    parens (String -> SDoc
    text String
    "max arity =" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    int Int
    mAX_CTUPLE_SIZE))
                   Int
    2 (String -> SDoc
    text String
    "Instead, use a nested tuple")

    {- *********************************************************************
    *                                                                      *
                  Generating code for HsExpanded
          See Note [Handling overloaded and rebindable constructs]
    *                                                                      *
    ********************************************************************* -}

    wrapGenSpan :: a -> LocatedAn an a
    -- Wrap something in a "generatedSrcSpan"
    -- See Note [Rebindable syntax and HsExpansion]
    wrapGenSpan :: forall a an. a -> LocatedAn an a
    wrapGenSpan a
    x = SrcAnn an -> a -> GenLocated (SrcAnn an) a
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcAnn an
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    generatedSrcSpan) a
    x

    genHsApps :: Name -> [LHsExpr GhcRn] -> HsExpr GhcRn
    genHsApps :: Name -> [LHsExpr GhcRn] -> HsExpr GhcRn
    genHsApps Name
    fun [LHsExpr GhcRn]
    args = (HsExpr GhcRn
     -> GenLocated SrcSpanAnnA (HsExpr GhcRn) -> HsExpr GhcRn)
    -> HsExpr GhcRn
    -> [GenLocated SrcSpanAnnA (HsExpr GhcRn)]
    -> HsExpr GhcRn
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl HsExpr GhcRn -> LHsExpr GhcRn -> HsExpr GhcRn
    HsExpr GhcRn
    -> GenLocated SrcSpanAnnA (HsExpr GhcRn) -> HsExpr GhcRn
    genHsApp (Name -> HsExpr GhcRn
    genHsVar Name
    fun) [LHsExpr GhcRn]
    [GenLocated SrcSpanAnnA (HsExpr GhcRn)]
    args

    genHsApp :: HsExpr GhcRn -> LHsExpr GhcRn -> HsExpr GhcRn
    genHsApp :: HsExpr GhcRn -> LHsExpr GhcRn -> HsExpr GhcRn
    genHsApp HsExpr GhcRn
    fun LHsExpr GhcRn
    arg = XApp GhcRn -> LHsExpr GhcRn -> LHsExpr GhcRn -> HsExpr GhcRn
    forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
    HsApp XApp GhcRn
    EpAnn NoEpAnns
    forall a. EpAnn a
    noAnn (HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
    forall a an. a -> LocatedAn an a
    wrapGenSpan HsExpr GhcRn
    fun) LHsExpr GhcRn
    arg

    genLHsVar :: Name -> LHsExpr GhcRn
    genLHsVar :: Name -> LHsExpr GhcRn
    genLHsVar Name
    nm = HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
    forall a an. a -> LocatedAn an a
    wrapGenSpan (HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn))
    -> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
    forall a b. (a -> b) -> a -> b
    $ Name -> HsExpr GhcRn
    genHsVar Name
    nm

    genHsVar :: Name -> HsExpr GhcRn
    genHsVar :: Name -> HsExpr GhcRn
    genHsVar Name
    nm = XVar GhcRn -> XRec GhcRn (IdP GhcRn) -> HsExpr GhcRn
    forall p. XVar p -> LIdP p -> HsExpr p
    HsVar XVar GhcRn
    NoExtField
    noExtField (XRec GhcRn (IdP GhcRn) -> HsExpr GhcRn)
    -> XRec GhcRn (IdP GhcRn) -> HsExpr GhcRn
    forall a b. (a -> b) -> a -> b
    $ Name -> LocatedAn NameAnn Name
    forall a an. a -> LocatedAn an a
    wrapGenSpan Name
    nm

    genAppType :: HsExpr GhcRn -> HsType (NoGhcTc GhcRn) -> HsExpr GhcRn
    genAppType :: HsExpr GhcRn -> HsType (NoGhcTc GhcRn) -> HsExpr GhcRn
    genAppType HsExpr GhcRn
    expr = XAppTypeE GhcRn
    -> LHsExpr GhcRn -> LHsWcType (NoGhcTc GhcRn) -> HsExpr GhcRn
    forall p.
    XAppTypeE p -> LHsExpr p -> LHsWcType (NoGhcTc p) -> HsExpr p
    HsAppType XAppTypeE GhcRn
    NoExtField
    noExtField (HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
    forall a an. a -> LocatedAn an a
    wrapGenSpan HsExpr GhcRn
    expr) (HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn))
     -> HsExpr GhcRn)
    -> (HsType GhcRn
        -> HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn)))
    -> HsType GhcRn
    -> HsExpr GhcRn
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (HsType GhcRn)
    -> HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall thing. thing -> HsWildCardBndrs GhcRn thing
    mkEmptyWildCardBndrs (GenLocated SrcSpanAnnA (HsType GhcRn)
     -> HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn)))
    -> (HsType GhcRn -> GenLocated SrcSpanAnnA (HsType GhcRn))
    -> HsType GhcRn
    -> HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsType GhcRn -> GenLocated SrcSpanAnnA (HsType GhcRn)
    forall a an. a -> LocatedAn an a
    wrapGenSpan

    genHsIntegralLit :: IntegralLit -> LocatedAn an (HsExpr GhcRn)
    genHsIntegralLit :: forall an. IntegralLit -> LocatedAn an (HsExpr GhcRn)
    genHsIntegralLit IntegralLit
    lit = HsExpr GhcRn -> LocatedAn an (HsExpr GhcRn)
    forall a an. a -> LocatedAn an a
    wrapGenSpan (HsExpr GhcRn -> LocatedAn an (HsExpr GhcRn))
    -> HsExpr GhcRn -> LocatedAn an (HsExpr GhcRn)
    forall a b. (a -> b) -> a -> b
    $ XLitE GhcRn -> HsLit GhcRn -> HsExpr GhcRn
    forall p. XLitE p -> HsLit p -> HsExpr p
    HsLit XLitE GhcRn
    EpAnn NoEpAnns
    forall a. EpAnn a
    noAnn (XHsInt GhcRn -> IntegralLit -> HsLit GhcRn
    forall x. XHsInt x -> IntegralLit -> HsLit x
    HsInt XHsInt GhcRn
    NoExtField
    noExtField IntegralLit
    lit)

    genHsTyLit :: FastString -> HsType GhcRn
    genHsTyLit :: FieldLabelString -> HsType GhcRn
    genHsTyLit = XTyLit GhcRn -> HsTyLit -> HsType GhcRn
    forall pass. XTyLit pass -> HsTyLit -> HsType pass
    HsTyLit XTyLit GhcRn
    NoExtField
    noExtField (HsTyLit -> HsType GhcRn)
    -> (FieldLabelString -> HsTyLit)
    -> FieldLabelString
    -> HsType GhcRn
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SourceText -> FieldLabelString -> HsTyLit
    HsStrTy SourceText
    NoSourceText