    {-# LANGUAGE CPP #-}
    {-# LANGUAGE NamedFieldPuns #-}
    {-# LANGUAGE TypeApplications #-}

    {-
    (c) The GRASP/AQUA Project, Glasgow University, 1992-2006

    GHC.Rename.Env contains functions which convert RdrNames into Names.

    -}

    module GHC.Rename.Env (
            newTopSrcBinder,

            lookupLocatedTopBndrRn, lookupLocatedTopBndrRnN, lookupTopBndrRn,

            lookupLocatedOccRn, lookupOccRn, lookupOccRn_maybe,
            lookupLocalOccRn_maybe, lookupInfoOccRn,
            lookupLocalOccThLvl_maybe, lookupLocalOccRn,
            lookupTypeOccRn,
            lookupGlobalOccRn, lookupGlobalOccRn_maybe,

            AmbiguousResult(..),
            lookupExprOccRn,
            lookupRecFieldOcc,
            lookupRecFieldOcc_update,

            ChildLookupResult(..),
            lookupSubBndrOcc_helper,
            combineChildLookupResult, -- Called by lookupChildrenExport

            HsSigCtxt(..), lookupLocalTcNames, lookupSigOccRn, lookupSigOccRnN,
            lookupSigCtxtOccRn, lookupSigCtxtOccRnN,

            lookupInstDeclBndr, lookupFamInstName,
            lookupConstructorFields,

            lookupGreAvailRn,

            -- Rebindable Syntax
            lookupSyntax, lookupSyntaxExpr, lookupSyntaxNames,
            lookupSyntaxName,
            lookupIfThenElse,

            -- QualifiedDo
            lookupQualifiedDoExpr, lookupQualifiedDo,
            lookupQualifiedDoName, lookupNameWithQualifier,

            -- Constructing usage information
            addUsedGRE, addUsedGREs, addUsedDataCons,

            dataTcOccs, --TODO: Move this somewhere, into utils?

        ) where

    #include "HsVersions.h"

    import GHC.Prelude

    import GHC.Iface.Load   ( loadInterfaceForName, loadSrcInterface_maybe )
    import GHC.Iface.Env
    import GHC.Hs
    import GHC.Types.Name.Reader
    import GHC.Tc.Utils.Env
    import GHC.Tc.Utils.Monad
    import GHC.Parser.PostProcess ( setRdrNameSpace )
    import GHC.Builtin.Types
    import GHC.Types.Name
    import GHC.Types.Name.Set
    import GHC.Types.Name.Env
    import GHC.Types.Avail
    import GHC.Unit.Module
    import GHC.Unit.Module.ModIface
    import GHC.Unit.Module.Warnings  ( WarningTxt, pprWarningTxtForMsg )
    import GHC.Core.ConLike
    import GHC.Core.DataCon
    import GHC.Core.TyCon
    import GHC.Builtin.Names( rOOT_MAIN )
    import GHC.Types.Basic  ( TopLevelFlag(..), TupleSort(..) )
    import GHC.Types.SrcLoc as SrcLoc
    import GHC.Utils.Outputable as Outputable
    import GHC.Types.Unique.Set ( uniqSetAny )
    import GHC.Utils.Misc
    import GHC.Utils.Panic
    import GHC.Data.Maybe
    import GHC.Driver.Session
    import GHC.Data.FastString
    import Control.Monad
    import GHC.Data.List.SetOps ( minusList )
    import qualified GHC.LanguageExtensions as LangExt
    import GHC.Rename.Unbound
    import GHC.Rename.Utils
    import qualified Data.Semigroup as Semi
    import Data.Either      ( partitionEithers )
    import Data.List        ( find, sortBy )
    import qualified Data.List.NonEmpty as NE
    import Control.Arrow    ( first )
    import Data.Function
    import GHC.Types.FieldLabel

    {-
    *********************************************************
    *                                                      *
                    Source-code binders
    *                                                      *
    *********************************************************

    Note [Signature lazy interface loading]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    GHC's lazy interface loading can be a bit confusing, so this Note is an
    empirical description of what happens in one interesting case. When
    compiling a signature module against an its implementation, we do NOT
    load interface files associated with its names until after the type
    checking phase.  For example:

        module ASig where
            data T
            f :: T -> T

    Suppose we compile this with -sig-of "A is ASig":

        module B where
            data T = T
            f T = T

        module A(module B) where
            import B

    During type checking, we'll load A.hi because we need to know what the
    RdrEnv for the module is, but we DO NOT load the interface for B.hi!
    It's wholly unnecessary: our local definition 'data T' in ASig is all
    the information we need to finish type checking.  This is contrast to
    type checking of ordinary Haskell files, in which we would not have the
    local definition "data T" and would need to consult B.hi immediately.
    (Also, this situation never occurs for hs-boot files, since you're not
    allowed to reexport from another module.)

    After type checking, we then check that the types we provided are
    consistent with the backing implementation (in checkHiBootOrHsigIface).
    At this point, B.hi is loaded, because we need something to compare
    against.

    I discovered this behavior when trying to figure out why type class
    instances for Data.Map weren't in the EPS when I was type checking a
    test very much like ASig (sigof02dm): the associated interface hadn't
    been loaded yet!  (The larger issue is a moot point, since an instance
    declared in a signature can never be a duplicate.)

    This behavior might change in the future.  Consider this
    alternate module B:

        module B where
            {-# DEPRECATED T, f "Don't use" #-}
            data T = T
            f T = T

    One might conceivably want to report deprecation warnings when compiling
    ASig with -sig-of B, in which case we need to look at B.hi to find the
    deprecation warnings during renaming.  At the moment, you don't get any
    warning until you use the identifier further downstream.  This would
    require adjusting addUsedGRE so that during signature compilation,
    we do not report deprecation warnings for LocalDef.  See also
    Note [Handling of deprecations]
    -}

    newTopSrcBinder :: LocatedN RdrName -> RnM Name
    newTopSrcBinder :: LocatedN RdrName -> RnM Name
    newTopSrcBinder (L SrcSpanAnnN
    loc RdrName
    rdr_name)
      | Just Name
    name <- RdrName -> Maybe Name
    isExact_maybe RdrName
    rdr_name
      =     -- This is here to catch
            --   (a) Exact-name binders created by Template Haskell
            --   (b) The PrelBase defn of (say) [] and similar, for which
            --       the parser reads the special syntax and returns an Exact RdrName
            -- We are at a binding site for the name, so check first that it
            -- the current module is the correct one; otherwise GHC can get
            -- very confused indeed. This test rejects code like
            --      data T = (,) Int Int
            -- unless we are in GHC.Tup
        if Name -> Bool
    isExternalName Name
    name then
          do { Module
    this_mod <- forall (m :: * -> *). HasModule m => m Module
    getModule
             ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (Module
    this_mod forall a. Eq a => a -> a -> Bool
    == HasDebugCallStack => Name -> Module
    nameModule Name
    name)
                      (SrcSpan -> SDoc -> TcRn ()
    addErrAt (forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnN
    loc) (RdrName -> SDoc
    badOrigBinding RdrName
    rdr_name))
             ; forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name }
        else   -- See Note [Binders in Template Haskell] in "GHC.ThToHs"
          do { Module
    this_mod <- forall (m :: * -> *). HasModule m => m Module
    getModule
             ; forall m n. Module -> Name -> TcRnIf m n Name
    externaliseName Module
    this_mod Name
    name }

      | Just (Module
    rdr_mod, OccName
    rdr_occ) <- RdrName -> Maybe (Module, OccName)
    isOrig_maybe RdrName
    rdr_name
      = do  { Module
    this_mod <- forall (m :: * -> *). HasModule m => m Module
    getModule
            ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (Module
    rdr_mod forall a. Eq a => a -> a -> Bool
    == Module
    this_mod Bool -> Bool -> Bool
    || Module
    rdr_mod forall a. Eq a => a -> a -> Bool
    == Module
    rOOT_MAIN)
                     (SrcSpan -> SDoc -> TcRn ()
    addErrAt (forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnN
    loc) (RdrName -> SDoc
    badOrigBinding RdrName
    rdr_name))
            -- When reading External Core we get Orig names as binders,
            -- but they should agree with the module gotten from the monad
            --
            -- We can get built-in syntax showing up here too, sadly.  If you type
            --      data T = (,,,)
            -- the constructor is parsed as a type, and then GHC.Parser.PostProcess.tyConToDataCon
            -- uses setRdrNameSpace to make it into a data constructors.  At that point
            -- the nice Exact name for the TyCon gets swizzled to an Orig name.
            -- Hence the badOrigBinding error message.
            --
            -- Except for the ":Main.main = ..." definition inserted into
            -- the Main module; ugh!

            -- Because of this latter case, we call newGlobalBinder with a module from
            -- the RdrName, not from the environment.  In principle, it'd be fine to
            -- have an arbitrary mixture of external core definitions in a single module,
            -- (apart from module-initialisation issues, perhaps).
            ; forall a b. Module -> OccName -> SrcSpan -> TcRnIf a b Name
    newGlobalBinder Module
    rdr_mod OccName
    rdr_occ (forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnN
    loc) }

      | Bool
    otherwise
      = do  { forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (RdrName -> Bool
    isQual RdrName
    rdr_name)
                     (SrcSpan -> SDoc -> TcRn ()
    addErrAt (forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnN
    loc) (RdrName -> SDoc
    badQualBndrErr RdrName
    rdr_name))
                    -- Binders should not be qualified; if they are, and with a different
                    -- module name, we get a confusing "M.T is not in scope" error later

            ; ThStage
    stage <- TcM ThStage
    getStage
            ; if ThStage -> Bool
    isBrackStage ThStage
    stage then
                    -- We are inside a TH bracket, so make an *Internal* name
                    -- See Note [Top-level Names in Template Haskell decl quotes] in GHC.Rename.Names
                 do { Unique
    uniq <- forall gbl lcl. TcRnIf gbl lcl Unique
    newUnique
                    ; forall (m :: * -> *) a. Monad m => a -> m a
    return (Unique -> OccName -> SrcSpan -> Name
    mkInternalName Unique
    uniq (RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name) (forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnN
    loc)) }
              else
                 do { Module
    this_mod <- forall (m :: * -> *). HasModule m => m Module
    getModule
                    ; String -> SDoc -> TcRn ()
    traceRn String
    "newTopSrcBinder" (forall a. Outputable a => a -> SDoc
    ppr Module
    this_mod SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr (forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnN
    loc))
                    ; forall a b. Module -> OccName -> SrcSpan -> TcRnIf a b Name
    newGlobalBinder Module
    this_mod (RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name) (forall a. SrcSpanAnn' a -> SrcSpan
    locA SrcSpanAnnN
    loc) }
            }

    {-
    *********************************************************
    *                                                      *
            Source code occurrences
    *                                                      *
    *********************************************************

    Looking up a name in the GHC.Rename.Env.

    Note [Type and class operator definitions]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    We want to reject all of these unless we have -XTypeOperators (#3265)
       data a :*: b  = ...
       class a :*: b where ...
       data (:*:) a b  = ....
       class (:*:) a b where ...
    The latter two mean that we are not just looking for a
    *syntactically-infix* declaration, but one that uses an operator
    OccName.  We use OccName.isSymOcc to detect that case, which isn't
    terribly efficient, but there seems to be no better way.
    -}

    -- Can be made to not be exposed
    -- Only used unwrapped in rnAnnProvenance
    lookupTopBndrRn :: RdrName -> RnM Name
    -- Look up a top-level source-code binder.   We may be looking up an unqualified 'f',
    -- and there may be several imported 'f's too, which must not confuse us.
    -- For example, this is OK:
    --      import Foo( f )
    --      infix 9 f       -- The 'f' here does not need to be qualified
    --      f x = x         -- Nor here, of course
    -- So we have to filter out the non-local ones.
    --
    -- A separate function (importsFromLocalDecls) reports duplicate top level
    -- decls, so here it's safe just to choose an arbitrary one.
    lookupTopBndrRn :: RdrName -> RnM Name
    lookupTopBndrRn RdrName
    rdr_name =
      forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig RdrName
    rdr_name forall a. a -> a
    id forall a b. (a -> b) -> a -> b
    $
        do  {  -- Check for operators in type or class declarations
               -- See Note [Type and class operator definitions]
              let occ :: OccName
    occ = RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name
            ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (OccName -> Bool
    isTcOcc OccName
    occ Bool -> Bool -> Bool
    && OccName -> Bool
    isSymOcc OccName
    occ)
                   (do { Bool
    op_ok <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.TypeOperators
                       ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless Bool
    op_ok (SDoc -> TcRn ()
    addErr (RdrName -> SDoc
    opDeclErr RdrName
    rdr_name)) })

            ; GlobalRdrEnv
    env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv
            ; case forall a. (a -> Bool) -> [a] -> [a]
    filter GlobalRdrElt -> Bool
    isLocalGRE (RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
    lookupGRE_RdrName RdrName
    rdr_name GlobalRdrEnv
    env) of
                [GlobalRdrElt
    gre] -> forall (m :: * -> *) a. Monad m => a -> m a
    return (GlobalRdrElt -> Name
    greMangledName GlobalRdrElt
    gre)
                [GlobalRdrElt]
    _     -> do -- Ambiguous (can't happen) or unbound
                            String -> SDoc -> TcRn ()
    traceRn String
    "lookupTopBndrRN fail" (forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)
                            WhereLooking -> RdrName -> RnM Name
    unboundName WhereLooking
    WL_LocalTop RdrName
    rdr_name
        }

    lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
    lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
    lookupLocatedTopBndrRn = forall a b. (a -> TcM b) -> Located a -> TcM (Located b)
    wrapLocM RdrName -> RnM Name
    lookupTopBndrRn

    lookupLocatedTopBndrRnN :: LocatedN RdrName -> RnM (LocatedN Name)
    lookupLocatedTopBndrRnN :: LocatedN RdrName -> RnM (LocatedN Name)
    lookupLocatedTopBndrRnN = forall a b ann.
    (a -> TcM b)
    -> GenLocated (SrcSpanAnn' ann) a
    -> TcRn (GenLocated (SrcSpanAnn' ann) b)
    wrapLocMA RdrName -> RnM Name
    lookupTopBndrRn

    -- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].
    -- This never adds an error, but it may return one, see
    -- Note [Errors in lookup functions]
    lookupExactOcc_either :: Name -> RnM (Either SDoc Name)
    lookupExactOcc_either :: Name -> RnM (Either SDoc Name)
    lookupExactOcc_either Name
    name
      | Just TyThing
    thing <- Name -> Maybe TyThing
    wiredInNameTyThing_maybe Name
    name
      , Just TyCon
    tycon <- case TyThing
    thing of
                        ATyCon TyCon
    tc                 -> forall a. a -> Maybe a
    Just TyCon
    tc
                        AConLike (RealDataCon DataCon
    dc) -> forall a. a -> Maybe a
    Just (DataCon -> TyCon
    dataConTyCon DataCon
    dc)
                        TyThing
    _                         -> forall a. Maybe a
    Nothing
      , Just TupleSort
    tupleSort <- TyCon -> Maybe TupleSort
    tyConTuple_maybe TyCon
    tycon
      = do { let tupArity :: Arity
    tupArity = case TupleSort
    tupleSort of
                   -- Unboxed tuples have twice as many arguments because of the
                   -- 'RuntimeRep's (#17837)
                   TupleSort
    UnboxedTuple -> TyCon -> Arity
    tyConArity TyCon
    tycon forall a. Integral a => a -> a -> a
    `div` Arity
    2
                   TupleSort
    _ -> TyCon -> Arity
    tyConArity TyCon
    tycon
           ; Arity -> TcRn ()
    checkTupSize Arity
    tupArity
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right Name
    name) }

      | Name -> Bool
    isExternalName Name
    name
      = forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right Name
    name)

      | Bool
    otherwise
      = do { GlobalRdrEnv
    env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv
           ; let -- See Note [Splicing Exact names]
                 main_occ :: OccName
    main_occ =  Name -> OccName
    nameOccName Name
    name
                 demoted_occs :: [OccName]
    demoted_occs = case OccName -> Maybe OccName
    demoteOccName OccName
    main_occ of
                                  Just OccName
    occ -> [OccName
    occ]
                                  Maybe OccName
    Nothing  -> []
                 gres :: [GlobalRdrElt]
    gres = [ GlobalRdrElt
    gre | OccName
    occ <- OccName
    main_occ forall a. a -> [a] -> [a]
    : [OccName]
    demoted_occs
                              , GlobalRdrElt
    gre <- GlobalRdrEnv -> OccName -> [GlobalRdrElt]
    lookupGlobalRdrEnv GlobalRdrEnv
    env OccName
    occ
                              , GlobalRdrElt -> Name
    greMangledName GlobalRdrElt
    gre forall a. Eq a => a -> a -> Bool
    == Name
    name ]
           ; case [GlobalRdrElt]
    gres of
               [GlobalRdrElt
    gre] -> forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right (GlobalRdrElt -> Name
    greMangledName GlobalRdrElt
    gre))

               []    -> -- See Note [Splicing Exact names]
                        do { LocalRdrEnv
    lcl_env <- RnM LocalRdrEnv
    getLocalRdrEnv
                           ; if Name
    name Name -> LocalRdrEnv -> Bool
    `inLocalRdrEnvScope` LocalRdrEnv
    lcl_env
                             then forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right Name
    name)
                             else
                             do { TcRef NameSet
    th_topnames_var <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap TcGblEnv -> TcRef NameSet
    tcg_th_topnames forall gbl lcl. TcRnIf gbl lcl gbl
    getGblEnv
                                ; NameSet
    th_topnames <- forall a gbl lcl. TcRef a -> TcRnIf gbl lcl a
    readTcRef TcRef NameSet
    th_topnames_var
                                ; if Name
    name Name -> NameSet -> Bool
    `elemNameSet` NameSet
    th_topnames
                                  then forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right Name
    name)
                                  else forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. a -> Either a b
    Left (Name -> SDoc
    exactNameErr Name
    name))
                                }
                           }
               [GlobalRdrElt]
    gres -> forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. a -> Either a b
    Left ([GlobalRdrElt] -> SDoc
    sameNameErr [GlobalRdrElt]
    gres))   -- Ugh!  See Note [Template Haskell ambiguity]
           }

    sameNameErr :: [GlobalRdrElt] -> SDoc
    sameNameErr :: [GlobalRdrElt] -> SDoc
    sameNameErr [] = forall a. String -> a
    panic String
    "addSameNameErr: empty list"
    sameNameErr gres :: [GlobalRdrElt]
    gres@(GlobalRdrElt
    _ : [GlobalRdrElt]
    _)
      = SDoc -> Arity -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Same exact name in multiple name-spaces:")
           Arity
    2 ([SDoc] -> SDoc
    vcat (forall a b. (a -> b) -> [a] -> [b]
    map Name -> SDoc
    pp_one [Name]
    sorted_names) SDoc -> SDoc -> SDoc
    $$ SDoc
    th_hint)
      where
        sorted_names :: [Name]
    sorted_names = forall a. (a -> a -> Ordering) -> [a] -> [a]
    sortBy (SrcSpan -> SrcSpan -> Ordering
    SrcLoc.leftmost_smallest forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` Name -> SrcSpan
    nameSrcSpan) (forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrElt -> Name
    greMangledName [GlobalRdrElt]
    gres)
        pp_one :: Name -> SDoc
    pp_one Name
    name
          = SDoc -> Arity -> SDoc -> SDoc
    hang (NameSpace -> SDoc
    pprNameSpace (OccName -> NameSpace
    occNameSpace (forall a. NamedThing a => a -> OccName
    getOccName Name
    name))
                  SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr Name
    name) SDoc -> SDoc -> SDoc
    <> SDoc
    comma)
               Arity
    2 (String -> SDoc
    text String
    "declared at:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr (Name -> SrcLoc
    nameSrcLoc Name
    name))

        th_hint :: SDoc
    th_hint = [SDoc] -> SDoc
    vcat [ String -> SDoc
    text String
    "Probable cause: you bound a unique Template Haskell name (NameU),"
                       , String -> SDoc
    text String
    "perhaps via newName, in different name-spaces."
                       , String -> SDoc
    text String
    "If that's it, then -ddump-splices might be useful" ]

    -----------------------------------------------
    lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
    -- This is called on the method name on the left-hand side of an
    -- instance declaration binding. eg.  instance Functor T where
    --                                       fmap = ...
    --                                       ^^^^ called on this
    -- Regardless of how many unqualified fmaps are in scope, we want
    -- the one that comes from the Functor class.
    --
    -- Furthermore, note that we take no account of whether the
    -- name is only in scope qualified.  I.e. even if method op is
    -- in scope as M.op, we still allow plain 'op' on the LHS of
    -- an instance decl
    --
    -- The "what" parameter says "method" or "associated type",
    -- depending on what we are looking up
    lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
    lookupInstDeclBndr Name
    cls SDoc
    what RdrName
    rdr
      = do { forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (RdrName -> Bool
    isQual RdrName
    rdr)
                  (SDoc -> TcRn ()
    addErr (RdrName -> SDoc
    badQualBndrErr RdrName
    rdr))
                    -- In an instance decl you aren't allowed
                    -- to use a qualified name for the method
                    -- (Although it'd make perfect sense.)
           ; Either SDoc Name
    mb_name <- Bool -> Name -> SDoc -> RdrName -> RnM (Either SDoc Name)
    lookupSubBndrOcc
                              Bool
    False -- False => we don't give deprecated
                                    -- warnings when a deprecated class
                                    -- method is defined. We only warn
                                    -- when it's used
                              Name
    cls SDoc
    doc RdrName
    rdr
           ; case Either SDoc Name
    mb_name of
               Left SDoc
    err -> do { SDoc -> TcRn ()
    addErr SDoc
    err; forall (m :: * -> *) a. Monad m => a -> m a
    return (RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr) }
               Right Name
    nm -> forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    nm }
      where
        doc :: SDoc
    doc = SDoc
    what SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "of class" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr Name
    cls)

    -----------------------------------------------
    lookupFamInstName :: Maybe Name -> LocatedN RdrName
                      -> RnM (LocatedN Name)
    -- Used for TyData and TySynonym family instances only,
    -- See Note [Family instance binders]
    lookupFamInstName :: Maybe Name -> LocatedN RdrName -> RnM (LocatedN Name)
    lookupFamInstName (Just Name
    cls) LocatedN RdrName
    tc_rdr  -- Associated type; c.f GHC.Rename.Bind.rnMethodBind
      = forall a b ann.
    (a -> TcM b)
    -> GenLocated (SrcSpanAnn' ann) a
    -> TcRn (GenLocated (SrcSpanAnn' ann) b)
    wrapLocMA (Name -> SDoc -> RdrName -> RnM Name
    lookupInstDeclBndr Name
    cls (String -> SDoc
    text String
    "associated type")) LocatedN RdrName
    tc_rdr
    lookupFamInstName Maybe Name
    Nothing LocatedN RdrName
    tc_rdr     -- Family instance; tc_rdr is an *occurrence*
      = forall ann.
    GenLocated (SrcSpanAnn' ann) RdrName
    -> TcRn (GenLocated (SrcSpanAnn' ann) Name)
    lookupLocatedOccRn LocatedN RdrName
    tc_rdr

    -----------------------------------------------
    lookupConstructorFields :: Name -> RnM [FieldLabel]
    -- Look up the fields of a given constructor
    --   *  For constructors from this module, use the record field env,
    --      which is itself gathered from the (as yet un-typechecked)
    --      data type decls
    --
    --    * For constructors from imported modules, use the *type* environment
    --      since imported modules are already compiled, the info is conveniently
    --      right there

    lookupConstructorFields :: Name -> RnM [FieldLabel]
    lookupConstructorFields Name
    con_name
      = do  { Module
    this_mod <- forall (m :: * -> *). HasModule m => m Module
    getModule
            ; if Module -> Name -> Bool
    nameIsLocalOrFrom Module
    this_mod Name
    con_name then
              do { RecFieldEnv
    field_env <- TcRn RecFieldEnv
    getRecFieldEnv
                 ; String -> SDoc -> TcRn ()
    traceTc String
    "lookupCF" (forall a. Outputable a => a -> SDoc
    ppr Name
    con_name SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr (forall a. NameEnv a -> Name -> Maybe a
    lookupNameEnv RecFieldEnv
    field_env Name
    con_name) SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr RecFieldEnv
    field_env)
                 ; forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a. NameEnv a -> Name -> Maybe a
    lookupNameEnv RecFieldEnv
    field_env Name
    con_name forall a. Maybe a -> a -> a
    `orElse` []) }
              else
              do { ConLike
    con <- Name -> TcM ConLike
    tcLookupConLike Name
    con_name
                 ; String -> SDoc -> TcRn ()
    traceTc String
    "lookupCF 2" (forall a. Outputable a => a -> SDoc
    ppr ConLike
    con)
                 ; forall (m :: * -> *) a. Monad m => a -> m a
    return (ConLike -> [FieldLabel]
    conLikeFieldLabels ConLike
    con) } }

    -- In CPS style as `RnM r` is monadic
    -- Reports an error if the name is an Exact or Orig and it can't find the name
    -- Otherwise if it is not an Exact or Orig, returns k
    lookupExactOrOrig :: RdrName -> (Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig :: forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig RdrName
    rdr_name Name -> r
    res RnM r
    k
      = do { ExactOrOrigResult
    men <- RdrName -> RnM ExactOrOrigResult
    lookupExactOrOrig_base RdrName
    rdr_name
           ; case ExactOrOrigResult
    men of
              FoundExactOrOrig Name
    n -> forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> r
    res Name
    n)
              ExactOrOrigError SDoc
    e ->
                do { SDoc -> TcRn ()
    addErr SDoc
    e
                   ; forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> r
    res (RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name)) }
              ExactOrOrigResult
    NotExactOrOrig     -> RnM r
    k }

    -- Variant of 'lookupExactOrOrig' that does not report an error
    -- See Note [Errors in lookup functions]
    -- Calls k if the name is neither an Exact nor Orig
    lookupExactOrOrig_maybe :: RdrName -> (Maybe Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig_maybe :: forall r. RdrName -> (Maybe Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig_maybe RdrName
    rdr_name Maybe Name -> r
    res RnM r
    k
      = do { ExactOrOrigResult
    men <- RdrName -> RnM ExactOrOrigResult
    lookupExactOrOrig_base RdrName
    rdr_name
           ; case ExactOrOrigResult
    men of
               FoundExactOrOrig Name
    n -> forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe Name -> r
    res (forall a. a -> Maybe a
    Just Name
    n))
               ExactOrOrigError SDoc
    _ -> forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe Name -> r
    res forall a. Maybe a
    Nothing)
               ExactOrOrigResult
    NotExactOrOrig     -> RnM r
    k }

    data ExactOrOrigResult = FoundExactOrOrig Name -- ^ Found an Exact Or Orig Name
                           | ExactOrOrigError SDoc -- ^ The RdrName was an Exact
                                                     -- or Orig, but there was an
                                                     -- error looking up the Name
                           | NotExactOrOrig -- ^ The RdrName is neither an Exact nor
                                            -- Orig

    -- Does the actual looking up an Exact or Orig name, see 'ExactOrOrigResult'
    lookupExactOrOrig_base :: RdrName -> RnM ExactOrOrigResult
    lookupExactOrOrig_base :: RdrName -> RnM ExactOrOrigResult
    lookupExactOrOrig_base RdrName
    rdr_name
      | Just Name
    n <- RdrName -> Maybe Name
    isExact_maybe RdrName
    rdr_name   -- This happens in derived code
      = Either SDoc Name -> ExactOrOrigResult
    cvtEither forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> RnM (Either SDoc Name)
    lookupExactOcc_either Name
    n
      | Just (Module
    rdr_mod, OccName
    rdr_occ) <- RdrName -> Maybe (Module, OccName)
    isOrig_maybe RdrName
    rdr_name
      = Name -> ExactOrOrigResult
    FoundExactOrOrig forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> forall a b. Module -> OccName -> TcRnIf a b Name
    lookupOrig Module
    rdr_mod OccName
    rdr_occ
      | Bool
    otherwise = forall (m :: * -> *) a. Monad m => a -> m a
    return ExactOrOrigResult
    NotExactOrOrig
      where
        cvtEither :: Either SDoc Name -> ExactOrOrigResult
    cvtEither (Left SDoc
    e)  = SDoc -> ExactOrOrigResult
    ExactOrOrigError SDoc
    e
        cvtEither (Right Name
    n) = Name -> ExactOrOrigResult
    FoundExactOrOrig Name
    n

    {- Note [Errors in lookup functions]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Many of these lookup functions will attach an error if it can't find the Name it
    is trying to lookup. However there are also _maybe and _either variants for many
    of these functions.

    These variants should *not* attach any errors, as there are
    places where we want to attempt looking up a name, but it's not the end of the
    world if we don't find it.

    For example, see lookupThName_maybe: It calls lookupOccRn_maybe multiple
    times for varying names in different namespaces. lookupOccRn_maybe should
    therefore never attach an error, instead just return a Nothing.

    For these _maybe/_either variant functions then, avoid calling further lookup
    functions that can attach errors and instead call their _maybe/_either
    counterparts.
    -}

    -----------------------------------------------
    -- | Look up an occurrence of a field in record construction or pattern
    -- matching (but not update).  When the -XDisambiguateRecordFields
    -- flag is on, take account of the data constructor name to
    -- disambiguate which field to use.
    --
    -- See Note [DisambiguateRecordFields] and Note [NoFieldSelectors].
    lookupRecFieldOcc :: Maybe Name -- Nothing  => just look it up as usual
                                    -- Just con => use data con to disambiguate
                      -> RdrName
                      -> RnM Name
    lookupRecFieldOcc :: Maybe Name -> RdrName -> RnM Name
    lookupRecFieldOcc Maybe Name
    mb_con RdrName
    rdr_name
      | Just Name
    con <- Maybe Name
    mb_con
      , Name -> Bool
    isUnboundName Name
    con  -- Avoid error cascade
      = forall (m :: * -> *) a. Monad m => a -> m a
    return (RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name)
      | Just Name
    con <- Maybe Name
    mb_con
      = do { [FieldLabel]
    flds <- Name -> RnM [FieldLabel]
    lookupConstructorFields Name
    con
           ; GlobalRdrEnv
    env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv
           ; let lbl :: FastString
    lbl      = OccName -> FastString
    occNameFS (RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name)
                 mb_field :: Maybe (FieldLabel, GlobalRdrElt)
    mb_field = do FieldLabel
    fl <- forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
    find ((forall a. Eq a => a -> a -> Bool
    == FastString
    lbl) forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FieldLabel -> FastString
    flLabel) [FieldLabel]
    flds
                               -- We have the label, now check it is in scope.  If
                               -- there is a qualifier, use pickGREs to check that
                               -- the qualifier is correct, and return the filtered
                               -- GRE so we get import usage right (see #17853).
                               GlobalRdrElt
    gre <- GlobalRdrEnv -> FieldLabel -> Maybe GlobalRdrElt
    lookupGRE_FieldLabel GlobalRdrEnv
    env FieldLabel
    fl
                               if RdrName -> Bool
    isQual RdrName
    rdr_name
                                 then do GlobalRdrElt
    gre' <- forall a. [a] -> Maybe a
    listToMaybe (RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
    pickGREs RdrName
    rdr_name [GlobalRdrElt
    gre])
                                         forall (m :: * -> *) a. Monad m => a -> m a
    return (FieldLabel
    fl, GlobalRdrElt
    gre')
                                  else forall (m :: * -> *) a. Monad m => a -> m a
    return (FieldLabel
    fl, GlobalRdrElt
    gre)
           ; case Maybe (FieldLabel, GlobalRdrElt)
    mb_field of
               Just (FieldLabel
    fl, GlobalRdrElt
    gre) -> do { Bool -> GlobalRdrElt -> TcRn ()
    addUsedGRE Bool
    True GlobalRdrElt
    gre
                                    ; forall (m :: * -> *) a. Monad m => a -> m a
    return (FieldLabel -> Name
    flSelector FieldLabel
    fl) }
               Maybe (FieldLabel, GlobalRdrElt)
    Nothing        -> FieldsOrSelectors -> RdrName -> RnM Name
    lookupGlobalOccRn' FieldsOrSelectors
    WantBoth RdrName
    rdr_name }
                 -- See Note [Fall back on lookupGlobalOccRn in lookupRecFieldOcc]
      | Bool
    otherwise
      -- This use of Global is right as we are looking up a selector which
      -- can only be defined at the top level.
      = FieldsOrSelectors -> RdrName -> RnM Name
    lookupGlobalOccRn' FieldsOrSelectors
    WantBoth RdrName
    rdr_name

    -- | Look up an occurrence of a field in a record update, returning the selector
    -- name.
    --
    -- Unlike construction and pattern matching with @-XDisambiguateRecordFields@
    -- (see 'lookupRecFieldOcc'), there is no data constructor to help disambiguate,
    -- so this may be ambiguous if the field is in scope multiple times.  However we
    -- ignore non-fields in scope with the same name if @-XDisambiguateRecordFields@
    -- is on (see Note [DisambiguateRecordFields for updates]).
    --
    -- Here a field is in scope even if @NoFieldSelectors@ was enabled at its
    -- definition site (see Note [NoFieldSelectors]).
    lookupRecFieldOcc_update
      :: DuplicateRecordFields
      -> RdrName
      -> RnM AmbiguousResult
    lookupRecFieldOcc_update :: DuplicateRecordFields -> RdrName -> RnM AmbiguousResult
    lookupRecFieldOcc_update DuplicateRecordFields
    dup_fields_ok RdrName
    rdr_name = do
        Bool
    disambig_ok <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.DisambiguateRecordFields
        let want :: FieldsOrSelectors
    want | Bool
    disambig_ok = FieldsOrSelectors
    WantField
                 | Bool
    otherwise   = FieldsOrSelectors
    WantBoth
        Maybe AmbiguousResult
    mr <- DuplicateRecordFields
    -> FieldsOrSelectors -> RdrName -> RnM (Maybe AmbiguousResult)
    lookupGlobalOccRn_overloaded DuplicateRecordFields
    dup_fields_ok FieldsOrSelectors
    want RdrName
    rdr_name
        case Maybe AmbiguousResult
    mr of
            Just AmbiguousResult
    r  -> forall (m :: * -> *) a. Monad m => a -> m a
    return AmbiguousResult
    r
            Maybe AmbiguousResult
    Nothing  -- Try again if we previously looked only for fields, see
                     -- Note [DisambiguateRecordFields for updates]
              | Bool
    disambig_ok -> do Maybe AmbiguousResult
    mr' <- DuplicateRecordFields
    -> FieldsOrSelectors -> RdrName -> RnM (Maybe AmbiguousResult)
    lookupGlobalOccRn_overloaded DuplicateRecordFields
    dup_fields_ok FieldsOrSelectors
    WantBoth RdrName
    rdr_name
                                  case Maybe AmbiguousResult
    mr' of
                                      Just AmbiguousResult
    r -> forall (m :: * -> *) a. Monad m => a -> m a
    return AmbiguousResult
    r
                                      Maybe AmbiguousResult
    Nothing -> RnM AmbiguousResult
    unbound
              | Bool
    otherwise   -> RnM AmbiguousResult
    unbound
      where
        unbound :: RnM AmbiguousResult
    unbound = GreName -> AmbiguousResult
    UnambiguousGre forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> GreName
    NormalGreName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> WhereLooking -> RdrName -> RnM Name
    unboundName WhereLooking
    WL_Global RdrName
    rdr_name

    {- Note [DisambiguateRecordFields]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When we are looking up record fields in record construction or pattern
    matching, we can take advantage of the data constructor name to
    resolve fields that would otherwise be ambiguous (provided the
    -XDisambiguateRecordFields flag is on).

    For example, consider:

       data S = MkS { x :: Int }
       data T = MkT { x :: Int }

       e = MkS { x = 3 }

    When we are renaming the occurrence of `x` in `e`, instead of looking
    `x` up directly (and finding both fields), lookupRecFieldOcc will
    search the fields of `MkS` to find the only possible `x` the user can
    mean.

    Of course, we still have to check the field is in scope, using
    lookupGRE_FieldLabel.  The handling of qualified imports is slightly
    subtle: the occurrence may be unqualified even if the field is
    imported only qualified (but if the occurrence is qualified, the
    qualifier must be correct). For example:

       module A where
         data S = MkS { x :: Int }
         data T = MkT { x :: Int }

       module B where
         import qualified A (S(..))
         import A (T(MkT))

         e1 = MkT   { x = 3 }   -- x not in scope, so fail
         e2 = A.MkS { B.x = 3 } -- module qualifier is wrong, so fail
         e3 = A.MkS { x = 3 }   -- x in scope (lack of module qualifier permitted)

    In case `e1`, lookupGRE_FieldLabel will return Nothing.  In case `e2`,
    lookupGRE_FieldLabel will return the GRE for `A.x`, but then the guard
    will fail because the field RdrName `B.x` is qualified and pickGREs
    rejects the GRE.  In case `e3`, lookupGRE_FieldLabel will return the
    GRE for `A.x` and the guard will succeed because the field RdrName `x`
    is unqualified.

    Note [DisambiguateRecordFields for updates]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When we are looking up record fields in record update, we can take advantage of
    the fact that we know we are looking for a field, even though we do not know the
    data constructor name (as in Note [DisambiguateRecordFields]), provided the
    -XDisambiguateRecordFields flag is on.

    For example, consider:

       module N where
         f = ()

       {-# LANGUAGE DisambiguateRecordFields #-}
       module M where
         import N (f)
         data T = MkT { f :: Int }
         t = MkT { f = 1 }  -- unambiguous because MkT determines which field we mean
         u = t { f = 2 }    -- unambiguous because we ignore the non-field 'f'

    This works by lookupRecFieldOcc_update using 'WantField :: FieldsOrSelectors'
    when looking up the field name, so that 'filterFieldGREs' will later ignore any
    non-fields in scope.  Of course, if a record update has two fields in scope with
    the same name, it is still ambiguous.

    If we do not find anything when looking only for fields, we try again allowing
    fields or non-fields.  This leads to a better error message if the user
    mistakenly tries to use a non-field name in a record update:

        f = ()
        e x = x { f = () }

    Unlike with constructors or pattern-matching, we do not allow the module
    qualifier to be omitted, because we do not have a data constructor from which to
    determine it.

    Note [Fall back on lookupGlobalOccRn in lookupRecFieldOcc]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Whenever we fail to find the field or it is not in scope, mb_field
    will be False, and we fall back on looking it up normally using
    lookupGlobalOccRn.  We don't report an error immediately because the
    actual problem might be located elsewhere.  For example (#9975):

       data Test = Test { x :: Int }
       pattern Test wat = Test { x = wat }

    Here there are multiple declarations of Test (as a data constructor
    and as a pattern synonym), which will be reported as an error.  We
    shouldn't also report an error about the occurrence of `x` in the
    pattern synonym RHS.  However, if the pattern synonym gets added to
    the environment first, we will try and fail to find `x` amongst the
    (nonexistent) fields of the pattern synonym.

    Alternatively, the scope check can fail due to Template Haskell.
    Consider (#12130):

       module Foo where
         import M
         b = $(funny)

       module M(funny) where
         data T = MkT { x :: Int }
         funny :: Q Exp
         funny = [| MkT { x = 3 } |]

    When we splice, `MkT` is not lexically in scope, so
    lookupGRE_FieldLabel will fail.  But there is no need for
    disambiguation anyway, because `x` is an original name, and
    lookupGlobalOccRn will find it.
    -}

    -- | Used in export lists to lookup the children.
    lookupSubBndrOcc_helper :: Bool -> Bool -> Name -> RdrName
                            -> RnM ChildLookupResult
    lookupSubBndrOcc_helper :: Bool -> Bool -> Name -> RdrName -> RnM ChildLookupResult
    lookupSubBndrOcc_helper Bool
    must_have_parent Bool
    warn_if_deprec Name
    parent RdrName
    rdr_name
      | Name -> Bool
    isUnboundName Name
    parent
        -- Avoid an error cascade
      = forall (m :: * -> *) a. Monad m => a -> m a
    return (Parent -> GreName -> ChildLookupResult
    FoundChild Parent
    NoParent (Name -> GreName
    NormalGreName (RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name)))

      | Bool
    otherwise = do
      GlobalRdrEnv
    gre_env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv

      let original_gres :: [GlobalRdrElt]
    original_gres = GlobalRdrEnv -> OccName -> [GlobalRdrElt]
    lookupGlobalRdrEnv GlobalRdrEnv
    gre_env (RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name)
      -- Disambiguate the lookup based on the parent information.
      -- The remaining GREs are things that we *could* export here, note that
      -- this includes things which have `NoParent`. Those are sorted in
      -- `checkPatSynParent`.
      String -> SDoc -> TcRn ()
    traceRn String
    "parent" (forall a. Outputable a => a -> SDoc
    ppr Name
    parent)
      String -> SDoc -> TcRn ()
    traceRn String
    "lookupExportChild original_gres:" (forall a. Outputable a => a -> SDoc
    ppr [GlobalRdrElt]
    original_gres)
      String -> SDoc -> TcRn ()
    traceRn String
    "lookupExportChild picked_gres:" (forall a. Outputable a => a -> SDoc
    ppr ([GlobalRdrElt] -> DisambigInfo
    picked_gres [GlobalRdrElt]
    original_gres) SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr Bool
    must_have_parent)
      case [GlobalRdrElt] -> DisambigInfo
    picked_gres [GlobalRdrElt]
    original_gres of
        DisambigInfo
    NoOccurrence ->
          [GlobalRdrElt] -> RnM ChildLookupResult
    noMatchingParentErr [GlobalRdrElt]
    original_gres
        UniqueOccurrence GlobalRdrElt
    g ->
          if Bool
    must_have_parent then [GlobalRdrElt] -> RnM ChildLookupResult
    noMatchingParentErr [GlobalRdrElt]
    original_gres
                              else GlobalRdrElt -> RnM ChildLookupResult
    checkFld GlobalRdrElt
    g
        DisambiguatedOccurrence GlobalRdrElt
    g ->
          GlobalRdrElt -> RnM ChildLookupResult
    checkFld GlobalRdrElt
    g
        AmbiguousOccurrence NonEmpty GlobalRdrElt
    gres ->
          NonEmpty GlobalRdrElt -> RnM ChildLookupResult
    mkNameClashErr NonEmpty GlobalRdrElt
    gres
        where
            -- Convert into FieldLabel if necessary
            checkFld :: GlobalRdrElt -> RnM ChildLookupResult
            checkFld :: GlobalRdrElt -> RnM ChildLookupResult
    checkFld g :: GlobalRdrElt
    g@GRE{GreName
    gre_name :: GlobalRdrElt -> GreName
    gre_name :: GreName
    gre_name,Parent
    gre_par :: GlobalRdrElt -> Parent
    gre_par :: Parent
    gre_par} = do
              Bool -> GlobalRdrElt -> TcRn ()
    addUsedGRE Bool
    warn_if_deprec GlobalRdrElt
    g
              forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $ Parent -> GreName -> ChildLookupResult
    FoundChild Parent
    gre_par GreName
    gre_name

            -- Called when we find no matching GREs after disambiguation but
            -- there are three situations where this happens.
            -- 1. There were none to begin with.
            -- 2. None of the matching ones were the parent but
            --  a. They were from an overloaded record field so we can report
            --     a better error
            --  b. The original lookup was actually ambiguous.
            --     For example, the case where overloading is off and two
            --     record fields are in scope from different record
            --     constructors, neither of which is the parent.
            noMatchingParentErr :: [GlobalRdrElt] -> RnM ChildLookupResult
            noMatchingParentErr :: [GlobalRdrElt] -> RnM ChildLookupResult
    noMatchingParentErr [GlobalRdrElt]
    original_gres = do
              String -> SDoc -> TcRn ()
    traceRn String
    "npe" (forall a. Outputable a => a -> SDoc
    ppr [GlobalRdrElt]
    original_gres)
              Bool
    dup_fields_ok <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.DuplicateRecordFields
              case [GlobalRdrElt]
    original_gres of
                [] ->  forall (m :: * -> *) a. Monad m => a -> m a
    return ChildLookupResult
    NameNotFound
                [GlobalRdrElt
    g] -> forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $ Name -> GreName -> [Name] -> ChildLookupResult
    IncorrectParent Name
    parent
                                  (GlobalRdrElt -> GreName
    gre_name GlobalRdrElt
    g)
                                  [Name
    p | Just Name
    p <- [GlobalRdrElt -> Maybe Name
    getParent GlobalRdrElt
    g]]
                gss :: [GlobalRdrElt]
    gss@(GlobalRdrElt
    g:gss' :: [GlobalRdrElt]
    gss'@(GlobalRdrElt
    _:[GlobalRdrElt]
    _)) ->
                  if forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all GlobalRdrElt -> Bool
    isRecFldGRE [GlobalRdrElt]
    gss Bool -> Bool -> Bool
    && Bool
    dup_fields_ok
                    then forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $
                          Name -> GreName -> [Name] -> ChildLookupResult
    IncorrectParent Name
    parent
                            (GlobalRdrElt -> GreName
    gre_name GlobalRdrElt
    g)
                            [Name
    p | GlobalRdrElt
    x <- [GlobalRdrElt]
    gss, Just Name
    p <- [GlobalRdrElt -> Maybe Name
    getParent GlobalRdrElt
    x]]
                    else NonEmpty GlobalRdrElt -> RnM ChildLookupResult
    mkNameClashErr forall a b. (a -> b) -> a -> b
    $ GlobalRdrElt
    g forall a. a -> [a] -> NonEmpty a
    NE.:| [GlobalRdrElt]
    gss'

            mkNameClashErr :: NE.NonEmpty GlobalRdrElt -> RnM ChildLookupResult
            mkNameClashErr :: NonEmpty GlobalRdrElt -> RnM ChildLookupResult
    mkNameClashErr NonEmpty GlobalRdrElt
    gres = do
              RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
    addNameClashErrRn RdrName
    rdr_name NonEmpty GlobalRdrElt
    gres
              forall (m :: * -> *) a. Monad m => a -> m a
    return (Parent -> GreName -> ChildLookupResult
    FoundChild (GlobalRdrElt -> Parent
    gre_par (forall a. NonEmpty a -> a
    NE.head NonEmpty GlobalRdrElt
    gres)) (GlobalRdrElt -> GreName
    gre_name (forall a. NonEmpty a -> a
    NE.head NonEmpty GlobalRdrElt
    gres)))

            getParent :: GlobalRdrElt -> Maybe Name
            getParent :: GlobalRdrElt -> Maybe Name
    getParent (GRE { gre_par :: GlobalRdrElt -> Parent
    gre_par = Parent
    p } ) =
              case Parent
    p of
                ParentIs Name
    cur_parent -> forall a. a -> Maybe a
    Just Name
    cur_parent
                Parent
    NoParent -> forall a. Maybe a
    Nothing

            picked_gres :: [GlobalRdrElt] -> DisambigInfo
            -- For Unqual, find GREs that are in scope qualified or unqualified
            -- For Qual,   find GREs that are in scope with that qualification
            picked_gres :: [GlobalRdrElt] -> DisambigInfo
    picked_gres [GlobalRdrElt]
    gres
              | RdrName -> Bool
    isUnqual RdrName
    rdr_name
              = forall a. Monoid a => [a] -> a
    mconcat (forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrElt -> DisambigInfo
    right_parent [GlobalRdrElt]
    gres)
              | Bool
    otherwise
              = forall a. Monoid a => [a] -> a
    mconcat (forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrElt -> DisambigInfo
    right_parent (RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
    pickGREs RdrName
    rdr_name [GlobalRdrElt]
    gres))

            right_parent :: GlobalRdrElt -> DisambigInfo
            right_parent :: GlobalRdrElt -> DisambigInfo
    right_parent GlobalRdrElt
    p
              = case GlobalRdrElt -> Maybe Name
    getParent GlobalRdrElt
    p of
                   Just Name
    cur_parent
                      | Name
    parent forall a. Eq a => a -> a -> Bool
    == Name
    cur_parent -> GlobalRdrElt -> DisambigInfo
    DisambiguatedOccurrence GlobalRdrElt
    p
                      | Bool
    otherwise            -> DisambigInfo
    NoOccurrence
                   Maybe Name
    Nothing                   -> GlobalRdrElt -> DisambigInfo
    UniqueOccurrence GlobalRdrElt
    p

    -- This domain specific datatype is used to record why we decided it was
    -- possible that a GRE could be exported with a parent.
    data DisambigInfo
           = NoOccurrence
              -- The GRE could never be exported. It has the wrong parent.
           | UniqueOccurrence GlobalRdrElt
              -- The GRE has no parent. It could be a pattern synonym.
           | DisambiguatedOccurrence GlobalRdrElt
              -- The parent of the GRE is the correct parent
           | AmbiguousOccurrence (NE.NonEmpty GlobalRdrElt)
              -- For example, two normal identifiers with the same name are in
              -- scope. They will both be resolved to "UniqueOccurrence" and the
              -- monoid will combine them to this failing case.

    instance Outputable DisambigInfo where
      ppr :: DisambigInfo -> SDoc
    ppr DisambigInfo
    NoOccurrence = String -> SDoc
    text String
    "NoOccurence"
      ppr (UniqueOccurrence GlobalRdrElt
    gre) = String -> SDoc
    text String
    "UniqueOccurrence:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr GlobalRdrElt
    gre
      ppr (DisambiguatedOccurrence GlobalRdrElt
    gre) = String -> SDoc
    text String
    "DiambiguatedOccurrence:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr GlobalRdrElt
    gre
      ppr (AmbiguousOccurrence NonEmpty GlobalRdrElt
    gres)    = String -> SDoc
    text String
    "Ambiguous:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr NonEmpty GlobalRdrElt
    gres

    instance Semi.Semigroup DisambigInfo where
      -- This is the key line: We prefer disambiguated occurrences to other
      -- names.
      DisambigInfo
    _ <> :: DisambigInfo -> DisambigInfo -> DisambigInfo
    <> DisambiguatedOccurrence GlobalRdrElt
    g' = GlobalRdrElt -> DisambigInfo
    DisambiguatedOccurrence GlobalRdrElt
    g'
      DisambiguatedOccurrence GlobalRdrElt
    g' <> DisambigInfo
    _ = GlobalRdrElt -> DisambigInfo
    DisambiguatedOccurrence GlobalRdrElt
    g'

      DisambigInfo
    NoOccurrence <> DisambigInfo
    m = DisambigInfo
    m
      DisambigInfo
    m <> DisambigInfo
    NoOccurrence = DisambigInfo
    m
      UniqueOccurrence GlobalRdrElt
    g <> UniqueOccurrence GlobalRdrElt
    g'
        = NonEmpty GlobalRdrElt -> DisambigInfo
    AmbiguousOccurrence forall a b. (a -> b) -> a -> b
    $ GlobalRdrElt
    g forall a. a -> [a] -> NonEmpty a
    NE.:| [GlobalRdrElt
    g']
      UniqueOccurrence GlobalRdrElt
    g <> AmbiguousOccurrence NonEmpty GlobalRdrElt
    gs
        = NonEmpty GlobalRdrElt -> DisambigInfo
    AmbiguousOccurrence (GlobalRdrElt
    g forall a. a -> NonEmpty a -> NonEmpty a
    `NE.cons` NonEmpty GlobalRdrElt
    gs)
      AmbiguousOccurrence NonEmpty GlobalRdrElt
    gs <> UniqueOccurrence GlobalRdrElt
    g'
        = NonEmpty GlobalRdrElt -> DisambigInfo
    AmbiguousOccurrence (GlobalRdrElt
    g' forall a. a -> NonEmpty a -> NonEmpty a
    `NE.cons` NonEmpty GlobalRdrElt
    gs)
      AmbiguousOccurrence NonEmpty GlobalRdrElt
    gs <> AmbiguousOccurrence NonEmpty GlobalRdrElt
    gs'
        = NonEmpty GlobalRdrElt -> DisambigInfo
    AmbiguousOccurrence (NonEmpty GlobalRdrElt
    gs forall a. Semigroup a => a -> a -> a
    Semi.<> NonEmpty GlobalRdrElt
    gs')

    instance Monoid DisambigInfo where
      mempty :: DisambigInfo
    mempty = DisambigInfo
    NoOccurrence
      mappend :: DisambigInfo -> DisambigInfo -> DisambigInfo
    mappend = forall a. Semigroup a => a -> a -> a
    (Semi.<>)

    -- Lookup SubBndrOcc can never be ambiguous
    --
    -- Records the result of looking up a child.
    data ChildLookupResult
          = NameNotFound                --  We couldn't find a suitable name
          | IncorrectParent Name        -- Parent
                            GreName     -- Child we were looking for
                            [Name]      -- List of possible parents
          | FoundChild Parent GreName   --  We resolved to a child

    -- | Specialised version of msum for RnM ChildLookupResult
    combineChildLookupResult :: [RnM ChildLookupResult] -> RnM ChildLookupResult
    combineChildLookupResult :: [RnM ChildLookupResult] -> RnM ChildLookupResult
    combineChildLookupResult [] = forall (m :: * -> *) a. Monad m => a -> m a
    return ChildLookupResult
    NameNotFound
    combineChildLookupResult (RnM ChildLookupResult
    x:[RnM ChildLookupResult]
    xs) = do
      ChildLookupResult
    res <- RnM ChildLookupResult
    x
      case ChildLookupResult
    res of
        ChildLookupResult
    NameNotFound -> [RnM ChildLookupResult] -> RnM ChildLookupResult
    combineChildLookupResult [RnM ChildLookupResult]
    xs
        ChildLookupResult
    _ -> forall (m :: * -> *) a. Monad m => a -> m a
    return ChildLookupResult
    res

    instance Outputable ChildLookupResult where
      ppr :: ChildLookupResult -> SDoc
    ppr ChildLookupResult
    NameNotFound = String -> SDoc
    text String
    "NameNotFound"
      ppr (FoundChild Parent
    p GreName
    n) = String -> SDoc
    text String
    "Found:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr Parent
    p SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr GreName
    n
      ppr (IncorrectParent Name
    p GreName
    n [Name]
    ns) = String -> SDoc
    text String
    "IncorrectParent"
                                      SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    hsep [forall a. Outputable a => a -> SDoc
    ppr Name
    p, forall a. Outputable a => a -> SDoc
    ppr GreName
    n, forall a. Outputable a => a -> SDoc
    ppr [Name]
    ns]

    lookupSubBndrOcc :: Bool
                     -> Name     -- Parent
                     -> SDoc
                     -> RdrName
                     -> RnM (Either SDoc Name)
    -- Find all the things the rdr-name maps to
    -- and pick the one with the right parent namep
    lookupSubBndrOcc :: Bool -> Name -> SDoc -> RdrName -> RnM (Either SDoc Name)
    lookupSubBndrOcc Bool
    warn_if_deprec Name
    the_parent SDoc
    doc RdrName
    rdr_name = do
      ChildLookupResult
    res <-
        forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig RdrName
    rdr_name (Parent -> GreName -> ChildLookupResult
    FoundChild Parent
    NoParent forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> GreName
    NormalGreName) forall a b. (a -> b) -> a -> b
    $
          -- This happens for built-in classes, see mod052 for example
          Bool -> Bool -> Name -> RdrName -> RnM ChildLookupResult
    lookupSubBndrOcc_helper Bool
    True Bool
    warn_if_deprec Name
    the_parent RdrName
    rdr_name
      case ChildLookupResult
    res of
        ChildLookupResult
    NameNotFound -> forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. a -> Either a b
    Left (SDoc -> RdrName -> SDoc
    unknownSubordinateErr SDoc
    doc RdrName
    rdr_name))
        FoundChild Parent
    _p GreName
    child -> forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right (GreName -> Name
    greNameMangledName GreName
    child))
        IncorrectParent {}
             -- See [Mismatched class methods and associated type families]
             -- in TcInstDecls.
          -> forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $ forall a b. a -> Either a b
    Left (SDoc -> RdrName -> SDoc
    unknownSubordinateErr SDoc
    doc RdrName
    rdr_name)

    {-
    Note [Family instance binders]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
      data family F a
      data instance F T = X1 | X2

    The 'data instance' decl has an *occurrence* of F (and T), and *binds*
    X1 and X2.  (This is unlike a normal data type declaration which would
    bind F too.)  So we want an AvailTC F [X1,X2].

    Now consider a similar pair:
      class C a where
        data G a
      instance C S where
        data G S = Y1 | Y2

    The 'data G S' *binds* Y1 and Y2, and has an *occurrence* of G.

    But there is a small complication: in an instance decl, we don't use
    qualified names on the LHS; instead we use the class to disambiguate.
    Thus:
      module M where
        import Blib( G )
        class C a where
          data G a
        instance C S where
          data G S = Y1 | Y2
    Even though there are two G's in scope (M.G and Blib.G), the occurrence
    of 'G' in the 'instance C S' decl is unambiguous, because C has only
    one associated type called G. This is exactly what happens for methods,
    and it is only consistent to do the same thing for types. That's the
    role of the function lookupTcdName; the (Maybe Name) give the class of
    the encloseing instance decl, if any.

    Note [Looking up Exact RdrNames]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Exact RdrNames are generated by:

    * Template Haskell (See Note [Binders in Template Haskell] in GHC.ThToHs)
    * Derived instances (See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate)

    For data types and classes have Exact system Names in the binding
    positions for constructors, TyCons etc.  For example
        [d| data T = MkT Int |]
    when we splice in and convert to HsSyn RdrName, we'll get
        data (Exact (system Name "T")) = (Exact (system Name "MkT")) ...
    These System names are generated by GHC.ThToHs.thRdrName

    But, constructors and the like need External Names, not System Names!
    So we do the following

     * In GHC.Rename.Env.newTopSrcBinder we spot Exact RdrNames that wrap a
       non-External Name, and make an External name for it. This is
       the name that goes in the GlobalRdrEnv

     * When looking up an occurrence of an Exact name, done in
       GHC.Rename.Env.lookupExactOcc, we find the Name with the right unique in the
       GlobalRdrEnv, and use the one from the envt -- it will be an
       External Name in the case of the data type/constructor above.

     * Exact names are also use for purely local binders generated
       by TH, such as    \x_33. x_33
       Both binder and occurrence are Exact RdrNames.  The occurrence
       gets looked up in the LocalRdrEnv by GHC.Rename.Env.lookupOccRn, and
       misses, because lookupLocalRdrEnv always returns Nothing for
       an Exact Name.  Now we fall through to lookupExactOcc, which
       will find the Name is not in the GlobalRdrEnv, so we just use
       the Exact supplied Name.

    Note [Splicing Exact names]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider the splice $(do { x <- newName "x"; return (VarE x) })
    This will generate a (HsExpr RdrName) term that mentions the
    Exact RdrName "x_56" (or whatever), but does not bind it.  So
    when looking such Exact names we want to check that it's in scope,
    otherwise the type checker will get confused.  To do this we need to
    keep track of all the Names in scope, and the LocalRdrEnv does just that;
    we consult it with RdrName.inLocalRdrEnvScope.

    There is another wrinkle.  With TH and -XDataKinds, consider
       $( [d| data Nat = Zero
              data T = MkT (Proxy 'Zero)  |] )
    After splicing, but before renaming we get this:
       data Nat_77{tc} = Zero_78{d}
       data T_79{tc} = MkT_80{d} (Proxy 'Zero_78{tc})  |] )
    The occurrence of 'Zero in the data type for T has the right unique,
    but it has a TcClsName name-space in its OccName.  (This is set by
    the ctxt_ns argument of Convert.thRdrName.)  When we check that is
    in scope in the GlobalRdrEnv, we need to look up the DataName namespace
    too.  (An alternative would be to make the GlobalRdrEnv also have
    a Name -> GRE mapping.)

    Note [Template Haskell ambiguity]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The GlobalRdrEnv invariant says that if
      occ -> [gre1, ..., gren]
    then the gres have distinct Names (INVARIANT 1 of GlobalRdrEnv).
    This is guaranteed by extendGlobalRdrEnvRn (the dups check in add_gre).

    So how can we get multiple gres in lookupExactOcc_maybe?  Because in
    TH we might use the same TH NameU in two different name spaces.
    eg (#7241):
       $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])
    Here we generate a type constructor and data constructor with the same
    unique, but different name spaces.

    It'd be nicer to rule this out in extendGlobalRdrEnvRn, but that would
    mean looking up the OccName in every name-space, just in case, and that
    seems a bit brutal.  So it's just done here on lookup.  But we might
    need to revisit that choice.

    Note [Usage for sub-bndrs]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~
    If you have this
       import qualified M( C( f ) )
       instance M.C T where
         f x = x
    then is the qualified import M.f used?  Obviously yes.
    But the RdrName used in the instance decl is unqualified.  In effect,
    we fill in the qualification by looking for f's whose class is M.C
    But when adding to the UsedRdrNames we must make that qualification
    explicit (saying "used  M.f"), otherwise we get "Redundant import of M.f".

    So we make up a suitable (fake) RdrName.  But be careful
       import qualified M
       import M( C(f) )
       instance C T where
         f x = x
    Here we want to record a use of 'f', not of 'M.f', otherwise
    we'll miss the fact that the qualified import is redundant.

    --------------------------------------------------
    --              Occurrences
    --------------------------------------------------
    -}

    lookupLocatedOccRn :: GenLocated (SrcSpanAnn' ann) RdrName
                       -> TcRn (GenLocated (SrcSpanAnn' ann) Name)
    lookupLocatedOccRn :: forall ann.
    GenLocated (SrcSpanAnn' ann) RdrName
    -> TcRn (GenLocated (SrcSpanAnn' ann) Name)
    lookupLocatedOccRn = forall a b ann.
    (a -> TcM b)
    -> GenLocated (SrcSpanAnn' ann) a
    -> TcRn (GenLocated (SrcSpanAnn' ann) b)
    wrapLocMA RdrName -> RnM Name
    lookupOccRn

    lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
    -- Just look in the local environment
    lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
    lookupLocalOccRn_maybe RdrName
    rdr_name
      = do { LocalRdrEnv
    local_env <- RnM LocalRdrEnv
    getLocalRdrEnv
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return (LocalRdrEnv -> RdrName -> Maybe Name
    lookupLocalRdrEnv LocalRdrEnv
    local_env RdrName
    rdr_name) }

    lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, ThLevel))
    -- Just look in the local environment
    lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, Arity))
    lookupLocalOccThLvl_maybe Name
    name
      = do { TcLclEnv
    lcl_env <- forall gbl lcl. TcRnIf gbl lcl lcl
    getLclEnv
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a. NameEnv a -> Name -> Maybe a
    lookupNameEnv (TcLclEnv -> ThBindEnv
    tcl_th_bndrs TcLclEnv
    lcl_env) Name
    name) }

    -- lookupOccRn looks up an occurrence of a RdrName
    lookupOccRn :: RdrName -> RnM Name
    lookupOccRn :: RdrName -> RnM Name
    lookupOccRn RdrName
    rdr_name
      = do { Maybe Name
    mb_name <- RdrName -> RnM (Maybe Name)
    lookupOccRn_maybe RdrName
    rdr_name
           ; case Maybe Name
    mb_name of
               Just Name
    name -> forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name
               Maybe Name
    Nothing   -> RdrName -> RnM Name
    reportUnboundName RdrName
    rdr_name }

    -- Only used in one place, to rename pattern synonym binders.
    -- See Note [Renaming pattern synonym variables] in GHC.Rename.Bind
    lookupLocalOccRn :: RdrName -> RnM Name
    lookupLocalOccRn :: RdrName -> RnM Name
    lookupLocalOccRn RdrName
    rdr_name
      = do { Maybe Name
    mb_name <- RdrName -> RnM (Maybe Name)
    lookupLocalOccRn_maybe RdrName
    rdr_name
           ; case Maybe Name
    mb_name of
               Just Name
    name -> forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name
               Maybe Name
    Nothing   -> WhereLooking -> RdrName -> RnM Name
    unboundName WhereLooking
    WL_LocalOnly RdrName
    rdr_name }

    -- lookupTypeOccRn looks up an optionally promoted RdrName.
    -- Used for looking up type variables.
    lookupTypeOccRn :: RdrName -> RnM Name
    -- see Note [Demotion]
    lookupTypeOccRn :: RdrName -> RnM Name
    lookupTypeOccRn RdrName
    rdr_name
      | OccName -> Bool
    isVarOcc (RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name)  -- See Note [Promoted variables in types]
      = RdrName -> RnM Name
    badVarInType RdrName
    rdr_name
      | Bool
    otherwise
      = do { Maybe Name
    mb_name <- RdrName -> RnM (Maybe Name)
    lookupOccRn_maybe RdrName
    rdr_name
           ; case Maybe Name
    mb_name of
                 Just Name
    name -> forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name
                 Maybe Name
    Nothing   -> RdrName -> RnM Name
    lookup_demoted RdrName
    rdr_name }

    lookup_demoted :: RdrName -> RnM Name
    lookup_demoted :: RdrName -> RnM Name
    lookup_demoted RdrName
    rdr_name
      | Just RdrName
    demoted_rdr <- RdrName -> Maybe RdrName
    demoteRdrName RdrName
    rdr_name
        -- Maybe it's the name of a *data* constructor
      = do { Bool
    data_kinds <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.DataKinds
           ; Bool
    star_is_type <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.StarIsType
           ; let star_info :: SDoc
    star_info = Bool -> RdrName -> SDoc
    starInfo Bool
    star_is_type RdrName
    rdr_name
           ; if Bool
    data_kinds
                then do { Maybe Name
    mb_demoted_name <- RdrName -> RnM (Maybe Name)
    lookupOccRn_maybe RdrName
    demoted_rdr
                        ; case Maybe Name
    mb_demoted_name of
                            Maybe Name
    Nothing -> WhereLooking -> RdrName -> SDoc -> RnM Name
    unboundNameX WhereLooking
    WL_Any RdrName
    rdr_name SDoc
    star_info
                            Just Name
    demoted_name ->
                              do { forall gbl lcl.
    WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    whenWOptM WarningFlag
    Opt_WarnUntickedPromotedConstructors forall a b. (a -> b) -> a -> b
    $
                                   WarnReason -> SDoc -> TcRn ()
    addWarn
                                     (WarningFlag -> WarnReason
    Reason WarningFlag
    Opt_WarnUntickedPromotedConstructors)
                                     (forall a. Outputable a => a -> SDoc
    untickedPromConstrWarn Name
    demoted_name)
                                 ; forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    demoted_name } }
                else do { -- We need to check if a data constructor of this name is
                          -- in scope to give good error messages. However, we do
                          -- not want to give an additional error if the data
                          -- constructor happens to be out of scope! See #13947.
                          Maybe Name
    mb_demoted_name <- forall a. TcRn a -> TcRn a
    discardErrs forall a b. (a -> b) -> a -> b
    $
                                             RdrName -> RnM (Maybe Name)
    lookupOccRn_maybe RdrName
    demoted_rdr
                        ; let suggestion :: SDoc
    suggestion | forall a. Maybe a -> Bool
    isJust Maybe Name
    mb_demoted_name = SDoc
    suggest_dk
                                         | Bool
    otherwise = SDoc
    star_info
                        ; WhereLooking -> RdrName -> SDoc -> RnM Name
    unboundNameX WhereLooking
    WL_Any RdrName
    rdr_name SDoc
    suggestion } }

      | Bool
    otherwise
      = RdrName -> RnM Name
    reportUnboundName RdrName
    rdr_name

      where
        suggest_dk :: SDoc
    suggest_dk = String -> SDoc
    text String
    "A data constructor of that name is in scope; did you mean DataKinds?"
        untickedPromConstrWarn :: a -> SDoc
    untickedPromConstrWarn a
    name =
          String -> SDoc
    text String
    "Unticked promoted constructor" SDoc -> SDoc -> SDoc
    <> SDoc
    colon SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr a
    name) SDoc -> SDoc -> SDoc
    <> SDoc
    dot
          SDoc -> SDoc -> SDoc
    $$
          [SDoc] -> SDoc
    hsep [ String -> SDoc
    text String
    "Use"
               , SDoc -> SDoc
    quotes (Char -> SDoc
    char Char
    '\'' SDoc -> SDoc -> SDoc
    <> forall a. Outputable a => a -> SDoc
    ppr a
    name)
               , String -> SDoc
    text String
    "instead of"
               , SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr a
    name) SDoc -> SDoc -> SDoc
    <> SDoc
    dot ]

    -- If the given RdrName can be promoted to the type level and its promoted variant is in scope,
    -- lookup_promoted returns the corresponding type-level Name.
    -- Otherwise, the function returns Nothing.
    -- See Note [Promotion] below.
    lookup_promoted :: RdrName -> RnM (Maybe Name)
    lookup_promoted :: RdrName -> RnM (Maybe Name)
    lookup_promoted RdrName
    rdr_name
      | Just RdrName
    promoted_rdr <- RdrName -> Maybe RdrName
    promoteRdrName RdrName
    rdr_name
      = RdrName -> RnM (Maybe Name)
    lookupOccRn_maybe RdrName
    promoted_rdr
      | Bool
    otherwise
      = forall (m :: * -> *) a. Monad m => a -> m a
    return forall a. Maybe a
    Nothing

    badVarInType :: RdrName -> RnM Name
    badVarInType :: RdrName -> RnM Name
    badVarInType RdrName
    rdr_name
      = do { SDoc -> TcRn ()
    addErr (String -> SDoc
    text String
    "Illegal promoted term variable in a type:"
                     SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return (RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name) }

    {- Note [Promoted variables in types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider this (#12686):
       x = True
       data Bad = Bad 'x

    The parser treats the quote in 'x as saying "use the term
    namespace", so we'll get (Bad x{v}), with 'x' in the
    VarName namespace.  If we don't test for this, the renamer
    will happily rename it to the x bound at top level, and then
    the typecheck falls over because it doesn't have 'x' in scope
    when kind-checking.

    Note [Demotion]
    ~~~~~~~~~~~~~~~
    When the user writes:
      data Nat = Zero | Succ Nat
      foo :: f Zero -> Int

    'Zero' in the type signature of 'foo' is parsed as:
      HsTyVar ("Zero", TcClsName)

    When the renamer hits this occurrence of 'Zero' it's going to realise
    that it's not in scope. But because it is renaming a type, it knows
    that 'Zero' might be a promoted data constructor, so it will demote
    its namespace to DataName and do a second lookup.

    The final result (after the renamer) will be:
      HsTyVar ("Zero", DataName)

    Note [Promotion]
    ~~~~~~~~~~~~~~~
    When the user mentions a type constructor or a type variable in a
    term-level context, then we report that a value identifier was expected
    instead of a type-level one. That makes error messages more precise.
    Previously, such errors contained only the info that a given value was out of scope (#18740).
    We promote the namespace of RdrName and look up after that
    (see the functions promotedRdrName and lookup_promoted).

    In particular, we have the following error message
      • Illegal term-level use of the type constructor ‘Int’
          imported from ‘Prelude’ (and originally defined in ‘GHC.Types’)
      • In the first argument of ‘id’, namely ‘Int’
        In the expression: id Int
        In an equation for ‘x’: x = id Int

    when the user writes the following declaration

      x = id Int
    -}

    lookupOccRnX_maybe :: (RdrName -> RnM (Maybe r)) -> (Name -> r) -> RdrName
                       -> RnM (Maybe r)
    lookupOccRnX_maybe :: forall r.
    (RdrName -> RnM (Maybe r))
    -> (Name -> r) -> RdrName -> RnM (Maybe r)
    lookupOccRnX_maybe RdrName -> RnM (Maybe r)
    globalLookup Name -> r
    wrapper RdrName
    rdr_name
      = forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
    runMaybeT forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall (t :: * -> *) (m :: * -> *) a.
    (Foldable t, MonadPlus m) =>
    t (m a) -> m a
    msum forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a b. (a -> b) -> [a] -> [b]
    map forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT forall a b. (a -> b) -> a -> b
    $
          [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Name -> r
    wrapper forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RdrName -> RnM (Maybe Name)
    lookupLocalOccRn_maybe RdrName
    rdr_name
          , RdrName -> RnM (Maybe r)
    globalLookup RdrName
    rdr_name ]

    -- Used outside this module only by TH name reification (lookupName, lookupThName_maybe)
    lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
    lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
    lookupOccRn_maybe = forall r.
    (RdrName -> RnM (Maybe r))
    -> (Name -> r) -> RdrName -> RnM (Maybe r)
    lookupOccRnX_maybe RdrName -> RnM (Maybe Name)
    lookupGlobalOccRn_maybe forall a. a -> a
    id

    -- | Look up a 'RdrName' used as a variable in an expression.
    --
    -- This may be a local variable, global variable, or one or more record selector
    -- functions.  It will not return record fields created with the
    -- @NoFieldSelectors@ extension (see Note [NoFieldSelectors]).  The
    -- 'DuplicateRecordFields' argument controls whether ambiguous fields will be
    -- allowed (resulting in an 'AmbiguousFields' result being returned).
    --
    -- If the name is not in scope at the term level, but its promoted equivalent is
    -- in scope at the type level, the lookup will succeed (so that the type-checker
    -- can report a more informative error later).  See Note [Promotion].
    --
    lookupExprOccRn
      :: DuplicateRecordFields -> RdrName
      -> RnM (Maybe AmbiguousResult)
    lookupExprOccRn :: DuplicateRecordFields -> RdrName -> RnM (Maybe AmbiguousResult)
    lookupExprOccRn DuplicateRecordFields
    dup_fields_ok RdrName
    rdr_name
      = do { Maybe AmbiguousResult
    mb_name <- forall r.
    (RdrName -> RnM (Maybe r))
    -> (Name -> r) -> RdrName -> RnM (Maybe r)
    lookupOccRnX_maybe RdrName -> RnM (Maybe AmbiguousResult)
    global_lookup (GreName -> AmbiguousResult
    UnambiguousGre forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> GreName
    NormalGreName) RdrName
    rdr_name
           ; case Maybe AmbiguousResult
    mb_name of
               Maybe AmbiguousResult
    Nothing   -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap @Maybe (GreName -> AmbiguousResult
    UnambiguousGre forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> GreName
    NormalGreName) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RdrName -> RnM (Maybe Name)
    lookup_promoted RdrName
    rdr_name
                            -- See Note [Promotion].
                            -- We try looking up the name as a
                            -- type constructor or type variable, if
                            -- we failed to look up the name at the term level.
               Maybe AmbiguousResult
    p         -> forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AmbiguousResult
    p }

      where
        global_lookup :: RdrName -> RnM (Maybe AmbiguousResult)
        global_lookup :: RdrName -> RnM (Maybe AmbiguousResult)
    global_lookup = DuplicateRecordFields
    -> FieldsOrSelectors -> RdrName -> RnM (Maybe AmbiguousResult)
    lookupGlobalOccRn_overloaded DuplicateRecordFields
    dup_fields_ok FieldsOrSelectors
    WantNormal

    lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
    -- Looks up a RdrName occurrence in the top-level
    -- environment, including using lookupQualifiedNameGHCi
    -- for the GHCi case, but first tries to find an Exact or Orig name.
    -- No filter function; does not report an error on failure
    -- See Note [Errors in lookup functions]
    -- Uses addUsedRdrName to record use and deprecations
    --
    -- Used directly only by getLocalNonValBinders (new_assoc).
    lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
    lookupGlobalOccRn_maybe RdrName
    rdr_name =
      forall r. RdrName -> (Maybe Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig_maybe RdrName
    rdr_name forall a. a -> a
    id (FieldsOrSelectors -> RdrName -> RnM (Maybe Name)
    lookupGlobalOccRn_base FieldsOrSelectors
    WantNormal RdrName
    rdr_name)

    lookupGlobalOccRn :: RdrName -> RnM Name
    -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
    -- environment.  Adds an error message if the RdrName is not in scope.
    -- You usually want to use "lookupOccRn" which also looks in the local
    -- environment.
    --
    -- Used by exports_from_avail
    lookupGlobalOccRn :: RdrName -> RnM Name
    lookupGlobalOccRn = FieldsOrSelectors -> RdrName -> RnM Name
    lookupGlobalOccRn' FieldsOrSelectors
    WantNormal

    lookupGlobalOccRn' :: FieldsOrSelectors -> RdrName -> RnM Name
    lookupGlobalOccRn' :: FieldsOrSelectors -> RdrName -> RnM Name
    lookupGlobalOccRn' FieldsOrSelectors
    fos RdrName
    rdr_name =
      forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig RdrName
    rdr_name forall a. a -> a
    id forall a b. (a -> b) -> a -> b
    $ do
        Maybe Name
    mn <- FieldsOrSelectors -> RdrName -> RnM (Maybe Name)
    lookupGlobalOccRn_base FieldsOrSelectors
    fos RdrName
    rdr_name
        case Maybe Name
    mn of
          Just Name
    n -> forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    n
          Maybe Name
    Nothing -> do { String -> SDoc -> TcRn ()
    traceRn String
    "lookupGlobalOccRn" (forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)
                        ; WhereLooking -> RdrName -> RnM Name
    unboundName WhereLooking
    WL_Global RdrName
    rdr_name }

    -- Looks up a RdrName occurrence in the GlobalRdrEnv and with
    -- lookupQualifiedNameGHCi. Does not try to find an Exact or Orig name first.
    -- lookupQualifiedNameGHCi here is used when we're in GHCi and a name like
    -- 'Data.Map.elems' is typed, even if you didn't import Data.Map
    lookupGlobalOccRn_base :: FieldsOrSelectors -> RdrName -> RnM (Maybe Name)
    lookupGlobalOccRn_base :: FieldsOrSelectors -> RdrName -> RnM (Maybe Name)
    lookupGlobalOccRn_base FieldsOrSelectors
    fos RdrName
    rdr_name =
      forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
    runMaybeT forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall (t :: * -> *) (m :: * -> *) a.
    (Foldable t, MonadPlus m) =>
    t (m a) -> m a
    msum forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a b. (a -> b) -> [a] -> [b]
    map forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT forall a b. (a -> b) -> a -> b
    $
        [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap GlobalRdrElt -> Name
    greMangledName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> FieldsOrSelectors -> RdrName -> RnM (Maybe GlobalRdrElt)
    lookupGreRn_maybe FieldsOrSelectors
    fos RdrName
    rdr_name
        , forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap GreName -> Name
    greNameMangledName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> FieldsOrSelectors -> RdrName -> RnM (Maybe GreName)
    lookupOneQualifiedNameGHCi FieldsOrSelectors
    fos RdrName
    rdr_name ]
                          -- This test is not expensive,
                          -- and only happens for failed lookups

    lookupInfoOccRn :: RdrName -> RnM [Name]
    -- lookupInfoOccRn is intended for use in GHCi's ":info" command
    -- It finds all the GREs that RdrName could mean, not complaining
    -- about ambiguity, but rather returning them all
    -- C.f. #9881
    -- lookupInfoOccRn is also used in situations where we check for
    -- at least one definition of the RdrName, not complaining about
    -- multiple definitions. (See #17832)
    lookupInfoOccRn :: RdrName -> RnM [Name]
    lookupInfoOccRn RdrName
    rdr_name =
      forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig RdrName
    rdr_name (forall a. a -> [a] -> [a]
    :[]) forall a b. (a -> b) -> a -> b
    $
        do { GlobalRdrEnv
    rdr_env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv
           ; let ns :: [Name]
    ns = forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrElt -> Name
    greMangledName (RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
    lookupGRE_RdrName' RdrName
    rdr_name GlobalRdrEnv
    rdr_env)
           ; [Name]
    qual_ns <- forall a b. (a -> b) -> [a] -> [b]
    map GreName -> Name
    greNameMangledName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> FieldsOrSelectors -> RdrName -> RnM [GreName]
    lookupQualifiedNameGHCi FieldsOrSelectors
    WantBoth RdrName
    rdr_name
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return ([Name]
    ns forall a. [a] -> [a] -> [a]
    ++ ([Name]
    qual_ns forall a. Ord a => [a] -> [a] -> [a]
    `minusList` [Name]
    ns)) }

    -- | Like 'lookupOccRn_maybe', but with a more informative result if
    -- the 'RdrName' happens to be a record selector:
    --
    --   * Nothing                 -> name not in scope (no error reported)
    --   * Just (UnambiguousGre x) -> name uniquely refers to x,
    --                                or there is a name clash (reported)
    --   * Just AmbiguousFields    -> name refers to two or more record fields
    --                                (no error reported)
    --
    -- See Note [ Unbound vs Ambiguous Names ].
    lookupGlobalOccRn_overloaded :: DuplicateRecordFields -> FieldsOrSelectors -> RdrName
                                 -> RnM (Maybe AmbiguousResult)
    lookupGlobalOccRn_overloaded :: DuplicateRecordFields
    -> FieldsOrSelectors -> RdrName -> RnM (Maybe AmbiguousResult)
    lookupGlobalOccRn_overloaded DuplicateRecordFields
    dup_fields_ok FieldsOrSelectors
    fos RdrName
    rdr_name =
      forall r. RdrName -> (Maybe Name -> r) -> RnM r -> RnM r
    lookupExactOrOrig_maybe RdrName
    rdr_name (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (GreName -> AmbiguousResult
    UnambiguousGre forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> GreName
    NormalGreName)) forall a b. (a -> b) -> a -> b
    $
        do { GreLookupResult
    res <- FieldsOrSelectors -> RdrName -> RnM GreLookupResult
    lookupGreRn_helper FieldsOrSelectors
    fos RdrName
    rdr_name
           ; case GreLookupResult
    res of
               GreLookupResult
    GreNotFound -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap GreName -> AmbiguousResult
    UnambiguousGre forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> FieldsOrSelectors -> RdrName -> RnM (Maybe GreName)
    lookupOneQualifiedNameGHCi FieldsOrSelectors
    fos RdrName
    rdr_name
               OneNameMatch GlobalRdrElt
    gre -> forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $ forall a. a -> Maybe a
    Just (GreName -> AmbiguousResult
    UnambiguousGre (GlobalRdrElt -> GreName
    gre_name GlobalRdrElt
    gre))
               MultipleNames NonEmpty GlobalRdrElt
    gres
                 | forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all GlobalRdrElt -> Bool
    isRecFldGRE NonEmpty GlobalRdrElt
    gres
                 , DuplicateRecordFields
    dup_fields_ok forall a. Eq a => a -> a -> Bool
    == DuplicateRecordFields
    DuplicateRecordFields -> forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $ forall a. a -> Maybe a
    Just AmbiguousResult
    AmbiguousFields
                 | Bool
    otherwise -> do
                      RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
    addNameClashErrRn RdrName
    rdr_name NonEmpty GlobalRdrElt
    gres
                      forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a. a -> Maybe a
    Just (GreName -> AmbiguousResult
    UnambiguousGre (GlobalRdrElt -> GreName
    gre_name (forall a. NonEmpty a -> a
    NE.head NonEmpty GlobalRdrElt
    gres)))) }

    -- | Result of looking up an occurrence that might be an ambiguous field.
    data AmbiguousResult
        = UnambiguousGre GreName
        -- ^ Occurrence picked out a single name, which may or may not belong to a
        -- field (or might be unbound, if an error has been reported already, per
        -- Note [ Unbound vs Ambiguous Names ]).
        | AmbiguousFields
        -- ^ Occurrence picked out two or more fields, and no non-fields.  For now
        -- this is allowed by DuplicateRecordFields in certain circumstances, as the
        -- type-checker may be able to disambiguate later.

    {-
    Note [NoFieldSelectors]
    ~~~~~~~~~~~~~~~~~~~~~~~
    The NoFieldSelectors extension allows record fields to be defined without
    bringing the corresponding selector functions into scope.  However, such fields
    may still be used in contexts such as record construction, pattern matching or
    update. This requires us to distinguish contexts in which selectors are required
    from those in which any field may be used.  For example:

      {-# LANGUAGE NoFieldSelectors #-}
      module M (T(foo), foo) where  -- T(foo) refers to the field,
                                    -- unadorned foo to the value binding
        data T = MkT { foo :: Int }
        foo = ()

        bar = foo -- refers to the value binding, field ignored

      module N where
        import M (T(..))
        baz = MkT { foo = 3 } -- refers to the field
        oops = foo -- an error: the field is in scope but the value binding is not

    Each 'FieldLabel' indicates (in the 'flHasFieldSelector' field) whether the
    FieldSelectors extension was enabled in the defining module.  This allows them
    to be filtered out by 'filterFieldGREs'.

    Even when NoFieldSelectors is in use, we still generate selector functions
    internally. For example, the expression
       getField @"foo" t
    or (with dot-notation)
       t.foo
    extracts the `foo` field of t::T, and hence needs the selector function
    (see Note [HasField instances] in GHC.Tc.Instance.Class).  In order to avoid
    name clashes with normal bindings reusing the names, selector names for such
    fields are mangled just as for DuplicateRecordFields (see Note [FieldLabel] in
    GHC.Types.FieldLabel).

    In many of the name lookup functions in this module we pass a FieldsOrSelectors
    value, indicating what we are looking for:

     * WantNormal: fields are in scope only if they have an accompanying selector
       function, e.g. we are looking up a variable in an expression
       (lookupExprOccRn).

     * WantBoth: any name or field will do, regardless of whether the selector
       function is available, e.g. record updates (lookupRecFieldOcc_update) with
       NoDisambiguateRecordFields.

     * WantField: any field will do, regardless of whether the selector function is
       available, but ignoring any non-field names, e.g. record updates
       (lookupRecFieldOcc_update) with DisambiguateRecordFields.

    -----------------------------------------------------------------------------------
      Context                                  FieldsOrSelectors
    -----------------------------------------------------------------------------------
      Record construction/pattern match        WantBoth if NoDisambiguateRecordFields
      e.g. MkT { foo = 3 }                     (DisambiguateRecordFields is separate)

      Record update                            WantBoth if NoDisambiguateRecordFields
      e.g. e { foo = 3 }                       WantField if DisambiguateRecordFields

      :info in GHCi                            WantBoth

      Variable occurrence in expression        WantNormal
      Type variable, data constructor
      Pretty much everything else
    -----------------------------------------------------------------------------------
    -}

    -- | When looking up GREs, we may or may not want to include fields that were
    -- defined in modules with @NoFieldSelectors@ enabled.  See Note
    -- [NoFieldSelectors].
    data FieldsOrSelectors
        = WantNormal -- ^ Include normal names, and fields with selectors, but
                     -- ignore fields without selectors.
        | WantBoth   -- ^ Include normal names and all fields (regardless of whether
                     -- they have selectors).
        | WantField  -- ^ Include only fields, with or without selectors, ignoring
                     -- any non-fields in scope.
      deriving FieldsOrSelectors -> FieldsOrSelectors -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
    $c/= :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
    == :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
    $c== :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
    Eq

    filterFieldGREs :: FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
    filterFieldGREs :: FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
    filterFieldGREs FieldsOrSelectors
    fos = forall a. (a -> Bool) -> [a] -> [a]
    filter (FieldsOrSelectors -> GreName -> Bool
    allowGreName FieldsOrSelectors
    fos forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GlobalRdrElt -> GreName
    gre_name)

    allowGreName :: FieldsOrSelectors -> GreName -> Bool
    allowGreName :: FieldsOrSelectors -> GreName -> Bool
    allowGreName FieldsOrSelectors
    WantBoth   GreName
    _                 = Bool
    True
    allowGreName FieldsOrSelectors
    WantNormal (FieldGreName FieldLabel
    fl) = FieldLabel -> FieldSelectors
    flHasFieldSelector FieldLabel
    fl forall a. Eq a => a -> a -> Bool
    == FieldSelectors
    FieldSelectors
    allowGreName FieldsOrSelectors
    WantNormal (NormalGreName Name
    _) = Bool
    True
    allowGreName FieldsOrSelectors
    WantField  (FieldGreName  FieldLabel
    _) = Bool
    True
    allowGreName FieldsOrSelectors
    WantField  (NormalGreName Name
    _) = Bool
    False

    --------------------------------------------------
    --      Lookup in the Global RdrEnv of the module
    --------------------------------------------------

    data GreLookupResult = GreNotFound
                         | OneNameMatch GlobalRdrElt
                         | MultipleNames (NE.NonEmpty GlobalRdrElt)

    lookupGreRn_maybe :: FieldsOrSelectors -> RdrName -> RnM (Maybe GlobalRdrElt)
    -- Look up the RdrName in the GlobalRdrEnv
    --   Exactly one binding: records it as "used", return (Just gre)
    --   No bindings:         return Nothing
    --   Many bindings:       report "ambiguous", return an arbitrary (Just gre)
    -- Uses addUsedRdrName to record use and deprecations
    lookupGreRn_maybe :: FieldsOrSelectors -> RdrName -> RnM (Maybe GlobalRdrElt)
    lookupGreRn_maybe FieldsOrSelectors
    fos RdrName
    rdr_name
      = do
          GreLookupResult
    res <- FieldsOrSelectors -> RdrName -> RnM GreLookupResult
    lookupGreRn_helper FieldsOrSelectors
    fos RdrName
    rdr_name
          case GreLookupResult
    res of
            OneNameMatch GlobalRdrElt
    gre ->  forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $ forall a. a -> Maybe a
    Just GlobalRdrElt
    gre
            MultipleNames NonEmpty GlobalRdrElt
    gres -> do
              String -> SDoc -> TcRn ()
    traceRn String
    "lookupGreRn_maybe:NameClash" (forall a. Outputable a => a -> SDoc
    ppr NonEmpty GlobalRdrElt
    gres)
              RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
    addNameClashErrRn RdrName
    rdr_name NonEmpty GlobalRdrElt
    gres
              forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $ forall a. a -> Maybe a
    Just (forall a. NonEmpty a -> a
    NE.head NonEmpty GlobalRdrElt
    gres)
            GreLookupResult
    GreNotFound -> forall (m :: * -> *) a. Monad m => a -> m a
    return forall a. Maybe a
    Nothing

    {-

    Note [ Unbound vs Ambiguous Names ]

    lookupGreRn_maybe deals with failures in two different ways. If a name
    is unbound then we return a `Nothing` but if the name is ambiguous
    then we raise an error and return a dummy name.

    The reason for this is that when we call `lookupGreRn_maybe` we are
    speculatively looking for whatever we are looking up. If we don't find it,
    then we might have been looking for the wrong thing and can keep trying.
    On the other hand, if we find a clash then there is no way to recover as
    we found the thing we were looking for but can no longer resolve which
    the correct one is.

    One example of this is in `lookupTypeOccRn` which first looks in the type
    constructor namespace before looking in the data constructor namespace to
    deal with `DataKinds`.

    There is however, as always, one exception to this scheme. If we find
    an ambiguous occurrence of a record selector and DuplicateRecordFields
    is enabled then we defer the selection until the typechecker.

    -}

    -- Internal Function
    lookupGreRn_helper :: FieldsOrSelectors -> RdrName -> RnM GreLookupResult
    lookupGreRn_helper :: FieldsOrSelectors -> RdrName -> RnM GreLookupResult
    lookupGreRn_helper FieldsOrSelectors
    fos RdrName
    rdr_name
      = do  { GlobalRdrEnv
    env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv
            ; case FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
    filterFieldGREs FieldsOrSelectors
    fos (RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
    lookupGRE_RdrName' RdrName
    rdr_name GlobalRdrEnv
    env) of
                []    -> forall (m :: * -> *) a. Monad m => a -> m a
    return GreLookupResult
    GreNotFound
                [GlobalRdrElt
    gre] -> do { Bool -> GlobalRdrElt -> TcRn ()
    addUsedGRE Bool
    True GlobalRdrElt
    gre
                            ; forall (m :: * -> *) a. Monad m => a -> m a
    return (GlobalRdrElt -> GreLookupResult
    OneNameMatch GlobalRdrElt
    gre) }
                -- Don't record usage for ambiguous names
                -- until we know which is meant
                (GlobalRdrElt
    gre:[GlobalRdrElt]
    gres) -> forall (m :: * -> *) a. Monad m => a -> m a
    return (NonEmpty GlobalRdrElt -> GreLookupResult
    MultipleNames (GlobalRdrElt
    gre forall a. a -> [a] -> NonEmpty a
    NE.:| [GlobalRdrElt]
    gres)) }

    lookupGreAvailRn :: RdrName -> RnM (Name, AvailInfo)
    -- Used in export lists
    -- If not found or ambiguous, add error message, and fake with UnboundName
    -- Uses addUsedRdrName to record use and deprecations
    lookupGreAvailRn :: RdrName -> RnM (Name, AvailInfo)
    lookupGreAvailRn RdrName
    rdr_name
      = do
          GreLookupResult
    mb_gre <- FieldsOrSelectors -> RdrName -> RnM GreLookupResult
    lookupGreRn_helper FieldsOrSelectors
    WantNormal RdrName
    rdr_name
          case GreLookupResult
    mb_gre of
            GreLookupResult
    GreNotFound ->
              do
                String -> SDoc -> TcRn ()
    traceRn String
    "lookupGreAvailRn" (forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)
                Name
    name <- WhereLooking -> RdrName -> RnM Name
    unboundName WhereLooking
    WL_Global RdrName
    rdr_name
                forall (m :: * -> *) a. Monad m => a -> m a
    return (Name
    name, Name -> AvailInfo
    avail Name
    name)
            MultipleNames NonEmpty GlobalRdrElt
    gres ->
              do
                RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
    addNameClashErrRn RdrName
    rdr_name NonEmpty GlobalRdrElt
    gres
                let unbound_name :: Name
    unbound_name = RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name
                forall (m :: * -> *) a. Monad m => a -> m a
    return (Name
    unbound_name, Name -> AvailInfo
    avail Name
    unbound_name)
                            -- Returning an unbound name here prevents an error
                            -- cascade
            OneNameMatch GlobalRdrElt
    gre ->
              forall (m :: * -> *) a. Monad m => a -> m a
    return (GlobalRdrElt -> Name
    greMangledName GlobalRdrElt
    gre, GlobalRdrElt -> AvailInfo
    availFromGRE GlobalRdrElt
    gre)

    {-
    *********************************************************
    *                                                      *
                    Deprecations
    *                                                      *
    *********************************************************

    Note [Handling of deprecations]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    * We report deprecations at each *occurrence* of the deprecated thing
      (see #5867)

    * We do not report deprecations for locally-defined names. For a
      start, we may be exporting a deprecated thing. Also we may use a
      deprecated thing in the defn of another deprecated things.  We may
      even use a deprecated thing in the defn of a non-deprecated thing,
      when changing a module's interface.

    * addUsedGREs: we do not report deprecations for sub-binders:
         - the ".." completion for records
         - the ".." in an export item 'T(..)'
         - the things exported by a module export 'module M'
    -}

    addUsedDataCons :: GlobalRdrEnv -> TyCon -> RnM ()
    -- Remember use of in-scope data constructors (#7969)
    addUsedDataCons :: GlobalRdrEnv -> TyCon -> TcRn ()
    addUsedDataCons GlobalRdrEnv
    rdr_env TyCon
    tycon
      = [GlobalRdrElt] -> TcRn ()
    addUsedGREs [ GlobalRdrElt
    gre
                    | DataCon
    dc <- TyCon -> [DataCon]
    tyConDataCons TyCon
    tycon
                    , Just GlobalRdrElt
    gre <- [GlobalRdrEnv -> Name -> Maybe GlobalRdrElt
    lookupGRE_Name GlobalRdrEnv
    rdr_env (DataCon -> Name
    dataConName DataCon
    dc)] ]

    addUsedGRE :: Bool -> GlobalRdrElt -> RnM ()
    -- Called for both local and imported things
    -- Add usage *and* warn if deprecated
    addUsedGRE :: Bool -> GlobalRdrElt -> TcRn ()
    addUsedGRE Bool
    warn_if_deprec GlobalRdrElt
    gre
      = do { forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when Bool
    warn_if_deprec (GlobalRdrElt -> TcRn ()
    warnIfDeprecated GlobalRdrElt
    gre)
           ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (GlobalRdrElt -> Bool
    isLocalGRE GlobalRdrElt
    gre) forall a b. (a -> b) -> a -> b
    $
             do { TcGblEnv
    env <- forall gbl lcl. TcRnIf gbl lcl gbl
    getGblEnv
                ; String -> SDoc -> TcRn ()
    traceRn String
    "addUsedGRE" (forall a. Outputable a => a -> SDoc
    ppr GlobalRdrElt
    gre)
                ; forall a env. IORef a -> (a -> a) -> IOEnv env ()
    updMutVar (TcGblEnv -> TcRef [GlobalRdrElt]
    tcg_used_gres TcGblEnv
    env) (GlobalRdrElt
    gre forall a. a -> [a] -> [a]
    :) } }

    addUsedGREs :: [GlobalRdrElt] -> RnM ()
    -- Record uses of any *imported* GREs
    -- Used for recording used sub-bndrs
    -- NB: no call to warnIfDeprecated; see Note [Handling of deprecations]
    addUsedGREs :: [GlobalRdrElt] -> TcRn ()
    addUsedGREs [GlobalRdrElt]
    gres
      | forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [GlobalRdrElt]
    imp_gres = forall (m :: * -> *) a. Monad m => a -> m a
    return ()
      | Bool
    otherwise     = do { TcGblEnv
    env <- forall gbl lcl. TcRnIf gbl lcl gbl
    getGblEnv
                           ; String -> SDoc -> TcRn ()
    traceRn String
    "addUsedGREs" (forall a. Outputable a => a -> SDoc
    ppr [GlobalRdrElt]
    imp_gres)
                           ; forall a env. IORef a -> (a -> a) -> IOEnv env ()
    updMutVar (TcGblEnv -> TcRef [GlobalRdrElt]
    tcg_used_gres TcGblEnv
    env) ([GlobalRdrElt]
    imp_gres forall a. [a] -> [a] -> [a]
    ++) }
      where
        imp_gres :: [GlobalRdrElt]
    imp_gres = forall a. (a -> Bool) -> [a] -> [a]
    filterOut GlobalRdrElt -> Bool
    isLocalGRE [GlobalRdrElt]
    gres

    warnIfDeprecated :: GlobalRdrElt -> RnM ()
    warnIfDeprecated :: GlobalRdrElt -> TcRn ()
    warnIfDeprecated gre :: GlobalRdrElt
    gre@(GRE { gre_imp :: GlobalRdrElt -> [ImportSpec]
    gre_imp = [ImportSpec]
    iss })
      | (ImportSpec
    imp_spec : [ImportSpec]
    _) <- [ImportSpec]
    iss
      = do { DynFlags
    dflags <- forall (m :: * -> *). HasDynFlags m => m DynFlags
    getDynFlags
           ; Module
    this_mod <- forall (m :: * -> *). HasModule m => m Module
    getModule
           ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (WarningFlag -> DynFlags -> Bool
    wopt WarningFlag
    Opt_WarnWarningsDeprecations DynFlags
    dflags Bool -> Bool -> Bool
    &&
                   Bool -> Bool
    not (Module -> Name -> Bool
    nameIsLocalOrFrom Module
    this_mod Name
    name)) forall a b. (a -> b) -> a -> b
    $
                       -- See Note [Handling of deprecations]
             do { ModIface
    iface <- SDoc -> Name -> TcRn ModIface
    loadInterfaceForName SDoc
    doc Name
    name
                ; case ModIface -> GlobalRdrElt -> Maybe WarningTxt
    lookupImpDeprec ModIface
    iface GlobalRdrElt
    gre of
                    Just WarningTxt
    txt -> WarnReason -> SDoc -> TcRn ()
    addWarn (WarningFlag -> WarnReason
    Reason WarningFlag
    Opt_WarnWarningsDeprecations)
                                       (ImportSpec -> WarningTxt -> SDoc
    mk_msg ImportSpec
    imp_spec WarningTxt
    txt)
                    Maybe WarningTxt
    Nothing  -> forall (m :: * -> *) a. Monad m => a -> m a
    return () } }
      | Bool
    otherwise
      = forall (m :: * -> *) a. Monad m => a -> m a
    return ()
      where
        occ :: OccName
    occ = GlobalRdrElt -> OccName
    greOccName GlobalRdrElt
    gre
        name :: Name
    name = GlobalRdrElt -> Name
    greMangledName GlobalRdrElt
    gre
        name_mod :: Module
    name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
        doc :: SDoc
    doc = String -> SDoc
    text String
    "The name" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr OccName
    occ) SDoc -> SDoc -> SDoc
    <+> PtrString -> SDoc
    ptext (String -> PtrString
    sLit String
    "is mentioned explicitly")

        mk_msg :: ImportSpec -> WarningTxt -> SDoc
    mk_msg ImportSpec
    imp_spec WarningTxt
    txt
          = [SDoc] -> SDoc
    sep [ [SDoc] -> SDoc
    sep [ String -> SDoc
    text String
    "In the use of"
                        SDoc -> SDoc -> SDoc
    <+> NameSpace -> SDoc
    pprNonVarNameSpace (OccName -> NameSpace
    occNameSpace OccName
    occ)
                        SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr OccName
    occ)
                      , SDoc -> SDoc
    parens SDoc
    imp_msg SDoc -> SDoc -> SDoc
    <> SDoc
    colon ]
                , WarningTxt -> SDoc
    pprWarningTxtForMsg WarningTxt
    txt ]
          where
            imp_mod :: ModuleName
    imp_mod  = ImportSpec -> ModuleName
    importSpecModule ImportSpec
    imp_spec
            imp_msg :: SDoc
    imp_msg  = String -> SDoc
    text String
    "imported from" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr ModuleName
    imp_mod SDoc -> SDoc -> SDoc
    <> SDoc
    extra
            extra :: SDoc
    extra | ModuleName
    imp_mod forall a. Eq a => a -> a -> Bool
    == forall unit. GenModule unit -> ModuleName
    moduleName Module
    name_mod = SDoc
    Outputable.empty
                  | Bool
    otherwise = String -> SDoc
    text String
    ", but defined in" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr Module
    name_mod

    lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt
    lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt
    lookupImpDeprec ModIface
    iface GlobalRdrElt
    gre
      = ModIfaceBackend -> OccName -> Maybe WarningTxt
    mi_warn_fn (forall (phase :: ModIfacePhase).
    ModIface_ phase -> IfaceBackendExts phase
    mi_final_exts ModIface
    iface) (GlobalRdrElt -> OccName
    greOccName GlobalRdrElt
    gre) forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    `mplus`  -- Bleat if the thing,
        case GlobalRdrElt -> Parent
    gre_par GlobalRdrElt
    gre of                      -- or its parent, is warn'd
           ParentIs  Name
    p              -> ModIfaceBackend -> OccName -> Maybe WarningTxt
    mi_warn_fn (forall (phase :: ModIfacePhase).
    ModIface_ phase -> IfaceBackendExts phase
    mi_final_exts ModIface
    iface) (Name -> OccName
    nameOccName Name
    p)
           Parent
    NoParent                 -> forall a. Maybe a
    Nothing

    {-
    Note [Used names with interface not loaded]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    It's (just) possible to find a used
    Name whose interface hasn't been loaded:

    a) It might be a WiredInName; in that case we may not load
       its interface (although we could).

    b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
       These are seen as "used" by the renamer (if -XRebindableSyntax)
       is on), but the typechecker may discard their uses
       if in fact the in-scope fromRational is GHC.Read.fromRational,
       (see tcPat.tcOverloadedLit), and the typechecker sees that the type
       is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
       In that obscure case it won't force the interface in.

    In both cases we simply don't permit deprecations;
    this is, after all, wired-in stuff.

    *********************************************************
    *                                                      *
                    GHCi support
    *                                                      *
    *********************************************************

    A qualified name on the command line can refer to any module at
    all: we try to load the interface if we don't already have it, just
    as if there was an "import qualified M" declaration for every
    module.

    For example, writing `Data.List.sort` will load the interface file for
    `Data.List` as if the user had written `import qualified Data.List`.

    If we fail we just return Nothing, rather than bleating
    about "attempting to use module ‘D’ (./D.hs) which is not loaded"
    which is what loadSrcInterface does.

    It is enabled by default and disabled by the flag
    `-fno-implicit-import-qualified`.

    Note [Safe Haskell and GHCi]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    We DON'T do this Safe Haskell as we need to check imports. We can
    and should instead check the qualified import but at the moment
    this requires some refactoring so leave as a TODO

    Note [DuplicateRecordFields and -fimplicit-import-qualified]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When DuplicateRecordFields is used, a single module can export the same OccName
    multiple times, for example:

      module M where
        data S = MkS { foo :: Int }
        data T = MkT { foo :: Int }

    Now if we refer to M.foo via -fimplicit-import-qualified, we need to report an
    ambiguity error.

    -}

    -- | Like 'lookupQualifiedNameGHCi' but returning at most one name, reporting an
    -- ambiguity error if there are more than one.
    lookupOneQualifiedNameGHCi :: FieldsOrSelectors -> RdrName -> RnM (Maybe GreName)
    lookupOneQualifiedNameGHCi :: FieldsOrSelectors -> RdrName -> RnM (Maybe GreName)
    lookupOneQualifiedNameGHCi FieldsOrSelectors
    fos RdrName
    rdr_name = do
        [GreName]
    gnames <- FieldsOrSelectors -> RdrName -> RnM [GreName]
    lookupQualifiedNameGHCi FieldsOrSelectors
    fos RdrName
    rdr_name
        case [GreName]
    gnames of
          []              -> forall (m :: * -> *) a. Monad m => a -> m a
    return forall a. Maybe a
    Nothing
          [GreName
    gname]         -> forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a. a -> Maybe a
    Just GreName
    gname)
          (GreName
    gname:[GreName]
    gnames') -> do RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
    addNameClashErrRn RdrName
    rdr_name (GreName -> GlobalRdrElt
    toGRE GreName
    gname forall a. a -> [a] -> NonEmpty a
    NE.:| forall a b. (a -> b) -> [a] -> [b]
    map GreName -> GlobalRdrElt
    toGRE [GreName]
    gnames')
                                forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a. a -> Maybe a
    Just (Name -> GreName
    NormalGreName (RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name)))
      where
        -- Fake a GRE so we can report a sensible name clash error if
        -- -fimplicit-import-qualified is used with a module that exports the same
        -- field name multiple times (see
        -- Note [DuplicateRecordFields and -fimplicit-import-qualified]).
        toGRE :: GreName -> GlobalRdrElt
    toGRE GreName
    gname = GRE { gre_name :: GreName
    gre_name = GreName
    gname, gre_par :: Parent
    gre_par = Parent
    NoParent, gre_lcl :: Bool
    gre_lcl = Bool
    False, gre_imp :: [ImportSpec]
    gre_imp = [ImportSpec
    is] }
        is :: ImportSpec
    is = ImpSpec { is_decl :: ImpDeclSpec
    is_decl = ImpDeclSpec { is_mod :: ModuleName
    is_mod = ModuleName
    mod, is_as :: ModuleName
    is_as = ModuleName
    mod, is_qual :: Bool
    is_qual = Bool
    True, is_dloc :: SrcSpan
    is_dloc = SrcSpan
    noSrcSpan }
                     , is_item :: ImpItemSpec
    is_item = ImpItemSpec
    ImpAll }
        -- If -fimplicit-import-qualified succeeded, the name must be qualified.
        (ModuleName
    mod, OccName
    _) = forall a. a -> Maybe a -> a
    fromMaybe (forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "lookupOneQualifiedNameGHCi" (forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)) (RdrName -> Maybe (ModuleName, OccName)
    isQual_maybe RdrName
    rdr_name)

    -- | Look up *all* the names to which the 'RdrName' may refer in GHCi (using
    -- @-fimplicit-import-qualified@).  This will normally be zero or one, but may
    -- be more in the presence of @DuplicateRecordFields@.
    lookupQualifiedNameGHCi :: FieldsOrSelectors -> RdrName -> RnM [GreName]
    lookupQualifiedNameGHCi :: FieldsOrSelectors -> RdrName -> RnM [GreName]
    lookupQualifiedNameGHCi FieldsOrSelectors
    fos RdrName
    rdr_name
      = -- We want to behave as we would for a source file import here,
        -- and respect hiddenness of modules/packages, hence loadSrcInterface.
        do { DynFlags
    dflags  <- forall (m :: * -> *). HasDynFlags m => m DynFlags
    getDynFlags
           ; Bool
    is_ghci <- TcRn Bool
    getIsGHCi
           ; DynFlags -> Bool -> RnM [GreName]
    go_for_it DynFlags
    dflags Bool
    is_ghci }

      where
        go_for_it :: DynFlags -> Bool -> RnM [GreName]
    go_for_it DynFlags
    dflags Bool
    is_ghci
          | Just (ModuleName
    mod,OccName
    occ) <- RdrName -> Maybe (ModuleName, OccName)
    isQual_maybe RdrName
    rdr_name
          , Bool
    is_ghci
          , GeneralFlag -> DynFlags -> Bool
    gopt GeneralFlag
    Opt_ImplicitImportQualified DynFlags
    dflags   -- Enables this GHCi behaviour
          , Bool -> Bool
    not (DynFlags -> Bool
    safeDirectImpsReq DynFlags
    dflags)            -- See Note [Safe Haskell and GHCi]
          = do { MaybeErr SDoc ModIface
    res <- SDoc
    -> ModuleName
    -> IsBootInterface
    -> Maybe FastString
    -> RnM (MaybeErr SDoc ModIface)
    loadSrcInterface_maybe SDoc
    doc ModuleName
    mod IsBootInterface
    NotBoot forall a. Maybe a
    Nothing
               ; case MaybeErr SDoc ModIface
    res of
                    Succeeded ModIface
    iface
                      -> forall (m :: * -> *) a. Monad m => a -> m a
    return [ GreName
    gname
                                | AvailInfo
    avail <- forall (phase :: ModIfacePhase). ModIface_ phase -> [AvailInfo]
    mi_exports ModIface
    iface
                                , GreName
    gname <- AvailInfo -> [GreName]
    availGreNames AvailInfo
    avail
                                , forall name. HasOccName name => name -> OccName
    occName GreName
    gname forall a. Eq a => a -> a -> Bool
    == OccName
    occ
                                -- Include a field if it has a selector or we are looking for all fields;
                                -- see Note [NoFieldSelectors].
                                , FieldsOrSelectors -> GreName -> Bool
    allowGreName FieldsOrSelectors
    fos GreName
    gname
                                ]

                    MaybeErr SDoc ModIface
    _ -> -- Either we couldn't load the interface, or
                         -- we could but we didn't find the name in it
                         do { String -> SDoc -> TcRn ()
    traceRn String
    "lookupQualifiedNameGHCi" (forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)
                            ; forall (m :: * -> *) a. Monad m => a -> m a
    return [] } }

          | Bool
    otherwise
          = do { String -> SDoc -> TcRn ()
    traceRn String
    "lookupQualifiedNameGHCi: off" (forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)
               ; forall (m :: * -> *) a. Monad m => a -> m a
    return [] }

        doc :: SDoc
    doc = String -> SDoc
    text String
    "Need to find" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name

    {-
    Note [Looking up signature names]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    lookupSigOccRn is used for type signatures and pragmas
    Is this valid?
      module A
            import M( f )
            f :: Int -> Int
            f x = x
    It's clear that the 'f' in the signature must refer to A.f
    The Haskell98 report does not stipulate this, but it will!
    So we must treat the 'f' in the signature in the same way
    as the binding occurrence of 'f', using lookupBndrRn

    However, consider this case:
            import M( f )
            f :: Int -> Int
            g x = x
    We don't want to say 'f' is out of scope; instead, we want to
    return the imported 'f', so that later on the renamer will
    correctly report "misplaced type sig".

    Note [Signatures for top level things]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    data HsSigCtxt = ... | TopSigCtxt NameSet | ....

    * The NameSet says what is bound in this group of bindings.
      We can't use isLocalGRE from the GlobalRdrEnv, because of this:
           f x = x
           $( ...some TH splice... )
           f :: Int -> Int
      When we encounter the signature for 'f', the binding for 'f'
      will be in the GlobalRdrEnv, and will be a LocalDef. Yet the
      signature is mis-placed

    * For type signatures the NameSet should be the names bound by the
      value bindings; for fixity declarations, the NameSet should also
      include class sigs and record selectors

          infix 3 `f`          -- Yes, ok
          f :: C a => a -> a   -- No, not ok
          class C a where
            f :: a -> a
    -}

    data HsSigCtxt
      = TopSigCtxt NameSet       -- At top level, binding these names
                                 -- See Note [Signatures for top level things]
      | LocalBindCtxt NameSet    -- In a local binding, binding these names
      | ClsDeclCtxt   Name       -- Class decl for this class
      | InstDeclCtxt  NameSet    -- Instance decl whose user-written method
                                 -- bindings are for these methods
      | HsBootCtxt NameSet       -- Top level of a hs-boot file, binding these names
      | RoleAnnotCtxt NameSet    -- A role annotation, with the names of all types
                                 -- in the group

    instance Outputable HsSigCtxt where
        ppr :: HsSigCtxt -> SDoc
    ppr (TopSigCtxt NameSet
    ns) = String -> SDoc
    text String
    "TopSigCtxt" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr NameSet
    ns
        ppr (LocalBindCtxt NameSet
    ns) = String -> SDoc
    text String
    "LocalBindCtxt" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr NameSet
    ns
        ppr (ClsDeclCtxt Name
    n) = String -> SDoc
    text String
    "ClsDeclCtxt" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr Name
    n
        ppr (InstDeclCtxt NameSet
    ns) = String -> SDoc
    text String
    "InstDeclCtxt" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr NameSet
    ns
        ppr (HsBootCtxt NameSet
    ns) = String -> SDoc
    text String
    "HsBootCtxt" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr NameSet
    ns
        ppr (RoleAnnotCtxt NameSet
    ns) = String -> SDoc
    text String
    "RoleAnnotCtxt" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr NameSet
    ns

    lookupSigOccRn :: HsSigCtxt
                   -> Sig GhcPs
                   -> LocatedA RdrName -> RnM (LocatedA Name)
    lookupSigOccRn :: HsSigCtxt -> Sig GhcPs -> LocatedA RdrName -> RnM (LocatedA Name)
    lookupSigOccRn HsSigCtxt
    ctxt Sig GhcPs
    sig = HsSigCtxt -> SDoc -> LocatedA RdrName -> RnM (LocatedA Name)
    lookupSigCtxtOccRn HsSigCtxt
    ctxt (forall name. Sig name -> SDoc
    hsSigDoc Sig GhcPs
    sig)

    lookupSigOccRnN :: HsSigCtxt
                   -> Sig GhcPs
                   -> LocatedN RdrName -> RnM (LocatedN Name)
    lookupSigOccRnN :: HsSigCtxt -> Sig GhcPs -> LocatedN RdrName -> RnM (LocatedN Name)
    lookupSigOccRnN HsSigCtxt
    ctxt Sig GhcPs
    sig = HsSigCtxt -> SDoc -> LocatedN RdrName -> RnM (LocatedN Name)
    lookupSigCtxtOccRnN HsSigCtxt
    ctxt (forall name. Sig name -> SDoc
    hsSigDoc Sig GhcPs
    sig)

    -- | Lookup a name in relation to the names in a 'HsSigCtxt'
    lookupSigCtxtOccRnN :: HsSigCtxt
                        -> SDoc         -- ^ description of thing we're looking up,
                                       -- like "type family"
                        -> LocatedN RdrName -> RnM (LocatedN Name)
    lookupSigCtxtOccRnN :: HsSigCtxt -> SDoc -> LocatedN RdrName -> RnM (LocatedN Name)
    lookupSigCtxtOccRnN HsSigCtxt
    ctxt SDoc
    what
      = forall a b ann.
    (a -> TcM b)
    -> GenLocated (SrcSpanAnn' ann) a
    -> TcRn (GenLocated (SrcSpanAnn' ann) b)
    wrapLocMA forall a b. (a -> b) -> a -> b
    $ \ RdrName
    rdr_name ->
        do { Either SDoc Name
    mb_name <- HsSigCtxt -> SDoc -> RdrName -> RnM (Either SDoc Name)
    lookupBindGroupOcc HsSigCtxt
    ctxt SDoc
    what RdrName
    rdr_name
           ; case Either SDoc Name
    mb_name of
               Left SDoc
    err   -> do { SDoc -> TcRn ()
    addErr SDoc
    err; forall (m :: * -> *) a. Monad m => a -> m a
    return (RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name) }
               Right Name
    name -> forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name }

    -- | Lookup a name in relation to the names in a 'HsSigCtxt'
    lookupSigCtxtOccRn :: HsSigCtxt
                       -> SDoc         -- ^ description of thing we're looking up,
                                       -- like "type family"
                       -> LocatedA RdrName -> RnM (LocatedA Name)
    lookupSigCtxtOccRn :: HsSigCtxt -> SDoc -> LocatedA RdrName -> RnM (LocatedA Name)
    lookupSigCtxtOccRn HsSigCtxt
    ctxt SDoc
    what
      = forall a b ann.
    (a -> TcM b)
    -> GenLocated (SrcSpanAnn' ann) a
    -> TcRn (GenLocated (SrcSpanAnn' ann) b)
    wrapLocMA forall a b. (a -> b) -> a -> b
    $ \ RdrName
    rdr_name ->
        do { Either SDoc Name
    mb_name <- HsSigCtxt -> SDoc -> RdrName -> RnM (Either SDoc Name)
    lookupBindGroupOcc HsSigCtxt
    ctxt SDoc
    what RdrName
    rdr_name
           ; case Either SDoc Name
    mb_name of
               Left SDoc
    err   -> do { SDoc -> TcRn ()
    addErr SDoc
    err; forall (m :: * -> *) a. Monad m => a -> m a
    return (RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name) }
               Right Name
    name -> forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name }

    lookupBindGroupOcc :: HsSigCtxt
                       -> SDoc
                       -> RdrName -> RnM (Either SDoc Name)
    -- Looks up the RdrName, expecting it to resolve to one of the
    -- bound names passed in.  If not, return an appropriate error message
    --
    -- See Note [Looking up signature names]
    lookupBindGroupOcc :: HsSigCtxt -> SDoc -> RdrName -> RnM (Either SDoc Name)
    lookupBindGroupOcc HsSigCtxt
    ctxt SDoc
    what RdrName
    rdr_name
      | Just Name
    n <- RdrName -> Maybe Name
    isExact_maybe RdrName
    rdr_name
      = Name -> RnM (Either SDoc Name)
    lookupExactOcc_either Name
    n   -- allow for the possibility of missing Exacts;
                                  -- see Note [dataTcOccs and Exact Names]
          -- Maybe we should check the side conditions
          -- but it's a pain, and Exact things only show
          -- up when you know what you are doing

      | Just (Module
    rdr_mod, OccName
    rdr_occ) <- RdrName -> Maybe (Module, OccName)
    isOrig_maybe RdrName
    rdr_name
      = do { Name
    n' <- forall a b. Module -> OccName -> TcRnIf a b Name
    lookupOrig Module
    rdr_mod OccName
    rdr_occ
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right Name
    n') }

      | Bool
    otherwise
      = case HsSigCtxt
    ctxt of
          HsBootCtxt NameSet
    ns    -> (Name -> Bool) -> RnM (Either SDoc Name)
    lookup_top (Name -> NameSet -> Bool
    `elemNameSet` NameSet
    ns)
          TopSigCtxt NameSet
    ns    -> (Name -> Bool) -> RnM (Either SDoc Name)
    lookup_top (Name -> NameSet -> Bool
    `elemNameSet` NameSet
    ns)
          RoleAnnotCtxt NameSet
    ns -> (Name -> Bool) -> RnM (Either SDoc Name)
    lookup_top (Name -> NameSet -> Bool
    `elemNameSet` NameSet
    ns)
          LocalBindCtxt NameSet
    ns -> NameSet -> RnM (Either SDoc Name)
    lookup_group NameSet
    ns
          ClsDeclCtxt  Name
    cls -> Name -> RnM (Either SDoc Name)
    lookup_cls_op Name
    cls
          InstDeclCtxt NameSet
    ns  -> if forall a. (a -> Bool) -> UniqSet a -> Bool
    uniqSetAny Name -> Bool
    isUnboundName NameSet
    ns -- #16610
                              then forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right forall a b. (a -> b) -> a -> b
    $ RdrName -> Name
    mkUnboundNameRdr RdrName
    rdr_name)
                              else (Name -> Bool) -> RnM (Either SDoc Name)
    lookup_top (Name -> NameSet -> Bool
    `elemNameSet` NameSet
    ns)
      where
        lookup_cls_op :: Name -> RnM (Either SDoc Name)
    lookup_cls_op Name
    cls
          = Bool -> Name -> SDoc -> RdrName -> RnM (Either SDoc Name)
    lookupSubBndrOcc Bool
    True Name
    cls SDoc
    doc RdrName
    rdr_name
          where
            doc :: SDoc
    doc = String -> SDoc
    text String
    "method of class" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr Name
    cls)

        lookup_top :: (Name -> Bool) -> RnM (Either SDoc Name)
    lookup_top Name -> Bool
    keep_me
          = do { GlobalRdrEnv
    env <- TcRn GlobalRdrEnv
    getGlobalRdrEnv
               ; let all_gres :: [GlobalRdrElt]
    all_gres = GlobalRdrEnv -> OccName -> [GlobalRdrElt]
    lookupGlobalRdrEnv GlobalRdrEnv
    env (RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name)
                     names_in_scope :: [Name]
    names_in_scope = -- If rdr_name lacks a binding, only
                                      -- recommend alternatives from related
                                      -- namespaces. See #17593.
                                      forall a. (a -> Bool) -> [a] -> [a]
    filter (\Name
    n -> NameSpace -> NameSpace -> Bool
    nameSpacesRelated
                                                      (RdrName -> NameSpace
    rdrNameSpace RdrName
    rdr_name)
                                                      (Name -> NameSpace
    nameNameSpace Name
    n))
                                    forall a b. (a -> b) -> a -> b
    $ forall a b. (a -> b) -> [a] -> [b]
    map GlobalRdrElt -> Name
    greMangledName
                                    forall a b. (a -> b) -> a -> b
    $ forall a. (a -> Bool) -> [a] -> [a]
    filter GlobalRdrElt -> Bool
    isLocalGRE
                                    forall a b. (a -> b) -> a -> b
    $ GlobalRdrEnv -> [GlobalRdrElt]
    globalRdrEnvElts GlobalRdrEnv
    env
                     candidates_msg :: SDoc
    candidates_msg = [Name] -> SDoc
    candidates [Name]
    names_in_scope
               ; case forall a. (a -> Bool) -> [a] -> [a]
    filter (Name -> Bool
    keep_me forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GlobalRdrElt -> Name
    greMangledName) [GlobalRdrElt]
    all_gres of
                   [] | forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [GlobalRdrElt]
    all_gres -> SDoc -> RnM (Either SDoc Name)
    bale_out_with SDoc
    candidates_msg
                      | Bool
    otherwise     -> SDoc -> RnM (Either SDoc Name)
    bale_out_with SDoc
    local_msg
                   (GlobalRdrElt
    gre:[GlobalRdrElt]
    _)            -> forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right (GlobalRdrElt -> Name
    greMangledName GlobalRdrElt
    gre)) }

        lookup_group :: NameSet -> RnM (Either SDoc Name)
    lookup_group NameSet
    bound_names  -- Look in the local envt (not top level)
          = do { Maybe Name
    mname <- RdrName -> RnM (Maybe Name)
    lookupLocalOccRn_maybe RdrName
    rdr_name
               ; LocalRdrEnv
    env <- RnM LocalRdrEnv
    getLocalRdrEnv
               ; let candidates_msg :: SDoc
    candidates_msg = [Name] -> SDoc
    candidates forall a b. (a -> b) -> a -> b
    $ LocalRdrEnv -> [Name]
    localRdrEnvElts LocalRdrEnv
    env
               ; case Maybe Name
    mname of
                   Just Name
    n
                     | Name
    n Name -> NameSet -> Bool
    `elemNameSet` NameSet
    bound_names -> forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. b -> Either a b
    Right Name
    n)
                     | Bool
    otherwise                   -> SDoc -> RnM (Either SDoc Name)
    bale_out_with SDoc
    local_msg
                   Maybe Name
    Nothing                         -> SDoc -> RnM (Either SDoc Name)
    bale_out_with SDoc
    candidates_msg }

        bale_out_with :: SDoc -> RnM (Either SDoc Name)
    bale_out_with SDoc
    msg
            = forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. a -> Either a b
    Left ([SDoc] -> SDoc
    sep [ String -> SDoc
    text String
    "The" SDoc -> SDoc -> SDoc
    <+> SDoc
    what
                                    SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "for" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name)
                               , Arity -> SDoc -> SDoc
    nest Arity
    2 forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "lacks an accompanying binding"]
                           SDoc -> SDoc -> SDoc
    $$ Arity -> SDoc -> SDoc
    nest Arity
    2 SDoc
    msg))

        local_msg :: SDoc
    local_msg = SDoc -> SDoc
    parens forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "The"  SDoc -> SDoc -> SDoc
    <+> SDoc
    what SDoc -> SDoc -> SDoc
    <+> PtrString -> SDoc
    ptext (String -> PtrString
    sLit String
    "must be given where")
                               SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr_name) SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "is declared"

        -- Identify all similar names and produce a message listing them
        candidates :: [Name] -> SDoc
        candidates :: [Name] -> SDoc
    candidates [Name]
    names_in_scope
          = case [Name]
    similar_names of
              []  -> SDoc
    Outputable.empty
              [Name
    n] -> String -> SDoc
    text String
    "Perhaps you meant" SDoc -> SDoc -> SDoc
    <+> Name -> SDoc
    pp_item Name
    n
              [Name]
    _   -> [SDoc] -> SDoc
    sep [ String -> SDoc
    text String
    "Perhaps you meant one of these:"
                         , Arity -> SDoc -> SDoc
    nest Arity
    2 (forall a. (a -> SDoc) -> [a] -> SDoc
    pprWithCommas Name -> SDoc
    pp_item [Name]
    similar_names) ]
          where
            similar_names :: [Name]
    similar_names
              = forall a. String -> [(String, a)] -> [a]
    fuzzyLookup (FastString -> String
    unpackFS forall a b. (a -> b) -> a -> b
    $ OccName -> FastString
    occNameFS forall a b. (a -> b) -> a -> b
    $ RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name)
                            forall a b. (a -> b) -> a -> b
    $ forall a b. (a -> b) -> [a] -> [b]
    map (\Name
    x -> ((FastString -> String
    unpackFS forall a b. (a -> b) -> a -> b
    $ OccName -> FastString
    occNameFS forall a b. (a -> b) -> a -> b
    $ Name -> OccName
    nameOccName Name
    x), Name
    x))
                                  [Name]
    names_in_scope

            pp_item :: Name -> SDoc
    pp_item Name
    x = SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr Name
    x) SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    parens (Name -> SDoc
    pprDefinedAt Name
    x)

    ---------------
    lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [(RdrName, Name)]
    -- GHC extension: look up both the tycon and data con or variable.
    -- Used for top-level fixity signatures and deprecations.
    -- Complain if neither is in scope.
    -- See Note [Fixity signature lookup]
    lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [(RdrName, Name)]
    lookupLocalTcNames HsSigCtxt
    ctxt SDoc
    what RdrName
    rdr_name
      = do { [Either SDoc (RdrName, Name)]
    mb_gres <- forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (Either SDoc (RdrName, Name))
    lookup (RdrName -> [RdrName]
    dataTcOccs RdrName
    rdr_name)
           ; let ([SDoc]
    errs, [(RdrName, Name)]
    names) = forall a b. [Either a b] -> ([a], [b])
    partitionEithers [Either SDoc (RdrName, Name)]
    mb_gres
           ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [(RdrName, Name)]
    names) forall a b. (a -> b) -> a -> b
    $ SDoc -> TcRn ()
    addErr (forall a. [a] -> a
    head [SDoc]
    errs) -- Bleat about one only
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return [(RdrName, Name)]
    names }
      where
        lookup :: RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (Either SDoc (RdrName, Name))
    lookup RdrName
    rdr = do { Module
    this_mod <- forall (m :: * -> *). HasModule m => m Module
    getModule
                        ; Either SDoc Name
    nameEither <- HsSigCtxt -> SDoc -> RdrName -> RnM (Either SDoc Name)
    lookupBindGroupOcc HsSigCtxt
    ctxt SDoc
    what RdrName
    rdr
                        ; forall (m :: * -> *) a. Monad m => a -> m a
    return (Module
    -> RdrName -> Either SDoc Name -> Either SDoc (RdrName, Name)
    guard_builtin_syntax Module
    this_mod RdrName
    rdr Either SDoc Name
    nameEither) }

        -- Guard against the built-in syntax (ex: `infixl 6 :`), see #15233
        guard_builtin_syntax :: Module
    -> RdrName -> Either SDoc Name -> Either SDoc (RdrName, Name)
    guard_builtin_syntax Module
    this_mod RdrName
    rdr (Right Name
    name)
          | Just Name
    _ <- OccName -> Maybe Name
    isBuiltInOcc_maybe (forall name. HasOccName name => name -> OccName
    occName RdrName
    rdr)
          , Module
    this_mod forall a. Eq a => a -> a -> Bool
    /= HasDebugCallStack => Name -> Module
    nameModule Name
    name
          = forall a b. a -> Either a b
    Left ([SDoc] -> SDoc
    hsep [String -> SDoc
    text String
    "Illegal", SDoc
    what, String -> SDoc
    text String
    "of built-in syntax:", forall a. Outputable a => a -> SDoc
    ppr RdrName
    rdr])
          | Bool
    otherwise
          = forall a b. b -> Either a b
    Right (RdrName
    rdr, Name
    name)
        guard_builtin_syntax Module
    _ RdrName
    _ (Left SDoc
    err) = forall a b. a -> Either a b
    Left SDoc
    err

    dataTcOccs :: RdrName -> [RdrName]
    -- Return both the given name and the same name promoted to the TcClsName
    -- namespace.  This is useful when we aren't sure which we are looking at.
    -- See also Note [dataTcOccs and Exact Names]
    dataTcOccs :: RdrName -> [RdrName]
    dataTcOccs RdrName
    rdr_name
      | OccName -> Bool
    isDataOcc OccName
    occ Bool -> Bool -> Bool
    || OccName -> Bool
    isVarOcc OccName
    occ
      = [RdrName
    rdr_name, RdrName
    rdr_name_tc]
      | Bool
    otherwise
      = [RdrName
    rdr_name]
      where
        occ :: OccName
    occ = RdrName -> OccName
    rdrNameOcc RdrName
    rdr_name
        rdr_name_tc :: RdrName
    rdr_name_tc =
          case RdrName
    rdr_name of
            -- The (~) type operator is always in scope, so we need a special case
            -- for it here, or else  :info (~)  fails in GHCi.
            -- See Note [eqTyCon (~) is built-in syntax]
            Unqual OccName
    occ | OccName -> FastString
    occNameFS OccName
    occ forall a. Eq a => a -> a -> Bool
    == String -> FastString
    fsLit String
    "~" -> RdrName
    eqTyCon_RDR
            RdrName
    _ -> RdrName -> NameSpace -> RdrName
    setRdrNameSpace RdrName
    rdr_name NameSpace
    tcName

    {-
    Note [dataTcOccs and Exact Names]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Exact RdrNames can occur in code generated by Template Haskell, and generally
    those references are, well, exact. However, the TH `Name` type isn't expressive
    enough to always track the correct namespace information, so we sometimes get
    the right Unique but wrong namespace. Thus, we still have to do the double-lookup
    for Exact RdrNames.

    There is also an awkward situation for built-in syntax. Example in GHCi
       :info []
    This parses as the Exact RdrName for nilDataCon, but we also want
    the list type constructor.

    Note that setRdrNameSpace on an Exact name requires the Name to be External,
    which it always is for built in syntax.
    -}

    {-
    ************************************************************************
    *                                                                      *
                            Rebindable names
            Dealing with rebindable syntax is driven by the
            Opt_RebindableSyntax dynamic flag.

            In "deriving" code we don't want to use rebindable syntax
            so we switch off the flag locally

    *                                                                      *
    ************************************************************************

    Haskell 98 says that when you say "3" you get the "fromInteger" from the
    Standard Prelude, regardless of what is in scope.   However, to experiment
    with having a language that is less coupled to the standard prelude, we're
    trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
    happens to be in scope.  Then you can
            import Prelude ()
            import MyPrelude as Prelude
    to get the desired effect.

    At the moment this just happens for
      * fromInteger, fromRational on literals (in expressions and patterns)
      * negate (in expressions)
      * minus  (arising from n+k patterns)
      * "do" notation

    We store the relevant Name in the HsSyn tree, in
      * HsIntegral/HsFractional/HsIsString
      * NegApp
      * NPlusKPat
      * HsDo
    respectively.  Initially, we just store the "standard" name (GHC.Builtin.Names.fromIntegralName,
    fromRationalName etc), but the renamer changes this to the appropriate user
    name if Opt_NoImplicitPrelude is on.  That is what lookupSyntax does.

    We treat the original (standard) names as free-vars too, because the type checker
    checks the type of the user thing against the type of the standard thing.
    -}

    lookupIfThenElse :: RnM (Maybe Name)
    -- Looks up "ifThenElse" if rebindable syntax is on
    lookupIfThenElse :: RnM (Maybe Name)
    lookupIfThenElse
      = do { Bool
    rebindable_on <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.RebindableSyntax
           ; if Bool -> Bool
    not Bool
    rebindable_on
             then forall (m :: * -> *) a. Monad m => a -> m a
    return forall a. Maybe a
    Nothing
             else do { Name
    ite <- RdrName -> RnM Name
    lookupOccRn (FastString -> RdrName
    mkVarUnqual (String -> FastString
    fsLit String
    "ifThenElse"))
                     ; forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a. a -> Maybe a
    Just Name
    ite) } }

    lookupSyntaxName :: Name                 -- ^ The standard name
                     -> RnM (Name, FreeVars) -- ^ Possibly a non-standard name
    -- Lookup a Name that may be subject to Rebindable Syntax (RS).
    --
    -- - When RS is off, just return the supplied (standard) Name
    --
    -- - When RS is on, look up the OccName of the supplied Name; return
    --   what we find, or the supplied Name if there is nothing in scope
    lookupSyntaxName :: Name -> RnM (Name, NameSet)
    lookupSyntaxName Name
    std_name
      = do { Bool
    rebind <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.RebindableSyntax
           ; if Bool -> Bool
    not Bool
    rebind
             then forall (m :: * -> *) a. Monad m => a -> m a
    return (Name
    std_name, NameSet
    emptyFVs)
             else do { Name
    nm <- RdrName -> RnM Name
    lookupOccRn (OccName -> RdrName
    mkRdrUnqual (Name -> OccName
    nameOccName Name
    std_name))
                     ; forall (m :: * -> *) a. Monad m => a -> m a
    return (Name
    nm, Name -> NameSet
    unitFV Name
    nm) } }

    lookupSyntaxExpr :: Name                          -- ^ The standard name
                     -> RnM (HsExpr GhcRn, FreeVars)  -- ^ Possibly a non-standard name
    lookupSyntaxExpr :: Name -> RnM (HsExpr GhcRn, NameSet)
    lookupSyntaxExpr Name
    std_name
      = do { (Name
    name, NameSet
    fvs) <- Name -> RnM (Name, NameSet)
    lookupSyntaxName Name
    std_name
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return (forall (p :: Pass) a.
    IsSrcSpanAnn p a =>
    IdP (GhcPass p) -> HsExpr (GhcPass p)
    nl_HsVar Name
    name, NameSet
    fvs) }

    lookupSyntax :: Name                             -- The standard name
                 -> RnM (SyntaxExpr GhcRn, FreeVars) -- Possibly a non-standard
                                                     -- name
    lookupSyntax :: Name -> RnM (SyntaxExpr GhcRn, NameSet)
    lookupSyntax Name
    std_name
      = do { (HsExpr GhcRn
    expr, NameSet
    fvs) <- Name -> RnM (HsExpr GhcRn, NameSet)
    lookupSyntaxExpr Name
    std_name
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return (HsExpr GhcRn -> SyntaxExprRn
    mkSyntaxExpr HsExpr GhcRn
    expr, NameSet
    fvs) }

    lookupSyntaxNames :: [Name]                         -- Standard names
         -> RnM ([HsExpr GhcRn], FreeVars) -- See comments with HsExpr.ReboundNames
       -- this works with CmdTop, which wants HsExprs, not SyntaxExprs
    lookupSyntaxNames :: [Name] -> RnM ([HsExpr GhcRn], NameSet)
    lookupSyntaxNames [Name]
    std_names
      = do { Bool
    rebindable_on <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.RebindableSyntax
           ; if Bool -> Bool
    not Bool
    rebindable_on then
                 forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. (a -> b) -> [a] -> [b]
    map (forall p. XVar p -> LIdP p -> HsExpr p
    HsVar NoExtField
    noExtField forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a an. a -> LocatedAn an a
    noLocA) [Name]
    std_names, NameSet
    emptyFVs)
            else
              do { [Name]
    usr_names <- forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (RdrName -> RnM Name
    lookupOccRn forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OccName -> RdrName
    mkRdrUnqual forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> OccName
    nameOccName) [Name]
    std_names
                 ; forall (m :: * -> *) a. Monad m => a -> m a
    return (forall a b. (a -> b) -> [a] -> [b]
    map (forall p. XVar p -> LIdP p -> HsExpr p
    HsVar NoExtField
    noExtField forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a an. a -> LocatedAn an a
    noLocA) [Name]
    usr_names, [Name] -> NameSet
    mkFVs [Name]
    usr_names) } }

    {-
    Note [QualifiedDo]
    ~~~~~~~~~~~~~~~~~~
    QualifiedDo is implemented using the same placeholders for operation names in
    the AST that were devised for RebindableSyntax. Whenever the renamer checks
    which names to use for do syntax, it first checks if the do block is qualified
    (e.g. M.do { stmts }), in which case it searches for qualified names. If the
    qualified names are not in scope, an error is produced. If the do block is not
    qualified, the renamer does the usual search of the names which considers
    whether RebindableSyntax is enabled or not. Dealing with QualifiedDo is driven
    by the Opt_QualifiedDo dynamic flag.
    -}

    -- Lookup operations for a qualified do. If the context is not a qualified
    -- do, then use lookupSyntaxExpr. See Note [QualifiedDo].
    lookupQualifiedDoExpr :: HsStmtContext p -> Name -> RnM (HsExpr GhcRn, FreeVars)
    lookupQualifiedDoExpr :: forall p. HsStmtContext p -> Name -> RnM (HsExpr GhcRn, NameSet)
    lookupQualifiedDoExpr HsStmtContext p
    ctxt Name
    std_name
      = forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first forall (p :: Pass) a.
    IsSrcSpanAnn p a =>
    IdP (GhcPass p) -> HsExpr (GhcPass p)
    nl_HsVar forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> forall p. HsStmtContext p -> Name -> RnM (Name, NameSet)
    lookupQualifiedDoName HsStmtContext p
    ctxt Name
    std_name

    -- Like lookupQualifiedDoExpr but for producing SyntaxExpr.
    -- See Note [QualifiedDo].
    lookupQualifiedDo
      :: HsStmtContext p
      -> Name
      -> RnM (SyntaxExpr GhcRn, FreeVars)
    lookupQualifiedDo :: forall p.
    HsStmtContext p -> Name -> RnM (SyntaxExpr GhcRn, NameSet)
    lookupQualifiedDo HsStmtContext p
    ctxt Name
    std_name
      = forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first HsExpr GhcRn -> SyntaxExprRn
    mkSyntaxExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> forall p. HsStmtContext p -> Name -> RnM (HsExpr GhcRn, NameSet)
    lookupQualifiedDoExpr HsStmtContext p
    ctxt Name
    std_name

    lookupNameWithQualifier :: Name -> ModuleName -> RnM (Name, FreeVars)
    lookupNameWithQualifier :: Name -> ModuleName -> RnM (Name, NameSet)
    lookupNameWithQualifier Name
    std_name ModuleName
    modName
      = do { Name
    qname <- RdrName -> RnM Name
    lookupOccRn (ModuleName -> OccName -> RdrName
    mkRdrQual ModuleName
    modName (Name -> OccName
    nameOccName Name
    std_name))
           ; forall (m :: * -> *) a. Monad m => a -> m a
    return (Name
    qname, Name -> NameSet
    unitFV Name
    qname) }

    -- See Note [QualifiedDo].
    lookupQualifiedDoName
      :: HsStmtContext p
      -> Name
      -> RnM (Name, FreeVars)
    lookupQualifiedDoName :: forall p. HsStmtContext p -> Name -> RnM (Name, NameSet)
    lookupQualifiedDoName HsStmtContext p
    ctxt Name
    std_name
      = case forall p. HsStmtContext p -> Maybe ModuleName
    qualifiedDoModuleName_maybe HsStmtContext p
    ctxt of
          Maybe ModuleName
    Nothing -> Name -> RnM (Name, NameSet)
    lookupSyntaxName Name
    std_name
          Just ModuleName
    modName -> Name -> ModuleName -> RnM (Name, NameSet)
    lookupNameWithQualifier Name
    std_name ModuleName
    modName

    -- Error messages

    opDeclErr :: RdrName -> SDoc
    opDeclErr :: RdrName -> SDoc
    opDeclErr RdrName
    n
      = SDoc -> Arity -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Illegal declaration of a type or class operator" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    n))
           Arity
    2 (String -> SDoc
    text String
    "Use TypeOperators to declare operators in type and declarations")

    badOrigBinding :: RdrName -> SDoc
    badOrigBinding :: RdrName -> SDoc
    badOrigBinding RdrName
    name
      | Just Name
    _ <- OccName -> Maybe Name
    isBuiltInOcc_maybe OccName
    occ
      = String -> SDoc
    text String
    "Illegal binding of built-in syntax:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr OccName
    occ
        -- Use an OccName here because we don't want to print Prelude.(,)
      | Bool
    otherwise
      = String -> SDoc
    text String
    "Cannot redefine a Name retrieved by a Template Haskell quote:"
        SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr RdrName
    name
        -- This can happen when one tries to use a Template Haskell splice to
        -- define a top-level identifier with an already existing name, e.g.,
        --
        --   $(pure [ValD (VarP 'succ) (NormalB (ConE 'True)) []])
        --
        -- (See #13968.)
      where
        occ :: OccName
    occ = RdrName -> OccName
    rdrNameOcc forall a b. (a -> b) -> a -> b
    $ RdrName -> RdrName
    filterCTuple RdrName
    name