For these chaps (which have Internal Names) we don't want to put

 them in the keep-alive set.

 Note [Quoting names]

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

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

 import Data.Dynamic  ( fromDynamic, toDyn )

 import qualified Data.IntMap as IntMap

 import qualified Data.Map as Map

 import Data.Proxy    ( Proxy (..) )

 import Data.IORef

 import GHC.Parser.HaddockLex (lexHsDoc)

 import GHC.Parser (parseIdentifier)

 import GHC.Rename.Doc (rnHsDoc)

 {-

 Note [Template Haskell state diagram]

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

 -}

 -- None of these functions add constraints to the LIE

 {-

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

 -}

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

 tcTypedBracket rn_expr expr res_ty

   = addErrCtxt (TypedTHBracketCtxt expr) $

     do { cur_lvl <- getThLevel

                        meta_ty res_ty }

 -- See Note [Typechecking Overloaded Quotes]

 tcUntypedBracket rn_expr brack ps res_ty

   = do { traceTc "tc_bracket untyped" (ppr brack $$ ppr ps)

 -- getUntypedSpliceBody: the renamer has expanded the splice.

 -- Just run the finalizers that it produced, and return

 -- the renamed expression

 getUntypedSpliceBody (HsUntypedSpliceTop { utsplice_result_finalizers = mod_finalizers

                                          , utsplice_result = rn_expr })

   = do { addModFinalizersWithLclEnv mod_finalizers

 getUntypedSpliceBody (HsUntypedSpliceNested {})

   = panic "tcTopUntypedSplice: invalid nested splice"

 tcTypedSplice HsTypedSpliceTop ctxt@(HsTypedSpliceExpr _ expr) res_ty

   = addErrCtxt (TypedSpliceCtxt Nothing ctxt) $

     setSrcSpan (getLocA expr)    $

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

 -}

 runAnnotation target expr = do

     -- Find the classes we want instances for in order to call toAnnotationWrapper

     loc <- getSrcSpanM

                                 specialised_to_annotation_wrapper_expr expr'))

                                 })

     -- Run the appropriately wrapped expression to get the value of

     -- the annotation and its dictionaries. The return value is of

     -- type AnnotationWrapper by construction, so this conversion is

     -- safe

     return Annotation {

                ann_target = target,

                ann_value = serialized

            }

 convertAnnotationWrapper fhv = do

   interp <- tcGetInterp

   case interpInstance interp of

                -- annotation are exposed at this point.  This is also why we are

                -- doing all this stuff inside the context of runMeta: it has the

                -- facilities to deal with user error in a meta-level expression

 #endif

 {-

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

 runMetaAW :: LHsExpr GhcTc         -- Of type AnnotationWrapper

 runMetaAW = runMeta metaRequestAW

 runMetaE :: LHsExpr GhcTc          -- Of type (Q Exp)

 import GHC.Prelude

 import GHC.Serialized   ( Serialized )

 import GHC.Hs

 import GHC.Utils.Outputable

   | MetaP  (LPat GhcPs      -> MetaResult)

   | MetaT  (LHsType GhcPs   -> MetaResult)

   | MetaD  ([LHsDecl GhcPs] -> MetaResult)

 -- | data constructors not exported to ensure correct result type

 data MetaResult

   | MetaResP  (LPat GhcPs)

   | MetaResT  (LHsType GhcPs)

   | MetaResD  [LHsDecl GhcPs]

 instance Outputable MetaResult where

     ppr (MetaResE e)   = text "MetaResE"  <> braces (ppr e)

 unMetaResD (MetaResD d) = d

 unMetaResD mr           = pprPanic "unMetaResD" (ppr mr)

 unMetaResAW (MetaResAW aw) = aw

 unMetaResAW mr             = pprPanic "unMetaResAW" (ppr mr)

 metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]

 metaRequestD h = fmap unMetaResD . h (MetaD MetaResD)

 metaRequestAW h = fmap unMetaResAW . h (MetaAW MetaResAW)

 import GHC.Utils.Exception

 import GHC.Exts (oneShot)

 {-

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

 *                                                                      *

 instance Outputable Serialized where

     ppr (Serialized the_type bytes) = int (length bytes) <+> text "of type" <+> text (show the_type)

 instance Outputable Extension where

     ppr = text . show

 instance Outputable ModuleName where

   ppr = pprModuleName

 pprModuleName :: IsLine doc => ModuleName -> doc

 pprModuleName (ModuleName nm) =

     docWithStyle (ztext (zEncodeFS nm)) (\_ -> ftext nm)

 instance OutputableP env Void where

     pdoc _ = \ case

 {-

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

 *                                                                      *