tcg_tcs          = tcs,

                             tcg_default_exports = defaults,

                             tcg_insts        = insts,

                             tcg_fam_insts    = fam_insts,

                             tcg_complete_matches = complete_matches,

                             tcg_self_boot    = self_boot

                                        (hsc_logger hsc_env)

                                        (initTicksConfig (hsc_dflags hsc_env))

                                        mod mod_loc

                               else return (binds, Nothing)

         ; let modBreaks

                 | Just (_, _, breakpointSpecs) <- m_tickInfo

 import GHC.Core.Type

 import GHC.Core.TyCon

 import GHC.Data.Maybe

 import GHC.Data.FastString

                                 -- isExportedId doesn't work yet (the desugarer

                                 -- hasn't set it), so we have to work from this set.

         -> [TyCon]              -- ^ Type constructors in this module

         -> LHsBinds GhcTc

         -> IO (LHsBinds GhcTc, Maybe (FilePath, SizedSeq Tick, SizedSeq Tick))

 addTicksToBinds logger cfg

   | let passes = ticks_passes cfg

   , not (null passes)

   , Just orig_file <- ml_hs_file mod_loc = do

                       , this_mod     = mod

                       , tickishType  = tickish

                       , recSelBinds  = emptyVarEnv

                       }

                 (binds',_,st') = unTM (addTickLHsBinds binds) env st

             in (binds', st')

 addTickLHsBind (L pos (XHsBindsLR bind@(AbsBinds { abs_binds = binds

                                                  , abs_exports = abs_exports

                                                  }))) =

       binds' <- addTickLHsBinds binds

       return $ L pos $ XHsBindsLR $ bind { abs_binds = binds' }

   where

                           | ABE{ abe_poly, abe_mono } <- abs_exports

                           , RecSelId{} <- [idDetails abe_poly] ] }

 addTickLHsBind (L pos (funBind@(FunBind { fun_id = L _ id, fun_matches = matches }))) = do

   let name = getOccString id

   decl_path <- getPathEntry

   density <- getDensity

   -- See Note [inline sccs]

   let inline   = isInlinePragma (idInlinePragma id)

   -- See Note [inline sccs]

   -- See Note [Record-selector ticks]

   selTicks <- recSelTick id

       toplev = null decl_path

       exported = idName id `elemNameSet` exported_names

              then

                 bindTick density name (locA pos) fvs

              else

                         , this_mod     :: Module

                         , tickishType  :: TickishType

                         , recSelBinds  :: IdEnv DVarSet

                         }

 --      deriving Show

                 -- Second pass over class and instance declarations,

                 -- now using the kind-checked decls

         traceTc "Tc6" empty ;

                 -- Foreign exports

         traceTc "Tc7" empty ;

                                  , tcg_anns    = tcg_anns tcg_env ++ annotations

                                  , tcg_ann_env = extendAnnEnvList (tcg_ann_env tcg_env) annotations

                                  , tcg_fords   = tcg_fords tcg_env ++ foe_decls ++ fi_decls

                                  -- tcg_dus: see Note [Newtype constructor usage in foreign declarations]

         -- See Note [Newtype constructor usage in foreign declarations]

         addUsedGREs NoDeprecationWarnings (bagToList fo_gres) ;

 ********************************************************************* -}

 tcInstDecls2 :: [LTyClDecl GhcRn] -> [InstInfo GhcRn]

 -- (a) From each class declaration,

 --      generate any default-method bindings

 -- (b) From each instance decl

               -- Add the default method Ids (again)

               -- (they were already added in GHC.Tc.TyCl.Utils.tcAddImplicits)

               -- See Note [Default methods in the type environment]

           -- Done

 {- Note [Default methods in the type environment]

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

 the default method Ids replete with their INLINE pragmas.  Urk.

 -}

             -- Returns a binding for the dfun

 tcInstDecl2 (InstInfo { iSpec = ispec, iBinds = ibinds })

     do {  -- Instantiate the instance decl with skolem constants

          (skol_info, inst_tyvars, dfun_theta, clas, inst_tys) <- tcSkolDFunType dfun_ty

        ; dfun_ev_vars <- newEvVars dfun_theta

          -- See Note [Typechecking plan for instance declarations]

        ; dfun_ev_binds_var <- newTcEvBinds

        ; let dfun_ev_binds = TcEvBinds dfun_ev_binds_var

              <- pushTcLevelM $

                 do { (sc_ids, sc_binds, sc_implics)

                         <- tcSuperClasses skol_info dfun_id clas inst_tyvars

                    ; return ( sc_ids     ++          meth_ids

                             , sc_binds   ++ meth_binds

        ; imp <- newImplication

        ; emitImplication $

                                   , abs_binds = [dict_bind]

                                   , abs_sig = True }

        }

  where

    dfun_id = instanceDFunId ispec

 import GHC.Types.Name.Set

 import GHC.Types.Avail

 import GHC.Types.Var

 import GHC.Types.TypeEnv

 import GHC.Types.SourceFile

 import GHC.Types.SrcLoc

           -- ^ Instance envt for all /home-package/ modules;

           -- Includes the dfuns in tcg_insts

           -- NB. BangPattern is to fix a leak, see #15111

         tcg_fam_inst_env :: !FamInstEnv, -- ^ Ditto for family instances

           -- NB. BangPattern is to fix a leak, see #15111

         tcg_ann_env      :: AnnEnv,     -- ^ And for annotations

           , tcg_knot_vars          = hsc_type_env_vars hsc_env

           , tcg_known_key_maps     = known_key_maps_var

           , tcg_inst_env           = emptyInstEnv

           , tcg_fam_inst_env       = emptyFamInstEnv

           , tcg_ann_env            = emptyAnnEnv

           , tcg_complete_match_env = []