{ implicit_lift_bind_lvl :: S.Set ThLevelIndex

           , implicit_lift_used_lvl :: ThLevelIndex

           , implicit_lift_gre :: Maybe GlobalRdrElt

           , implicit_lift_lid :: LIdOccP GhcRn

           }

         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

 {- Note [eqTyCon (~) compatibility fallback]

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

 -}

 -- Used when looking up a term name (varName or dataName) in a type

 lookup_demoted rdr_name

   | Just demoted_rdr <- demoteRdrNameTcCls rdr_name

     -- Maybe it's the name of a *data* constructor

        ; star_is_type <- xoptM LangExt.StarIsType

        ; let is_star_type = if star_is_type then StarIsType else StarIsNotType

              star_is_type_hints = noStarIsTypeHints is_star_type rdr_name

        ; if data_kinds

             then do { mb_demoted_gre <- lookupOccRn_maybe demoted_rdr

                     ; case mb_demoted_gre of

             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

                                      = [SuggestExtension $ SuggestSingleExtension additional LangExt.DataKinds]

                                      | otherwise

                                      = star_is_type_hints

   | isQual rdr_name,

     Just demoted_rdr_name <- demoteRdrNameTv rdr_name

     -- Definitely an illegal term variable, as type variables are never exported.

     -- See Note [Demotion of unqualified variables] (W2)

   | isUnqual rdr_name,

     Just demoted_rdr_name <- demoteRdrNameTv rdr_name

        ; if required_type_arguments

          then do { mb_demoted_gre <- lookupOccRn_maybe demoted_rdr_name

                  ; case mb_demoted_gre of

   | otherwise

   where

     looking_for = LF WL_Type WL_Anywhere

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

         ; let res_name = WithUserRdr (unLoc quoter) <$> quoter'

         ; 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

        -- Warning for implicit lift (#17804)

        addDetailedDiagnostic (TcRnImplicitLift name)

 import GHC.Hs

 import GHC.Tc.Utils.Monad

 import GHC.Types.Name.Set

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

    , mkUnboundNameRdr

    , mkUnboundGRE

    , mkUnboundGRERdr

    , isUnboundName

    , reportUnboundName

    , unknownNameSuggestions

    , LookingFor(..)

    , unboundName

    , unboundNameX

    , unboundTermNameInTypes

    , IsTermInTypes(..)

    , notInScopeErr

 mkUnboundNameRdr rdr = mkUnboundName (rdrNameOcc rdr)

 mkUnboundGRE :: OccName -> GlobalRdrElt

 mkUnboundGRERdr :: RdrName -> GlobalRdrElt

 reportUnboundName :: WhatLooking -> RdrName -> RnM Name

 reportUnboundName what_look rdr = unboundName (LF what_look WL_Anywhere) rdr

 unboundName :: LookingFor -> RdrName -> RnM Name

 unboundName lf rdr = unboundNameX lf rdr []

     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

 import qualified GHC.LanguageExtensions as LangExt

 import GHC.Iface.Errors.Types

 import GHC.Tc.Errors.Types.PromotionErr

 import {-# SOURCE #-} GHC.Tc.Errors.Hole (getHoleFitDispConfig)

           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)

                                           -- introducing bugs after a refactoring of that

                                           -- function, we check this completely independently

                                           -- before scrutinizing 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 =

 getThLevel :: TcM ThLevel

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

   = do { env <- getLclEnv;