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

                 -- 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 { uniq <- newUnique

   = do { local_env <- getLocalRdrEnv

        ; return (lookupLocalRdrEnv local_env rdr_name) }

 -- Just look in the local environment

 lookupLocalOccThLvl_maybe name

   = do { lcl_env <- getLclEnv

 import GHC.Hs

 import GHC.Tc.Errors.Types

 import GHC.Tc.Utils.Monad

 import GHC.Rename.Bind ( rnLocalBindsAndThen, rnLocalValBindsLHS, rnLocalValBindsRHS

     unlessXOptM LangExt.StaticPointers $

       addErr $ TcRnIllegalStaticExpression e

     (expr',fvExpr) <- rnLExpr expr

       Splice _ _ -> addErr $ TcRnTHError $ IllegalStaticFormInSplice e

       _        -> return ()

     mod <- getModule

                         | otherwise = False

        -- don't apply the transformation inside TH brackets, because

        -- GHC.HsToCore.Quote does not handle ApplicativeDo.

        ; if ado_is_on && is_do_expr && not in_th_bracket

             then do { traceRn "ppsfa" (ppr stmts)

                     ; rearrangeForApplicativeDo ctxt stmts }

 rnAnnDecl ann@(HsAnnotation (_, s) provenance expr)

   = addErrCtxt (AnnCtxt ann) $

     do { (provenance', provenance_fvs) <- rnAnnProvenance provenance

                               rnLExpr expr

        ; return (HsAnnotation (noAnn, s) provenance' expr',

                  provenance_fvs `plusFV` expr_fvs) }

     See Note [GlobalRdrEnv shadowing]

 3. We find out whether we are inside a [d| ... |] by testing the TH

    meant for the type checker, and here we are not interested in the

    fields of Brack, hence the error thunks in thRnBrack.

 -}

 extendGlobalRdrEnvRn new_gres new_fixities

   = checkNoErrs $  -- See Note [Fail fast on duplicate definitions]

     do  { (gbl_env, lcl_env) <- getEnvs

         ; isGHCi <- getIsGHCi

         ; let rdr_env  = tcg_rdr_env gbl_env

               fix_env  = tcg_fix_env gbl_env

               th_bndrs = getLclEnvThBndrs lcl_env

               -- Delete new_occs from global and local envs

               -- If we are in a TemplateHaskell decl bracket,

               --    we are going to shadow them

               -- See Note [GlobalRdrEnv shadowing]

               lcl_env_TH = modifyLclCtxt (\lcl_env -> lcl_env { tcl_rdr = minusLocalRdrEnv (tcl_rdr lcl_env) new_gres_env }) lcl_env

                            -- See Note [GlobalRdrEnv shadowing]

     do { checkForTemplateHaskellQuotes e

          -- Check for nested brackets

            { Splice _ _       -> return ()

                -- See Note [Untyped quotes in typed splices and vice versa]

            ; RunSplice _    ->

        ; recordThUse

        ; traceRn "Renaming typed TH bracket" empty

        ; return (HsTypedBracket noExtField body', fvs_e)

     do { checkForTemplateHaskellQuotes e

          -- Check for nested brackets

            { Splice _ _       -> return ()

                -- See Note [Untyped quotes in typed splices and vice versa]

            ; RunSplice _    ->

        ; (body', fvs_e) <-

          -- See Note [Rebindable syntax and Template Haskell]

          unsetXOptM LangExt.RebindableSyntax $

                   rn_utbracket br_body

        ; pendings <- readMutVar ps_var

        ; return (HsUntypedBracket pendings body', fvs_e)

                    -> RnM (a, FreeVars)

 rnUntypedSpliceGen run_splice pend_splice splice

   = addErrCtxt (UntypedSpliceCtxt splice) $ do

         Brack _ RnPendingTyped

           -> failWithTc $ thSyntaxError

                         $ MismatchedSpliceType Untyped IsSplice

                                     rnUntypedSplice splice

                 ; loc  <- getSrcSpanM

                 ; splice_name <- newLocalBndrRn (L (noAnnSrcSpan loc) unqualSplice)

                 ; return (result, fvs) }

         _ ->  do { checkTopSpliceAllowed splice

                  ; (splice', fvs1) <- checkNoErrs $

                                       rnUntypedSplice splice

                    -- checkNoErrs: don't attempt to run the splice if

                    -- renaming it failed; otherwise we get a cascade of

              -- Run the expression

        ; mod_finalizers_ref <- newTcRef []

                      run_meta zonked_q_expr

        ; mod_finalizers <- readTcRef mod_finalizers_ref

        ; traceSplice (SpliceInfo { spliceDescription = what

               -> RnM (HsExpr GhcRn, FreeVars)

 rnTypedSplice expr

   = addErrCtxt (TypedSpliceCtxt Nothing expr) $ do

         Brack _ (RnPendingUntyped _)

           -> failWithTc $ thSyntaxError $ MismatchedSpliceType Typed IsSplice

         _ -> do { unlessXOptM LangExt.TemplateHaskell

                     (failWith $ thSyntaxError IllegalTHSplice)

                   -- checkNoErrs: don't attempt to run the splice if

                   -- renaming it failed; otherwise we get a cascade of

                   -- errors from e.g. unbound variables

 -- Declaration splice at the very top level of the module

 rnTopSpliceDecls splice

    =  do { checkTopSpliceAllowed splice

          ; (rn_splice, fvs) <- checkNoErrs $

                                rnUntypedSplice splice

            -- As always, be sure to checkNoErrs above lest we end up with

            -- holes making it to typechecking, hence #12584.

   | otherwise

   = do  { traceRn "checkThLocalTyName" (ppr name)

         ; case mb_local_use of {

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

         -- this would break test for #20969

         --

         -- Consequently there is no check&restiction for top level splices.

         -- But it's annoying anyway.

         --

         -- about bind_lvl and use_lvl relation.

         --

         ; traceRn "checkThLocalTyName" (ppr name <+> ppr bind_lvl

                                                  <+> ppr use_lvl)

         ; dflags <- getDynFlags

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

   | otherwise

   = do  {

         ; case mb_local_use of {

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

         ; cur_mod <- extractModule <$> getGblEnv

         ; let is_local

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

                   | otherwise = True

         ; dflags <- getDynFlags

         ; env <- getGlobalRdrEnv

         ; let mgre = lookupGRE_Name env name

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

                        -> TopLevelFlag

                        -> Bool

                        -> Bool

                        -> ThLevel

                        -> Name -> TcM ()

   -- 1. If name is in-scope, at the correct level.

   -- 2. Name is imported with -XImplicitStagePersistence

   | not is_local

   , xopt LangExt.ImplicitStagePersistence dflags = return ()

   -- to be persisted into the future.

   | isTopLevel top_lvl

   , is_local

   , xopt LangExt.ImplicitStagePersistence dflags = when (isExternalName name) (keepAlive name)

   -- 4. Name is in an untyped bracket, and we are allowed to attempt to lift.

   , allow_lifting

   = do

       dflags <- getDynFlags

   -- 5. For an typed bracket, these checks happen again later on (checkThLocalId)

   -- In the future we should do all the level checks here.

     = return ()

   -- Otherwise, we have a level error, report.

   | isTopLevel top_lvl

   , xopt LangExt.ImplicitStagePersistence dflags

         -- Top-level identifiers in this module,

         -- If 'x' occurs many times we may get many identical

         -- bindings of the same SplicePointName, but that doesn't

         -- matter, although it's a mite untidy.

           -- Construct the (lift x) expression

         ; let lift_expr   = nlHsApp (nlHsVar liftName) (nlHsVar name)

         ; ps <- readMutVar ps_var

         ; writeMutVar ps_var (pend_splice : ps) }

   | isTopLevel top_lvl

   , xopt LangExt.ImplicitStagePersistence dflags

   = return ()

   -- Can also happen for negative cases

   -- See comment in checkThLocalTyName:

   | otherwise

   = return ()

 Note [Quoting names]

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

 A quoted name 'n is a bit like a quoted expression [| n |], except that we

 the use-level to account for the brackets, the cases are:

         bind > use                      Error

   \x. f 'x      -- Not ok (bind = 1, use = 1)

                 -- (whereas \x. f [| x |] might have been ok, by

   \y. [| \x. $(f 'y) |] -- Not ok (bind =1, use = 1)

 bindLocalNames :: [Name] -> RnM a -> RnM a

 bindLocalNames names

   = updLclCtxt $ \ lcl_env ->

         th_bndrs' = extendNameEnvList (tcl_th_bndrs lcl_env)

                     [ (n, (NotTopLevel, th_level)) | n <- names ]

         rdr_env'  = extendLocalRdrEnvList (tcl_rdr lcl_env) names

     TcRnBadlyLevelled reason bind_lvl use_lvl

       -> mkSimpleDecorated $

          vcat $

            hsep [text "is bound at level" <+> ppr bind_lvl,

                  text "but used at level" <+> ppr use_lvl]

          ] ++

          [ hsep [ text "Hint: quoting" <+> thBrackets (ppUnless (isValName n) "t") (ppr n)

                 , text "or an enclosing expression would allow the quotation to be used at an earlier level"

                 ]

          ] ++

          [ "From imports" <+> (ppr (gre_imp gre))

          , not (isEmptyBag (gre_imp gre)) ]

     TcRnBadlyLevelledType name bind_lvl use_lvl

       -> mkSimpleDecorated $

     WrongThingTyCon -> "type constructor"

     WrongThingAxiom -> "axiom"

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

     quotes (ppr t)

 pprUninferrableTyVarCtx :: UninferrableTyVarCtx -> SDoc

     mkSimpleDecorated $

       hang (text "The binder" <+> quotes (ppr name) <+> text "is not a NameU.")

          2 (text "Probable cause: you used mkName instead of newName to generate a binding.")

 pprTHReifyError :: THReifyError -> DecoratedSDoc

 pprTHReifyError = \case

 thNameErrorReason :: THNameError -> DiagnosticReason

 thNameErrorReason = \case

   NonExactName {}         -> ErrorWithoutFlag

 thReifyErrorReason :: THReifyError -> DiagnosticReason

 thReifyErrorReason = \case

 thNameErrorHints :: THNameError -> [GhcHint]

 thNameErrorHints = \case

   NonExactName {}         -> noHints

 thReifyErrorHints :: THReifyError -> [GhcHint]

 thReifyErrorHints = \case

   , RuleLhsErrReason(..)

   , HsigShapeMismatchReason(..)

   , WrongThingSort(..)

   , UninferrableTyVarCtx(..)

   , PatSynInvalidRhsReason(..)

   , BadFieldAnnotationReason(..)

     -> !LookupInstanceErrReason

     -> TcRnMessage

       invalid level.

     Test cases:

       T17820d, T17820, T21547, T5795, qq00[1-4], annfail0{3,4,6,9}

   -}

   TcRnBadlyLevelled

     -> TcRnMessage

     used in an invalid stage.

     Controlled by flags:

   -}

   TcRnBadlyLevelledType

     :: !Name  -- ^ The type binding being spliced.

     -> TcRnMessage

   {-| TcRnTyThingUsedWrong is an error that occurs when a thing is used where another

   | WrongThingTyCon

   | WrongThingAxiom

 data UninferrableTyVarCtx

   = UninfTyCtx_ClassContext [TcType]

   -}

   = NonExactName !RdrName

   deriving Generic

 data THReifyError

        --

        -- See [Wrinkle: VTA] in Note [Representation-polymorphism checking built-ins]

        -- in GHC.Tc.Utils.Concrete.

        ; ty_arg <- case mb_conc of

            Nothing   -> return ty_arg0

            Just conc

              -- See [Wrinkle: Typed Template Haskell]

              -- in Note [hasFixedRuntimeRep] in GHC.Tc.Utils.Concrete.

              -> return ty_arg0

              | otherwise

              ->

 -- checkThLocalName.

 checkThLocalId :: Id -> TcM ()

 checkThLocalId id

         ; case mb_local_use of

                 -> do

                     dflags <- getDynFlags

              _  -> return ()   -- Not a locally-bound thing, or

                                -- no cross-stage link

     }

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

 -- If we are inside typed brackets, and (use_lvl > bind_lvl)

 -- we must check whether there's a cross-stage lift to do

 -- Examples   \x -> [|| x ||]

 --            [|| map ||]

 --

 -- this code is applied to *typed* brackets.

   | isTopLevel top_lvl

   , xopt LangExt.ImplicitStagePersistence dflags

   = when (isExternalName id_name) (keepAlive id_name)

   where

     id_name = idName id

 {-

 Note [Lifting strings]

 The level which a name is availble at is stored in the 'GRE', in the normal

 GlobalRdrEnv. The function `greLevels` returns the levels which a specific GRE

 is imported at. The level information for a 'Name' is computed by `getStageAndBindLevel`.

 Instances are checked by `checkWellStagedDFun`, which computes the level an

 instance by calling `checkWellStagedInstanceWhat`, which sees what is available at by looking at the module graph.

 That's it for the main implementation of the feature, and the rest is modifications

 to the driver parts of the code to use this information. For example, in downsweep,

 we only enable code generation for modules needed at the runtime stage.

 -}

 {-

 Note [Template Haskell state diagram]

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

 The top level of the program is stage Comp:

      Start here

 RENAMER (rnUntypedBracket):

 * Rename the body

 TYPECHECKER (tcTypedBracket):

 * Typecheck the body, and keep the elaborated result (despite never using it!)

 -- See Note [How brackets and nested splices are handled]

 tcTypedBracket rn_expr expr res_ty

   = addErrCtxt (TypedTHBracketCtxt expr) $

        ; ps_ref <- newMutVar []

        ; lie_var <- getConstraintVar   -- Any constraints arising from nested splices

                                        -- should get thrown into the constraint set

        -- The typechecked expression won't be used, so we just discard it

        --   (See Note [The life cycle of a TH quotation] in GHC.Hs.Expr)

        -- We'll typecheck it again when we splice it in somewhere

                                 tcScalingUsage ManyTy $

                                 -- Scale by Many, TH lifting is currently nonlinear (#18465)

                                 tcInferRhoNC expr

 tcTypedSplice splice_name expr res_ty

   = addErrCtxt (TypedSpliceCtxt (Just splice_name) expr) $

     setSrcSpan (getLocA expr)    $ do

           Splice {}            -> tcTopSplice expr res_ty

           Brack pop_stage pend -> tcNestedSplice pop_stage pend splice_name expr res_ty

           RunSplice _          ->

   = checkNoErrs $  -- checkNoErrs: must not try to run the thing

                    -- if the type checker fails!

     do {    -- Typecheck the expression

          (mb_expr', wanted) <- tryCaptureConstraints tc_action

              -- If tc_action fails (perhaps because of insoluble constraints)

             Just expr' -> return $ mkHsDictLet (EvBinds const_binds) expr' }

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

                 -> LHsExpr GhcRn -> ExpRhoType -> TcM (HsExpr GhcTc)

     -- See Note [How brackets and nested splices are handled]

     -- A splice inside brackets

   = do { res_ty <- expTypeToType res_ty

        ; let rep = getRuntimeRep res_ty

        ; meta_exp_ty <- tcTExpTy m_var res_ty

                   setConstraintVar lie_var $

                   tcCheckMonoExpr expr meta_exp_ty

        ; untype_code <- tcLookupId unTypeCodeName

         -- See Note [Collecting modFinalizers in typed splices].

        ; modfinalizers_ref <- newTcRef []

          -- Run the expression

                     runMetaE zonked_q_expr

        ; mod_finalizers <- readTcRef modfinalizers_ref

        ; addModFinalizersWithLclEnv $ ThModFinalizers mod_finalizers

 -- | Adds a mod finalizer reference to the local environment.

 addModFinalizerRef :: ForeignRef (TH.Q ()) -> TcM ()

 addModFinalizerRef finRef = do

       RunSplice th_modfinalizers_var -> updTcRef th_modfinalizers_var (finRef :)

       -- This case happens only if a splice is executed and the caller does

       -- See Note [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice.

       _ ->

         pprPanic "addModFinalizer was called when no finalizers were collected"

 -- | Releases the external interpreter state.

 finishTH :: TcM ()

 -- Returns the CtLoc to used for sub-goals

 -- Probably also want to call checkReductionDepth

 checkInstanceOK loc what pred

        ; return deeper_loc }

   where

      deeper_loc = zap_origin (bumpCtLocDepth loc)

     -- Misc

     getDefaultInfo, getDynFlags, getGlobalRdrEnvTcS,

     matchFam, matchFamTcM,

     pprEq,

     -- Enforcing invariants for type equalities

 -- Various smaller utilities [TODO, maybe will be absorbed in the instance matcher]

 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 -- Check that we do not try to use an instance before it is available.  E.g.

 --    instance Eq T where ...

 --    f x = $( ... (\(p::T) -> p == p)... )

 -- Here we can't use the equality function from the instance in the splice

   = do

       case mbind_lvl of

         Just (bind_lvl, is_local) ->

           wrapTcS $ TcM.setCtLocM loc $ do

               ; dflags <- getDynFlags

         -- If no level information is returned for an InstanceWhat, then it's safe to use

         -- at any level.

         Nothing -> return ()

                             -> Bool -> TcM ()

   | not is_local

   , xopt LangExt.ImplicitStagePersistence dflags

   = return ()