-Wimplicit

 -include

 rts/include/ghcversion.h

 -DDEBUG

 -DDYNAMIC

 -DPROFILING

        }

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

        ; let res_name = L (l2l (locA rdr_name)) (WithUserRdr (unLoc rdr_name) name)

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

                                 ; return (ExpBr noExtField e', fvs) }

         ; case mb_local_use of {

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

              Just (top_lvl, bind_lvl, use_lvl) ->

         -- this would break test for #20969

         --

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

         -- Therefore checkCrossLevelLiftingTy shouldn't assume anything

         -- about bind_lvl and use_lvl relation.

         --

                                                  <+> ppr use_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

 checkThLocalNameNoLift :: LIdOccP GhcRn -> RnM ()

 checkThLocalNameNoLift name = checkThLocalName False name >> return ()

 -- See Note [Template Haskell levels]

 checkThLocalName :: Bool -> LIdOccP GhcRn -> RnM (HsExpr GhcRn)

 checkThLocalName allow_lifting name_var

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

   | isExact (userRdrName (unLoc name_var)) || isOrig (userRdrName (unLoc name_var))

   = return (HsVar noExtField name_var)

   | isWiredInName name

   = return (HsVar noExtField name_var)

   | otherwise

         ; 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

         ; env <- getGlobalRdrEnv

         ; let mgre = lookupGRE_Name env name

   where

     name = getName name_var

 checkCrossLevelLifting :: DynFlags

                        -> LevelCheckReason

                        -> TopLevelFlag

                        -> Bool

                        -> Bool

                        -> Set.Set ThLevelIndex

                        -> ThLevel

                        -> LIdOccP GhcRn

                        -> TcM (HsExpr GhcRn)

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

   | use_lvl_idx `Set.member` bind_lvl = return (HsVar noExtField name_var)

   -- 2. Name is imported with -XImplicitStagePersistence

   , xopt LangExt.ImplicitStagePersistence dflags = return (HsVar noExtField name_var)

   -- 3. Name is top-level, with -XImplicitStagePersistence, and needs

   -- to be persisted into the future.

   , is_local

   , any (use_lvl_idx >=) (Set.toList bind_lvl)

   , xopt LangExt.ImplicitStagePersistence dflags = when (isExternalName name) (keepAlive name) >> return (HsVar noExtField name_var)

   -- 4. Name is in a bracket, and lifting is allowed

   | Brack _ pending <- use_lvl

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

   , allow_lifting

   | otherwise = addErrTc (TcRnBadlyLevelled reason bind_lvl use_lvl_idx Nothing ErrorWithoutFlag ) >> return (HsVar noExtField name_var)

   where

     name = getName name_var

   , xopt LangExt.ImplicitStagePersistence dflags

   = return ()

   | otherwise

   = return ()

 {-

 Note [Keeping things alive for Template Haskell]

 the stage restriction.

 ```

     • In the expression: foo [|| T () ||]

       In the expression: $$(foo [|| T () ||])

    |

 ```

 Solving a `Typeable (T t1 ...tn)` constraint generates code that relies on

                                       -- in module Language.Haskell.Syntax.Extension

 {-# LANGUAGE TypeFamilies #-}

 {-# LANGUAGE LambdaCase #-}

 module GHC.Tc.Utils.Env(

         TyThing(..), TcTyThing(..), TcId,

 notFound :: Name -> TcM TyThing

 notFound name

   = do { lcl_env <- getLclEnv

        ; if isTermVarOrFieldNameSpace (nameNameSpace name)

            then

                -- This code path is only reachable with RequiredTypeArguments enabled

 {- Note [Out of scope might be a staging error]

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

 Consider

 -}

 enableDebugInfo = addArgs $ notStage0 ? mconcat

     [ builder (Ghc CompileHs) ? pure ["-g3"]

     , builder (Ghc CompileCWithGhc) ? pure ["-optc-g3"]

     , builder (Cc CompileC) ? arg "-g3"

     , builder (Cabal Setup) ? arg "--disable-library-stripping"

     , builder (Cabal Setup) ? arg "--disable-executable-stripping"

           , Debug     `wayUnit` way          ? pure [ "-DDEBUG"

                                                     , "-fno-omit-frame-pointer"

                                                     , "-g3"

           -- Set the namespace for the rts fs functions

           , arg $ "-DFS_NAMESPACE=rts"

         while (*last != NULL && (*last)->next != NULL) {

             struct InitFiniList *s0 = *last;

             struct InitFiniList *s1 = s0->next;

             switch (order) {

                 case INCREASING: flip = s0->priority > s1->priority; break;

                 case DECREASING: flip = s0->priority < s1->priority; break;

         ASSERT((W_)str == (W_)block + sizeof(StgCompactNFDataBlock));

         StgWord totalW = 0;

         for ( ; block ; block = block->next) {

             last = block;

             ASSERT(block->owner == str);

     # of whether we expected the compilation to fail or not (successful

     # compilations may generate warnings).

     actual_stderr_file = add_suffix(name, 'comp.stderr')

     diff_file_name = in_testdir(add_suffix(name, 'comp.diff'))

     # of whether we expected the compilation to fail or not (successful

     # compilations may generate warnings).

     actual_asm_file = add_suffix(name, 's')

     if not await compare_outputs(way, 'asm',

     if badResult(result):

         return result

     actual_asm_file = add_suffix(name, 's')

     if not grep_output(join_normalisers(normalise_errmsg),

     if badResult(result):

         return result

     actual_core_file = add_suffix(name, 'dump-simpl')

     if not grep_output(join_normalisers(normalise_errmsg),

             return result

         if compile_stderr:

             actual_stderr_file = add_suffix(name, 'comp.stderr')

             diff_file_name = in_testdir(add_suffix(name, 'comp.diff'))

 async def stdout_ok(name: TestName, way: WayName) -> bool:

    actual_stdout_file = add_suffix(name, 'run.stdout')

    extra_norm = join_normalisers(normalise_output, getTestOpts().extra_normaliser)

 async def stderr_ok(name: TestName, way: WayName) -> bool:

    actual_stderr_file = add_suffix(name, 'run.stderr')

    return await compare_outputs(way, 'stderr',

                           join_normalisers(normalise_errmsg, getTestOpts().extra_errmsg_normaliser), \

         return False

 async def check_prof_ok(name: TestName, way: WayName) -> bool:

     expected_prof_path = in_testdir(expected_prof_file)

     # Check actual prof file only if we have an expected prof file to

 # Finding the sample output.  The filename is of the form

 #

 #

     basename = add_suffix(name, suff)

     # Override the basename if the user has specified one, this will then be

     # subjected to the same name mangling scheme as normal to allow platform

     # specific overrides to work.

     basename = getTestOpts().use_specs.get(suff, basename)

              for plat in ['-' + config.platform, '-' + config.os, '']

     for f in files:

         if in_srcdir(f).exists():

 test('T20696', [extra_files(['A.hs', 'B.hs', 'C.hs'])

                , unless(ghc_dynamic(), skip)], multimod_compile, ['A', ''])

 test('T20696-static', [extra_files(['A.hs', 'B.hs', 'C.hs'])

                , when(ghc_dynamic(), skip)], multimod_compile, ['A', ''])

 # Check linking works when using -fbyte-code-and-object-code

 test('fat011', [req_th, extra_files(['FatMain.hs', 'FatTH.hs', 'FatQuote.hs'])], multimod_compile, ['FatMain', '-fbyte-code-and-object-code -fprefer-byte-code'])

 # Check that we use interpreter rather than enable dynamic-too if needed for TH

 # Check that no objects are generated if using -fno-code and -fprefer-byte-code

 test('fat013', [req_th, req_bco, extra_files(['FatTH.hs', 'FatQuote.hs'])], multimod_compile, ['FatTH', '-fno-code -fprefer-byte-code'])

 # When using interpreter should not produce objects

 test('fat014', [req_th, extra_files(['FatTH.hs', 'FatQuote.hs']), extra_run_opts('-fno-code')], ghci_script, ['fat014.script'])

 test('T22807', [req_th, unless(ghc_dynamic(), skip), extra_files(['T22807A.hs', 'T22807B.hs'])]

              , makefile_test, ['T22807'])

 test('T22807_ghci', [req_th, unless(ghc_dynamic(), skip), extra_files(['T22807_ghci.hs'])]

 test('SI04', [extra_files(["SI01A.hs"])], multimod_compile, ['SI04', '-v0'])

 test('SI05', [extra_files(["SI01A.hs"])], multimod_compile_fail, ['SI05', '-v0'])

 test('SI06', [extra_files(["SI01A.hs"])], multimod_compile, ['SI06', '-v0'])

 # Instance tests

 test('SI08', [extra_files(["ClassA.hs", "InstanceA.hs"])], multimod_compile_fail, ['SI08', '-v0'])

 test('SI09', [extra_files(["ClassA.hs", "InstanceA.hs"])], multimod_compile, ['SI09', '-v0'])

 test('QQTopError', normal, compile_fail, ['-fdiagnostics-show-caret'])

 test('GadtConSigs_th_pprint1', normal, compile, [''])

 test('GadtConSigs_th_dump1', normal, compile, ['-v0 -ddump-splices -dsuppress-uniques'])