lookupLocatedTopBndrRnN, lookupTopBndrRn,

         lookupLocatedOccRnNone,

         lookupLocalOccRn_maybe, lookupInfoOccRn,

         lookupLocalOccThLvl_maybe, lookupLocalOccRn,

         lookupTypeOccRn,

                    -> TcRn (GenLocated (EpAnn ann) Name)

 lookupLocatedOccRn what = wrapLocMA (lookupOccRn what)

 lookupLocatedOccRnConstr :: GenLocated (EpAnn ann) RdrName

                          -> TcRn (GenLocated (EpAnn ann) Name)

 lookupLocatedOccRnConstr = wrapLocMA lookupOccRnConstr

 -- | lookupOccRn looks up an occurrence of a RdrName, and uses its argument to

 -- determine what kind of suggestions should be displayed if it is not in scope

 lookupOccRn :: WhatLooking -> RdrName -> RnM Name

   = do { mb_gre <- lookupOccRn_maybe rdr_name

        ; case mb_gre of

 -- | Look up an occurrence of a 'RdrName'.

 --

 -- lookupTypeOccRn looks up an optionally promoted RdrName.

 -- Used for looking up type variables.

 -- see Note [Demotion]

 lookupTypeOccRn rdr_name

   = do { mb_gre <- lookupOccRn_maybe rdr_name

        ; case mb_gre of

              Nothing   ->

                if occName rdr_name == occName eqTyCon_RDR -- See Note [eqTyCon (~) compatibility fallback]

 {- Note [eqTyCon (~) compatibility fallback]

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

 {-# LANGUAGE CPP                 #-}

 {-# LANGUAGE MonadComprehensions #-}

 {-# LANGUAGE MultiWayIf          #-}

 {-# LANGUAGE TypeFamilies        #-}

 {-# LANGUAGE ViewPatterns        #-}

             -- matching GRE and add a name clash error

             -- (see lookupGlobalOccRn_overloaded, called by lookupExprOccRn).

             -> do { let sel_name = flSelector $ recFieldLabel fld_info

                   ; return (XExpr (HsRecSelRn (FieldOcc v  (L l sel_name))), unitFN sel_name)

                   }

             | nm == nilDataConName

             -> rnExpr (ExplicitList noAnn [])

             | otherwise

                   ; return (res_expr, unitFN nm) }

         }}}

          TcRnUnexpectedKindVar rdr_name

            -- Any type variable at the kind level is illegal without the use

            -- of PolyKinds (see #14710)

        ; this_mod <- getModule

        ; explicit_level_imports <- xoptM LangExt.ExplicitLevelImports

        ; if  | explicit_level_imports

              -- See Note [Strict level checks with ExplicitLevelImports]

              | nameIsLocalOrFrom this_mod name

              | otherwise -> pure ()

 rnHsTyKi env ty@(HsOpTy _ ty1 tyop ty2)

   = setSrcSpan (getLocA tyop) $

 -}

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

 rnTyVar env rdr_name

 -- Called externally; does not deal with wildcards

 rnLTyVar (L loc rdr_name)

   = do { tyvar <- lookupTypeOccRn rdr_name

          -> RnM (LHsType GhcRn, FreeNames)

 rnHsTyOp env overall_ty tyop

   | L l (HsTyVar ann prom (L loc op)) <- tyop

        ; unlessXOptM LangExt.TypeOperators $

            then addDiagnostic TcRnTypeEqualityRequiresOperators

            else addErr $ TcRnIllegalTypeOperator (ppr overall_ty) op

   | otherwise

   = rnLHsTyKi env tyop

              bindLocalNames (maybeToList (hsLTyVarName resTv)) $

              -- The return type variable scopes over the injectivity annotation

              -- e.g.   type family F a = (r::*) | r -> a

                 -- Note: srcSpan is unchanged, but typechecker gets

                 -- confused, l2l call makes it happy

                 ; return $ L (l2l srcSpan) (InjectivityAnn x injFrom' injTo') }

    (injDecl', _) <- askNoErrs $ do

      injFrom' <- rnLTyVar injFrom

      injTo'   <- mapM rnLTyVar injTo

    return $ injDecl'

 {-

 lookupTypeOccTPRnM :: RdrName -> TPRnM Name

 lookupTypeOccTPRnM rdr_name = liftRnFV $ do

   pure (name, unitFN name)

 rn_lty_pat :: LHsType GhcPs -> TPRnM (LHsType GhcRn)

 {-# LANGUAGE TypeFamilies #-}

 module GHC.Rename.Splice (

         rnTopSpliceDecls,

 import GHC.Types.SrcLoc

 import GHC.Rename.HsType ( rnLHsType )

 import {-# SOURCE #-} GHC.Rename.Expr ( rnLExpr )

 rn_utbracket :: HsQuote GhcPs -> RnM (HsQuote GhcRn, FreeNames)

 rn_utbracket (VarBr _ is_value_name rdr_name)

 rn_utbracket (ExpBr _ e) = do { (e', fvs) <- rnLExpr e

                                 ; return (ExpBr noExtField e', fvs) }

 rnUntypedSplice (HsQuasiQuote _ quoter quote) flavour

   = do  { -- Rename the quoter; akin to the HsVar case of rnExpr

         ; checkThLocalNameNoLift res_name

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

 rnTypedSplice :: HsTypedSplice GhcPs -- Typed splice expression

       = vcat [ text "--" <+> ppr loc <> colon <+> text "Splicing" <+> text sd

              , gen ]

   | isUnboundName name   -- Do not report two errors for

   = return ()            --   $(not_in_scope args)

   | otherwise

   = do  { traceRn "checkThLocalTyName" (ppr name)

         ; case mb_local_use of {

              Nothing -> return () ;  -- Not a locally-bound thing

              Just (top_lvl, bind_lvl, use_lvl) ->

                                                  <+> ppr use_lvl)

         ; dflags <- getDynFlags

         ; checkCrossLevelLiftingTy dflags top_lvl bind_lvl use_lvl name } } }

 -- | Check whether we are allowed to use a Name in this context (for TH purposes)

 -- In the case of a level incorrect program, attempt to fix it by using

 -- a Lift constraint.

 checkThLocalNameWithLift = checkThLocalName True

 -- | Check whether we are allowed to use a Name in this context (for TH purposes)

 -- In the case of a level incorrect program, do not attempt to fix it by using

 -- a Lift constraint.

 -- | Implementation of the level checks

 -- See Note [Template Haskell levels]

   -- Exact and Orig names are not imported, so presumed available at all levels.

   -- whenever the user uses exact names, e.g. say @'mkNameG_v' "" "Foo" "bar"@,

   -- even though the 'mkNameG_v' here is essentially a quotation, we do not do

   -- level checks as we assume that the user was trying to bypass the level checks

   = return (HsVar noExtField name_var)

   | isUnboundName name                  -- Do not report two errors for

   = return (HsVar noExtField name_var)  --   $(not_in_scope args)

   = return (HsVar noExtField name_var)

   | otherwise

   = do  {

         ; case mb_local_use of {

              Nothing -> return (HsVar noExtField name_var) ;  -- Not a locally-bound thing

              Just (top_lvl, bind_lvl, use_lvl) ->

         ; let is_local

                   | Just mod <- nameModule_maybe name = mod == cur_mod

                   | otherwise = True

         ; dflags <- getDynFlags

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

 checkCrossLevelLifting :: DynFlags

   , any (\bind_idx -> use_lvl_idx == incThLevelIndex bind_idx) (Set.toList bind_lvl)

   , allow_lifting

   = do

        (splice_name :: Name) <- newLocalBndrRn (noLocA unqualSplice)

        let  pend_splice :: HsImplicitLiftSplice

             pend_splice = HsImplicitLiftSplice bind_lvl use_lvl_idx mgre name_var

 import GHC.Hs

 import GHC.Tc.Utils.Monad

 import GHC.Types.Name.Set

 rnTopSpliceDecls :: HsUntypedSplice GhcPs -> RnM ([LHsDecl GhcPs], FreeNames)

     mkImplicitLiftingError :: ErrorItem -> TcRnMessage

     mkImplicitLiftingError item =

       case errorItemOrigin item of

         _ -> pprPanic "mkImplicitLiftingError" (ppr item)

 mkGivenErrorReporter :: Reporter

           (text "No instance for:" <+> quotes (ppr (errorItemPred item)))

          | Just item <- [lift_attempt]

          ] ++

          , not (isEmptyBag (gre_imp gre)) ]

   where

 note :: SDoc -> SDoc

 note note = "Note" <> colon <+> note <> dot

 pprLevelCheckReason = \case

   LevelCheckInstance _ t ->

     text "instance for" <+> quotes (ppr t)

 pprUninferrableTyVarCtx :: UninferrableTyVarCtx -> SDoc

 pprUninferrableTyVarCtx = \case

 data LevelCheckReason

   = LevelCheckInstance !InstanceWhat !PredType

 data UninferrableTyVarCtx

   = UninfTyCtx_ClassContext [TcType]

                let avail = availFromGRE gre

                    name = greName gre

                occs' <- check_occs occs ie [gre]

                (export_warn_spans', dont_warn_export', warn_txt_rn)

                  <- process_warning export_warn_spans

                     occs' <- check_occs occs ie [gre]

                     return (Just avail, occs', exp_dflts)

                (export_warn_spans', dont_warn_export', warn_txt_rn)

                  <- process_warning export_warn_spans

                                     dont_warn_export

                    all_gres = par : all_kids

                    all_names = map greName all_gres

                occs' <- check_occs occs ie all_gres

                (export_warn_spans', dont_warn_export', warn_txt_rn)

                  <- process_warning export_warn_spans

                    all_gres = par : all_kids

                    all_names = map greName all_gres

                occs' <- check_occs occs ie all_gres

                (export_warn_spans', dont_warn_export', warn_txt_rn)

                  <- process_warning export_warn_spans

       = addUsedGREs ExportDeprecationWarnings (pickGREs parent_rdr kid_gres)

 -- | In what namespaces should we go looking for an import/export item

 -- that is out of scope, for suggestions in error messages?

                  ; return (replaceLWrappedName n ub, gre)}

             FoundChild child@(GRE { gre_name = child_nm, gre_par = par }) ->

               do { checkPatSynParent spec_parent par child_nm

                  ; return (replaceLWrappedName n child_nm, child)

                  }

             IncorrectParent p c gs -> failWithDcErr (parentGRE_name p) (greName c) gs

           env <- getGblEnv

         ; case lookupNameEnv (tcg_type_env env) name of {

                 Just thing -> return thing ;

                 -- Should it have been in the local envt?

                 -- (NB: use semantic mod here, since names never use

                 -- identity module, see Note [Identity versus semantic module].)

            -- Try home package table and external package table

     do  { mb_thing <- tcLookupImported_maybe name

         ; case mb_thing of

 pprBinders [bndr] = quotes (ppr bndr)

 pprBinders bndrs  = pprWithCommas ppr bndrs

   = do { lcl_env <- getLclEnv

        ; if    -- See Note [Out of scope might be a staging error]

            | isUnboundName name -> failM  -- If the name really isn't in scope

                                           -- don't report it again (#11941)

                                           -- function, we check this completely independently

                                           -- before scrutinizing lvls

            | Just (_top_lvl_flag, bind_lvls, lvl@Splice {}) <- lvls

            | otherwise  -> pure ()

        ; if isTermVarOrFieldNameSpace (nameNameSpace name)

                   -- so let's just not print it!  Getting a loop here is

                   -- very unhelpful, because it hides one compiler bug with another

        }

 wrongThingErr :: WrongThingSort -> TcTyThing -> Name -> TcM a

 wrongThingErr expected thing name =

   -- * Template Haskell context

   recordThUse, recordThNeededRuntimeDeps,

   keepAlive, getThLevel, getCurrentAndBindLevel, setThLevel,

   -- * Safe Haskell context

   recordUnsafeInfer, finalSafeMode, fixSafeInstances,

 getThLevel :: TcM ThLevel

 getThLevel = do { env <- getLclEnv; return (getLclEnvThLevel env) }

   = do { env <- getLclEnv;

            Nothing                  -> do

            Just (top_lvl, bind_lvl) -> return (Just (top_lvl, Set.singleton bind_lvl, getLclEnvThLevel env)) }

   mod <- getModule

 setThLevel :: ThLevel -> TcM a -> TcRn a

 setThLevel l = updLclEnv (setLclEnvThLevel l)

         isOrig, isOrig_maybe, isExact, isExact_maybe, isSrcRdrName,

         -- ** Preserving user-written qualification

         -- * Local mapping of 'RdrName' to 'Name.Name'

         LocalRdrEnv, emptyLocalRdrEnv, extendLocalRdrEnv, extendLocalRdrEnvList,

 noUserRdr :: Name -> WithUserRdr Name

 noUserRdr n = WithUserRdr (nameRdrName n) n

 userRdrName (WithUserRdr rdr _) = rdr

 rdrQual_maybe :: RdrName -> Maybe ModuleName

 rdrQual_maybe = \case

   Qual q _ -> Just q

 SI03.hs:10:11: error: [GHC-28914]

     • Level error: ‘sid’ is bound at level 0 but used at level -1

     • In the untyped splice: $(sid [| pure () |])

 SI05.hs:10:11: error: [GHC-28914]

     • In the untyped splice: $(sid [| pure () |])

 SI05.hs:10:11: error: [GHC-87543]

 SI25.hs:16:13: error: [GHC-28914]

     • Level error: ‘nestedCode’ is bound at level -1

       but used at level -2

     • In the untyped splice: $(nestedCode "nested")

       In the untyped splice: $($(nestedCode "nested"))

 SI28.hs:8:13: error: [GHC-28914]

     • Level error: ‘id’ is bound at level 1 but used at level 0

     • In the Template Haskell quotation: [| id |]

       In the untyped splice: $([| id |])

 <interactive>:2:3: error: [GHC-28914]

     • Level error: ‘id’ is bound at level 0 but used at level -1

     • In the untyped splice: $(id [| () |])

 T26088A.hs:8:8: error: [GHC-28914]

     • Level error: ‘a’ is bound at level -1 but used at level 1

     • In the Template Haskell quotation: [| a |]

 T26090.hs:2:17: error: [GHC-28914]

     • Level error: ‘a’ is bound at level 1 but used at level 0

 T26090.hs:4:17: error: [GHC-28914]

     • Level error: ‘s’ is bound at level 1 but used at level 0

     • In the export: S(s)

 T26090.hs:5:17: error: [GHC-28914]

     • Level error: ‘R’ is bound at level 1 but used at level 0