f x = let k = map toUpper

          in ...(static k)...

   form, as always. If all names are in scope, the free variables of the

   body are stored in AST at the location of the static form.

   static form are floatable to top level (see Note [Meaning of

   IdBindingInfo] in GHC.Tc.Types).  In our example, 'k' is floatable.

   Even though it is bound in a nested let, we are fine.

   See the call to `checkClosedInStaticForm` in the HsStatic case of `tcExpr`.

   function 'makeStatic' (defined in module GHC.StaticPtr.Internal of

   base).  So we get

    f x = let k = map toUpper

          in ...fromStaticPtr (makeStatic location k)...

   to the top level. Thus the FloatOut pass is always executed, even when

   optimizations are disabled.  So we get

   Making the binding exported also has a necessary effect during the

   CoreTidy pass.

   b = /\ ... -> makeStatic location value

   where a distinct key is generated for each binding.

   sptModuleInitCode) into the final object which runs when the module is loaded,

   inserting the static forms defined by the module into the RTS's static pointer

   table.

   the SPT entries (recorded in CgGuts' cg_spt_entries field) to the interpreter

   process' SPT table using the addSptEntry interpreter message. This happens

   in upsweep after we have compiled the module (see GHC.Driver.Make.upsweep').

 tcExpr (HsStatic fvs expr) res_ty

   = do  { res_ty          <- expTypeToType res_ty

         ; (co, (p_ty, expr_ty)) <- matchExpectedAppTy res_ty

         -- Check that the free variables of the static form are closed.

         -- It's OK to use nonDetEltsUniqSet here as the only side effects of

         -- checkClosedInStaticForm are error messages.

         ; mapM_ checkClosedInStaticForm $ nonDetEltsUniqSet fvs

         -- Require the type of the argument to be Typeable.

         ; typeableClass <- tcLookupClass typeableClassName

         ; typeable_ev <- emitWantedEvVar StaticOrigin $

         -- Wrap the static form with the 'fromStaticPtr' call.

         ; fromStaticPtr <- newMethodFromName StaticOrigin fromStaticPtrName

         ; let wrap = mkWpEvVarApps [typeable_ev] <.> mkWpTyApps [expr_ty]

         ; loc <- getSrcSpanM

         ; static_ptr_ty_con <- tcLookupTyCon staticPtrTyConName

         }

 tcExpr (HsEmbTy _ _)      _ = failWith (TcRnIllegalTypeExpr TypeKeywordSyntax)

 -- calling this, so that the reportUnsolved has access to the most

 -- complete GlobalRdrEnv

 captureTopConstraints thing_inside

        -- See GHC.Tc.Utils.Monad Note [Constraints and errors]

        -- If the thing_inside threw an exception, but generated some insoluble

        -- constraints, report the latter before propagating the exception

        -- Otherwise they will be lost altogether

        ; case mb_res of

            Nothing  -> do { _ <- simplifyTop lie; failM } }

                 -- This call to simplifyTop is the reason

                 -- this function is here instead of GHC.Tc.Utils.Monad

 solveImplicationUsingUnsatGiven

   unsat_given@(given_ev,_)

   impl@(Implic { ic_wanted = wtd, ic_tclvl = tclvl, ic_binds = ev_binds_var

   | isCoEvBindsVar ev_binds_var

   -- We can't use Unsatisfiable evidence in kinds.

   -- See Note [Coercion evidence only] in GHC.Tc.Types.Evidence.

   = return impl

   | otherwise

        ; setImplicationStatus $

          impl { ic_wanted = wcs

               , ic_need_implic = inner `extendEvNeedSet` given_ev } }

        ; tclvl             <- TcS.getTcLevel

        -- Step (3) in Note [How type-class constraints are defaulted]

        ; successes <- fmap catMaybes $

                       mapM firstSuccess proposalSequences

        ; traceTcS "disambigProposalSequences {" (vcat [ ppr wanteds

                                                       , ppr proposalSequences

                                             in unSwap swapped (uType uenv') ki1 ki2

                       -- mkKindEqLoc: any new constraints, arising from the kind

                       -- unification, say they thay come from unifying xi1~xi2

                -- Kick out any inert constraints mentioning the unified variables

                ; kickOutAfterUnification unifs

                -- Emit the deferred constraints

             do { emitChildEqs ev eqs

                          -- rewriterSetFromCts: record in the /type/ unification xi1~xi2 that

                          -- it has been rewritten by any (unsolved) constraints in `cts`; that

                          -- stops xi1~xi2 from unifying until `cts` are solved. See (EIK2).

 setTcLevelTcS lvl (TcS thing_inside)

  = TcS $ \ env -> TcM.setTcLevel lvl (thing_inside env)

               -> TcLevel -> TcS a

               -> TcS a

   = TcS $ \ env@(TcSEnv { tcs_inerts = old_inert_var }) ->

        ; new_inert_var <- TcM.newTcRef nest_inert

        ; new_wl_var    <- TcM.newTcRef emptyWorkList

        ; let nest_env = env { tcs_ev_binds = ev_binds_var

        ; checkForCyclicBinds ev_binds

 #endif

        ; return res }

 nestFunDepsTcS :: TcS a -> TcS a

 nestFunDepsTcS (TcS thing_inside)

                             , ic_wanted = wanteds

                             , ic_env    = ct_loc_env

                             , ic_info   = info })

     do { let loc    = mkGivenLoc tclvl info ct_loc_env

              givens = mkGivens loc given_ids

        ; solveSimpleGivens givens

          -- Solve the nested constraints

        ; (has_given_eqs, given_insols, residual_wanted)

                do { let loc    = mkGivenLoc tclvl info ct_loc_env

                         givens = mkGivens loc given_ids

                   ; solveSimpleGivens givens

         tcg_top_loc :: RealSrcSpan,

         -- ^ The RealSrcSpan this module came from

         tcg_complete_matches :: !CompleteMatches,

         -- ^ Complete matches defined in this module.

 -- Definition sites of orphan identities will be identity modules, not semantic

 -- modules.

 tcVisibleOrphanMods :: TcGblEnv -> ModuleSet

 tcVisibleOrphanMods tcg_env

     = mkModuleSet (tcg_mod tcg_env : imp_orphs (tcg_imports tcg_env))

       ic_info  :: SkolemInfoAnon,    -- See Note [Skolems in an implication]

                                      -- See Note [Shadowing in a constraint]

       ic_skols :: [TcTyVar],     -- Introduced skolems; always skolem TcTyVars

                                  -- Their level numbers should be precisely ic_tclvl

   | UnkSkol CallStack

 -- | Use this when you can't specify a helpful origin for

 -- some skolem type variable.

 pprSkolInfo RuntimeUnkSkol     = text "Unknown type from GHCi runtime"

 pprSkolInfo ArrowReboundIfSkol = text "the expected type of a rebound if-then-else command"

 -- unkSkol

 -- For type variables the others are dealt with by pprSkolTvBinding.

   getTcEvBindsMap, setTcEvBindsMap, updTcEvBinds,

   getTcEvTyCoVars, chooseUniqueOccTc,

   getConstraintVar, setConstraintVar,

   emitImplication, emitImplications, ensureReflMultiplicityCo,

   emitDelayedErrors, emitHole, emitHoles, emitNotConcreteError,

   discardConstraints, captureConstraints, tryCaptureConstraints,

      ; zany_n_var           <- newIORef 0

      ; dependent_files_var  <- newIORef []

      ; dependent_dirs_var   <- newIORef []

      ; cc_st_var            <- newIORef newCostCentreState

      ; th_topdecls_var      <- newIORef []

      ; th_foreign_files_var <- newIORef []

           , tcg_defaulting_plugins  = []

           , tcg_hf_plugins          = []

           , tcg_top_loc             = loc

           , tcg_complete_matches    = []

           , tcg_cc_st               = cc_st_var

           , tcg_next_wrapper_num    = next_wrapper_num

 setConstraintVar :: TcRef WantedConstraints -> TcM a -> TcM a

 setConstraintVar lie_var = updLclEnv (\ env -> env { tcl_lie = lie_var })

 emitConstraints :: WantedConstraints -> TcM ()

 emitConstraints ct

   | isEmptyWC ct