JoinId {}        -> True

       WorkerLikeId {}  -> True

       RepPolyId {}     -> True

 interestingDict :: SpecEnv -> CoreExpr -> Bool

 -- This is a subtle and important function

 toIfaceIdDetails :: IdDetails -> IfaceIdDetails

 toIfaceIdDetails VanillaId                      = IfVanillaId

 toIfaceIdDetails (WorkerLikeId dmds)            = IfWorkerLikeId dmds

 toIfaceIdDetails (DFunId {})                    = IfDFunId

 toIfaceIdDetails (RecSelId { sel_naughty = n

                             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

                                        (initTicksConfig (hsc_dflags hsc_env))

                                        mod mod_loc

                                        export_set (typeEnvTyCons type_env)

                               else return (binds, Nothing)

         ; let modBreaks

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

 {-# OPTIONS_GHC -Wno-incomplete-record-updates #-}

 import GHC.Types.Var.Env

 import GHC.Types.Name.Set

 import GHC.Types.Name

 import GHC.Types.CostCentre

 import GHC.Types.CostCentre.State

 import GHC.Types.Tickish

 import GHC.Types.ProfAuto

 import GHC.Tc.Types.ErrCtxt

 import Control.Monad

 import Data.List (isSuffixOf, intersperse)

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

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

         -> [ClsInst]            -- ^ Class instances 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

                       }

                 addTick = do

                   instTicks <- allocInstTicks insts

      env{ instMeths = instMeths env `extendVarEnvList`

                         [ (abe_mono, dfun)

                         | ABE{ abe_poly, abe_mono } <- abs_exports

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

   let name = getOccString id

 -- inherited and hand-written, we need to go out of our way to create top-level

 -- tick boxes only for methods which correspond to user-written code.

 --

 --

 -- Additionally, we also want to inform the user whether or not their class

 -- instance as a whole has been used at run-time. To do so, we create a single

                         , this_mod     :: Module

                         , tickishType  :: TickishType

                         , recSelBinds  :: IdEnv DVarSet

                         }

 --      deriving Show

 isBlackListed UnhelpfulSpan{} = return False

 -- See Note [Instance Method Coverage].

 allocInstTicks insts =

   where

     alloc ClsInst{ is_dfun, is_cls }

       | null (classMethods is_cls) = pure Nothing

 -- See Note [Instance Method Coverage].

 instMethTick :: Id -> TM (Maybe CoreTickish)

 -- the tick application inherits the source position of its

 -- expression argument to support nested box allocations

                 -- 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) ;

 import GHC.Core.Type

 import GHC.Core.Multiplicity

 import GHC.Core.InstEnv

 import GHC.Core.TyCon

 import GHC.Core.Coercion.Axiom

 import GHC.Core.DataCon

 import GHC.Types.Basic

 import GHC.Types.ForeignCall ( typeCheckCType )

 import GHC.Types.Id

 import GHC.Types.InlinePragma

 import GHC.Types.SourceFile

 import GHC.Types.SourceText

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

 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

     tc_item :: ClassOpItem -> TcM (Id, LHsBind GhcTc, Maybe Implication)

     tc_item (sel_id, dm_info)

       | Just (user_bind, bndr_loc, prags) <- findMethodBind (idName sel_id) binds prag_fn

                      dfun_ev_binds is_derived hs_sig_fn

                      spec_inst_prags prags

                      sel_id user_bind bndr_loc

       -- See Note [Implementation of Unsatisfiable constraints],

       -- in GHC.Tc.Errors, point (D).

       _ | (theta_id,unsat_msg) : _ <- unsat_thetas

                                          inst_tys sel_id

              ; unsat_id <- tcLookupKnownKeyId unsatisfiableIdKey

              -- Recall that unsatisfiable :: forall {rep} (msg :: ErrorMessage) (a :: TYPE rep). Unsatisfiable msg => a

       Just (dm_name, dm_spec) ->

         do { (meth_bind, inline_prags) <- mkDefMethBind inst_loc dfun_id clas sel_id dm_name dm_spec

            ; tcMethodBody (is_vanilla_dm dm_spec)

                           dfun_ev_binds is_derived hs_sig_fn

                           spec_inst_prags inline_prags

                           sel_id meth_bind inst_loc }

       -- No default method

       Nothing ->

         do { traceTc "tc_def: warn" (ppr sel_id)

                                        inst_tys sel_id

            ; dflags <- getDynFlags

             -- Add a binding whose RHS is an error

 tcMethodBody :: Bool   -- True <=> This is a vanilla default method

                        -- See (TRC5) in Note [Tracking needed EvIds]

                        --            in GHC.Tc.Solver.Solve

              -> TcEvBinds -> Bool

              -> HsSigFun

              -> [LTcSpecPrag] -> [LSig GhcRn]

              -> Id -> LHsBind GhcRn -> SrcSpan

              -> TcM (TcId, LHsBind GhcTc, Maybe Implication)

              dfun_ev_binds is_derived

              sig_fn spec_inst_prags prags

              sel_id (L bind_loc meth_bind) bndr_loc

     do { traceTc "tcMethodBody" (ppr sel_id <+> ppr (idType sel_id) $$ ppr bndr_loc)

        ; let skol_info = MethSkol meth_name is_vanilla_dm

        ; (global_meth_id, local_meth_id) <- setSrcSpan bndr_loc $

                                                       inst_tys sel_id

        ; let lm_bind = meth_bind { fun_id = L (noAnnSrcSpan bndr_loc)

                                 -- they are all for meth_id

 ------------------------

           -> [TcType] -> Id -> TcM (TcId, TcId)

              -- returns (poly_id, local_id), but ignoring any instance signature

              -- See Note [Instance method signatures]

   = do  { poly_meth_name  <- newName (mkClassOpAuxOcc sel_occ)

         ; local_meth_name <- newName sel_occ

                   -- Base the local_meth_name on the selector name, because

                   -- type errors from tcMethodBody come from here

               local_meth_id = mkLocalId local_meth_name ManyTy local_meth_ty

         ; return (poly_meth_id, local_meth_id) }

 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

           -- 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_complete_match_env :: CompleteMatches,

         -- ^ The complete matches for all /home-package/ modules;

           , 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 = []

         --   - the [CbvMark] is always empty (and ignored) until after Tidy

         --     for ids from the current module

         --   - If non-empty, at least is isMarkedCbbv; see (CBV2)

 data RecSelInfo

   = RSI { rsi_def   :: [ConLike]   -- Record selector defined for these

                                            ppWhen is_naughty (text "(naughty)")

    pp CoVarId                 = text "CoVarId"

    pp (JoinId arity marks)    = text "JoinId" <> parens (int arity) <> parens (ppr marks)

 {-

 ************************************************************************

 True

 "Foo (T' a) instance"

 (0,"defMeth","defMeth = const \"class default\"")

 (0,"defMeth","defMeth = const \"Foo (T' a) instance\"")

 (0,"defMeth'","defMeth' = const \"class default\"")