-}

 runQuasi :: TH.Q a -> TcM a

 runRemoteModFinalizers :: ThModFinalizers -> TcM ()

 runRemoteModFinalizers (ThModFinalizers finRefs) = do

                                 , TH.loc_start = (srcSpanStartLine r, srcSpanStartCol r)

                                 , TH.loc_end = (srcSpanEndLine   r, srcSpanEndCol   r) }) }

                       ; let i = toInteger (getKey u)

                       ; return (TH.mkNameU s i) }

     -- 'msg' is forced to ensure exceptions don't escape,

     -- see Note [Exceptions in TH]

                                       ; dc  <- tcLookupDataCon nm'

                                       ; let bangs = dataConImplBangs dc

                                       ; return (map reifyDecidedStrictness bangs) }

         dflags <- getDynFlags

         return $ fromMaybe "." (workingDirectory dflags)

         ref <- fmap tcg_dependent_files getGblEnv

         dep_files <- readTcRef ref

         writeTcRef ref (fp:dep_files)

         ref <- fmap tcg_dependent_dirs getGblEnv

         dep_dirs <- readTcRef ref

         writeTcRef ref (dp:dep_dirs)

         dflags <- getDynFlags

         logger <- getLogger

         tmpfs  <- hsc_tmpfs <$> getTopEnv

         liftIO $ newTempName logger tmpfs (tmpDir dflags) TFL_GhcSession suffix

         var <- fmap tcg_th_foreign_files getGblEnv

         updTcRef var ((lang, fp) :)

         r <- liftIO $ mkRemoteRef fin

         fref <- liftIO $ mkForeignRef r (freeRemoteRef r)

         addModFinalizerRef fref

         hsc_env <- getTopEnv

         let fc        = hsc_FC hsc_env

         let home_unit = hsc_home_unit hsc_env

         th_coreplugins_var <- tcg_th_coreplugins <$> getGblEnv

         updTcRef th_coreplugins_var (plugin:)

         th_state_var <- fmap tcg_th_state getGblEnv

         updTcRef th_state_var (\m -> Map.insert (typeOf x) (toDyn x) m)

         EnumSet.toList . extensionFlags . hsc_dflags <$> getTopEnv

   }

 -- | Looks up documentation for a declaration in first the current module,

 --  type environment, so reification isn't going to

 --  work.

 instance Quasi IO where

   qNewName = newNameIO

   qReport True  msg = hPutStrLn stderr ("Template Haskell error: " ++ msg)

 -- inversion](https://en.wikipedia.org/wiki/Dependency_inversion_principle),

 -- providing an abstract interface for the user which is later concretely

 -- fufilled by an concrete 'Quasi' instance, internal to GHC.

 -- | \"Runs\" the 'Q' monad. Normal users of Template Haskell

 -- should not need this function, as the splice brackets @$( ... )@

 runQ = qRunQ

 instance Monad Q where

   (>>) = (*>)

 instance MonadFail Q where

 instance Functor Q where

 instance Applicative Q where

 -- | @since 2.17.0.0

 instance Semigroup a => Semigroup (Q a) where

   newName :: String -> m Name

 runHandler :: (forall m. MetaHandlers m -> m a) -> Q a

 runHandler1 :: (forall m. MetaHandlers m -> a -> m b) -> a -> Q b

 runHandler2 :: (forall m. MetaHandlers m -> a -> b -> m c) -> a -> b -> Q c

 instance Quote Q where

   newName = runHandler1 mNewName

 recover :: Q a -- ^ handler to invoke on failure

         -> Q a -- ^ computation to run

         -> Q a

 -- We don't export lookupName; the Bool isn't a great API

 -- Instead we export lookupTypeName, lookupValueName

 -- necessarily flushed when the compiler finishes running, so you should

 -- flush them yourself.

 runIO :: IO a -> Q a

 -- | Get the package root for the current package which is being compiled.

 -- This can be set explicitly with the -package-root flag but is normally

 {-# LANGUAGE ScopedTypeVariables, StandaloneDeriving, DeriveGeneric,

 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}

 -- |

     where typerep = typeOf (undefined :: a)

 runQinGHCiQ :: TH.Q a -> GHCiQ a

   where

     runInIO :: IORef QState -> GHCiQ a -> IO a

     runInIO sRef (GHCiQ m) = m sRef

   -- See Note [TH recover with -fexternal-interpreter] in GHC.Tc.Gen.Splice

       s <- readIORef sRef

       remoteTHCall (qsPipe s) StartRecover

       e <- try $ unmask $ runGHCiQ (runQinGHCiQ a <* ghcCmd FailIfErrs) sRef

           -- in case of error, restore the state to the start of the `recover` block.

           newIORef s >>= runGHCiQ (runQinGHCiQ h)

         Right r -> return r

                          ghcCmd . AddModFinalizer

     s <- getState

     let lookup :: forall a. Typeable a => Map TypeRep Dynamic -> Maybe a

         lookup m = fromDynamic =<< M.lookup (typeOf (undefined::a)) m

     return $ lookup (qsMap s)

       modifyIORef' sRef (\s -> s { qsMap = M.insert (typeOf k) (toDyn k) (qsMap s) })

 }

 -- | The implementation of the 'StartTH' message: create