mkImplicitBinds :: Bool -> ModLocation -> TyCon -> [CoreBind]

 -- See Note [Data constructor workers]

 mkImplicitBinds gen_debug_info mod_loc tycon

   = classop_binds ++ datacon_binds

   where

         ; let rhs' = mkOptTickBox rhs_tick rhs_expr

         ; let body_ty = exprType body

         ; let mult = getTcMultAnn mult_ann

         ; matchSimply rhs' PatBindRhs mult pat' body error_expr }

     -- This is the one place where matchSimply is given a non-ManyTy

     -- multiplicity argument.

       --

       -- See Note [Don't attempt to trim data types]

       final_ids  = [ trimId (opt_trim_ids opts) id

                    , isExternalName (idName id)

                    , not (isWiredIn id)

                    ]   -- See Note [Drop wired-in things]

       tidy_cls_insts = mkFinalClsInsts tidy_type_env $ mkInstEnv cls_insts

       tidy_rules     = tidyRules tidy_env trimmed_rules

       -- Get the TyCons to generate code for.  Careful!  We must use

       -- the untidied TyCons here, because we need

       --  (a) implicit TyCons arising from types and classes defined

       local_ccs

         | opt_collect_ccs opts

         | otherwise

               = S.empty

   return (CgGuts { cg_module        = mod

                  , cg_tycons        = alg_tycons

                  , cg_ccs           = S.toList local_ccs

                  , cg_foreign       = all_foreign_stubs

                  , cg_foreign_files = foreign_files

   static form wouldn't be closed because the Show dictionary would come from

   g's context instead of coming from the top level.

   GHC.StaticPtr.Internal of base).  So we get

 (SF6) The CoreTidy pass, specifically `sptCreateStaticBinds`, replaces all

   bindings of the form

   with

   where a distinct key is generated for each binding.

 (SF7) If we are compiling to object code we insert a C stub (generated by

   `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

 -- pointer table.

 --

 -- See (SF6) in Note [Grand plan for static forms]

 sptCreateStaticBinds opts this_mod binds = do

       (fps, binds') <- evalStateT (go [] [] binds) 0

       let cstub

         Nothing      -> return (Nothing, (b, e))

         Just (_, t, info, arg) -> do

           (fp, e') <- mkStaticBind t info arg

     mkStaticBind :: Type -> CoreExpr -> CoreExpr

                  -> StateT Int IO (Fingerprint, CoreExpr)

   ppr (CheckGen _ s) = text "CheckGen" <+> ppr s

 decideGeneralisationPlan

    -> [LHsBind GhcRn] -> GeneralisationPlan

 decideGeneralisationPlan dflags top_lvl closed_type sig_fn lbinds

   | Just (bind, sig) <- one_funbind_with_sig = CheckGen bind sig

         -- types (see #25428). So we don't force it.

         -- See (NVP5) in Note [Non-variable pattern bindings aren't linear] in GHC.Tc.Gen.Bind.

         -- See Note [Always generalise top-level bindings]

       | has_mult_anns_and_pats = False

 import GHC.Data.FastString

 import GHC.Data.List.SetOps

 import GHC.Types.SrcLoc

 import GHC.Types.Basic hiding( SuccessFlag(..) )

 isTypeClosedLetBndr :: Id -> Bool

 -- See Note [Bindings with closed types: ClosedTypeId] in GHC.Tc.Types

 tcExtendRecIds :: [(Name, TcId)] -> TcM a -> TcM a

 -- Used for binding the recursive uses of Ids in a binding

 -- Used for both top-level value bindings and nested let/where-bindings

 -- Used for a single NonRec or a single Rec

 -- Adds to the TcBinderStack too

   = tcExtendBinderStack [TcIdBndr id top_lvl | Scaled _ id <- ids] $

     tc_extend_local_env top_lvl

     foldr check_one_usg thing_inside ids

   where

     check_one_usg (Scaled mult id) thing_inside

     (rep_tys, rep_strs) = unzip (concat rep_tys_w_strs)

     -- This is True if the data constructor or class dictionary constructor

     -- along with the accompanying implementation in getTyConImplicitBinds.

     wrapper_reqd

       | isTypeDataTyCon tycon

   print $ deRefStaticPtr (static g)

   print $ deRefStaticPtr p0 'a'

   print $ deRefStaticPtr (static t_field) $ T 'b'

 lookupKey :: StaticPtr a -> IO a

 lookupKey p = unsafeLookupStaticPtr (staticKey p) >>= \case

 RnStaticPointersFail01.hs:5:7: error: [GHC-88431]

 RnStaticPointersFail03.hs:8:7: error: [GHC-88431]

 RnStaticPointersFail03.hs:10:8: error: [GHC-88431]

 RnStaticPointersFail03.hs:19:15: error: [GHC-88431]

 CaretDiagnostics1.hs:7:8-15: error: [GHC-83865]

     • In the second argument of ‘(+)’, namely ‘(3 :: Int)’

       In a stmt of a 'do' block:

         10000000000000000000000000000000000000 + 2 + (3 :: Int)

   |         ^^^^^^^^^^^^^^^^^^^

 CaretDiagnostics1.hs:13:7-11: error: [GHC-83865]

                      with: [Char]

         Actual: String

     • In the pattern: "γηξ"

       In a case alternative: "γηξ" -> () '0'