noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,

     impossibleErrorIdKey, impossibleConstraintErrorIdKey,

     patErrorIdKey, voidPrimIdKey,

     unpackCStringUtf8IdKey, unpackCStringAppendUtf8IdKey, unpackCStringFoldrUtf8IdKey,

     unpackCStringIdKey, unpackCStringAppendIdKey, unpackCStringFoldrIdKey,

     typeErrorIdKey, divIntIdKey, modIntIdKey,

 rationalToDoubleIdKey  = mkPreludeMiscIdUnique 133

 seqHashKey             = mkPreludeMiscIdUnique 134

 coerceKey :: Unique

 coerceKey                     = mkPreludeMiscIdUnique 157

         -- * Error Ids

         mkRuntimeErrorApp, mkImpossibleExpr, mkAbsentErrorApp, errorIds,

         nON_EXHAUSTIVE_GUARDS_ERROR_ID, nO_METHOD_BINDING_ERROR_ID,

         pAT_ERROR_ID, rEC_SEL_ERROR_ID,

         tYPE_ERROR_ID, aBSENT_SUM_FIELD_ERROR_ID

       nO_METHOD_BINDING_ERROR_ID,

       pAT_ERROR_ID,

       rEC_CON_ERROR_ID,

       rEC_SEL_ERROR_ID,

       iMPOSSIBLE_ERROR_ID, iMPOSSIBLE_CONSTRAINT_ERROR_ID,

       aBSENT_ERROR_ID,  aBSENT_CONSTRAINT_ERROR_ID,

       tYPE_ERROR_ID   -- Used with Opt_DeferTypeErrors, see #10284

       ]

 nonExhaustiveGuardsErrorName, noMethodBindingErrorName :: Name

 typeErrorName :: Name

 absentSumFieldErrorName :: Name

 recSelErrorName     = err_nm "recSelError"     recSelErrorIdKey     rEC_SEL_ERROR_ID

 recConErrorName     = err_nm "recConError"     recConErrorIdKey     rEC_CON_ERROR_ID

 patErrorName        = err_nm "patError"        patErrorIdKey        pAT_ERROR_ID

 typeErrorName       = err_nm "typeError"       typeErrorIdKey       tYPE_ERROR_ID

 err_nm :: String -> Unique -> Id -> Name

 err_nm str uniq id = mkWiredInIdName gHC_INTERNAL_CONTROL_EXCEPTION_BASE (fsLit str) uniq id

 pAT_ERROR_ID, nO_METHOD_BINDING_ERROR_ID, nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id

 tYPE_ERROR_ID, aBSENT_SUM_FIELD_ERROR_ID :: Id

 rEC_SEL_ERROR_ID                = mkRuntimeErrorId TypeLike recSelErrorName

 rEC_CON_ERROR_ID                = mkRuntimeErrorId TypeLike recConErrorName

 pAT_ERROR_ID                    = mkRuntimeErrorId TypeLike patErrorName

 nO_METHOD_BINDING_ERROR_ID      = mkRuntimeErrorId TypeLike noMethodBindingErrorName

 nON_EXHAUSTIVE_GUARDS_ERROR_ID  = mkRuntimeErrorId TypeLike nonExhaustiveGuardsErrorName

                          -- Use the equality proof to cast the selector Id to

                          -- type (r -> a), then use the newtype coercion to cast

                          -- it to a HasField dictionary.

                               [ evSelector modifier_id tvs evs `Cast` co ev2

                               , evSelector setter_id tvs evs `Cast` co ev1 

                               ]

                 pure (setter, modifier)

               Nothing -> do

                 binds@((setter, _), (modifier,_)) <- mkSetFieldBinds tycon fl

                 pure (setter, modifier)

      tc_inst_setfield_binds setter_id modifier_id

         -- Emit Typeable bindings

       ; tcg_env <- setGblEnv tcg_env $

                    mkTypeableBinds

       ; (tcg_env, recs_lie) <- setGblEnv tcg_env $

                    captureTopConstraints $

                    tcRecSetterBinds

       ; rec_ev_binds <- restoreEnvs (tcg_env, tcl_env) $ 

       ; let new_ev_binds = main_ev_binds `mappend` rec_ev_binds

 import GHC.Core.TyCo.Rep( Type(..), Coercion(..), MCoercion(..) )

 import GHC.Core.Multiplicity

 import GHC.Core.Predicate

 import GHC.Core.Class

 import GHC.Core.Type

 import GHC.Core.TyCon

 mkOneRecordSelector :: [ConLike] -> RecSelParent -> FieldLabel -> FieldSelectors

                     -> (Id, LHsBind GhcRn)

 mkOneRecordSelector all_cons idDetails fl has_sel

 mkRecordSelectorBind :: RecordBindBuilder (Id, LHsBind GhcRn)

   mk_sel_ty :: Type -> Type -> Type

       mkVisFunTyMany data_ty            $

         -- Record selectors are always typed with Many. We

         -- could improve on it in the case where all the

         -- fields in all the constructor have multiplicity Many.

       field_ty

       mkSimpleMatch match_ctxt

         (L loc [L loc (mk_sel_pat con)])

         (L loc (mkHsVar (L loc field_var)))

   where

     remove_binds (n, ((setter, _), (modifier, _))) = (flSelector n, (setter, modifier))

     get_ids_to_check [] = []

         setter : modifier : get_ids_to_check flds

     idDetails = RecSelData tycon

     mk_field_lbl prefix uniq =

         lbl = flLabel fl

         newOcc = mkOccNameFS varName (mkFastString prefix `mappend` field_label lbl)

     mk_binds cons_w_field rec_details ty_builder = do

       setter_fl <- mk_field_lbl "setter_" <$> newUnique

       let setter_bind = mkRecordSetterBind fl setter_fl all_cons cons_w_field rec_details ty_builder

       pure (setter_bind, modifier_bind)

 mkRecordSetterBind :: FieldLabel -> RecordBindBuilder (Id, LHsBind GhcRn)

       \_ field_var -> (genWildPat, genLHsVar field_var)

 mkRecordSetterType :: Type -> Type -> Type

     mkVisFunTyMany field_ty $

     mkVisFunTyMany data_ty data_ty

 mkRecordModifierBind :: FieldLabel -> RecordBindBuilder (Id, LHsBind GhcRn)

       let fld_nm = mk_set_fld_bind i fl

           expr = wrapGenSpan $ HsPar noExtField $ genLHsApp (genHsVar fun_var) (genLHsVar fld_nm)

       in (genVarPat fld_nm, expr)

 mkRecordModifierType :: Type -> Type -> Type

     mkVisFunTyMany (mkVisFunTyMany field_ty field_ty) $

     mkVisFunTyMany data_ty data_ty

     loc = noAnnSrcSpan (getSrcSpan setter_name)

       | fl == fld_lbl = on_fld i arg_var

       | otherwise =

           let fld_nm = mk_set_fld_bind i fld_lbl

     arg_var = mkInternalName (mkBuiltinUnique 1) occ_name loc

 mk_set_fld_bind i fld_lbl =

   mkInternalName (mkBuiltinUnique i)

     (nameOccName $ flSelector $ fld_lbl)

 type ConLikeWithField = ConLike

   FieldLabel -> [ConLike] -> [ConLikeWithField] -> IdDetails -> ((Type -> Type -> Type) -> Type) -> r

   Name -> HsMatchContext (LocatedN Name) -> ConLikeWithField -> LMatch GhcRn (LHsExpr GhcRn)

 collectFieldLabelInfo :: [ConLike] ->

                                                   -- A slight hack!

     sel_ty | is_naughty = \_ -> unitTy  -- See Note [Naughty record selectors]

                           mkForAllTys (tyVarSpecToBinders sel_tvbs) $

                           -- Urgh! See Note [The stupid context] in GHC.Core.DataCon

                           mkPhiTy (conLikeStupidTheta con1) $

                           mkPhiTy req_theta                 $

                           mk_ty data_ty field_ty

   (Type -> Type -> Type) ->

   FldBindMatchBuilder ->

   RecordBindBuilder (Id, LHsBind GhcRn)

   = (sel_id, L loc sel_bind)

   where

     sel_ty = ty_builder mk_ty

     -- We do this explicitly so that we get a nice error message that

     -- mentions this particular record selector

     deflt | all dealt_with all_cons = []

         -- Do not add a default case unless there are unmatched

         -- constructors.  We must take account of GADTs, else we

         inst_tys = dataConResRepTyArgs dc

     unit_rhs = mkLHsTupleExpr [] noExtField

 {-

 Note [Polymorphic selectors]

           -- they all have a non-empty gre_imp field.

         tcg_keep      :: TcRef NameSet,

         tcg_th_used :: TcRef Bool,

           -- ^ @True@ \<=> Template Haskell syntax used.

         -- ^ See Note [Generating fresh names for FFI wrappers]

     }

 -- NB: topModIdentity, not topModSemantic!

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

         finally,

         -- * Calls for GHC runtime

         impossibleError, impossibleConstraintError,

         nonExhaustiveGuardsError, patError, noMethodBindingError,

         typeError,

 -----

 -- See Note [Compiler error functions] in ghc-internal:GHC.Internal.Prim.Panic

   nonExhaustiveGuardsError, patError, noMethodBindingError

         :: Addr# -> a   -- All take a UTF8-encoded C string

 recSelError              s = throw (RecSelError ("No match in record selector "

                                                  ++ unpackCStringUtf8# s))  -- No location info unfortunately

 nonExhaustiveGuardsError s = throw (PatternMatchFail (untangle s "Non-exhaustive guards in"))

 recConError              s = throw (RecConError      (untangle s "Missing field in record construction"))

 noMethodBindingError     s = throw (NoMethodError    (untangle s "No instance nor default method for class operation"))