import GHC.Data.TrieMap

 import GHC.Core.Map.Type

 import GHC.Core

 import GHC.Core.Type

 import GHC.Types.Tickish

 import GHC.Types.Var

 eqDeBruijnExpr :: DeBruijn CoreExpr -> DeBruijn CoreExpr -> Bool

 eqDeBruijnExpr (D env1 e1) (D env2 e2) = go e1 e2 where

     go (Tick n1 e1) (Tick n2 e2)

       =  eqDeBruijnTickish (D env1 n1) (D env2 n2)

       && go e1 e2

 eqCoreExpr :: CoreExpr -> CoreExpr -> Bool

 eqCoreExpr e1 e2 = eqDeBruijnExpr (deBruijnize e1) (deBruijnize e2)

 -}

 {- Note [Alpha-equality for let-bindings]

    TypeMapG, CoercionMapG,

    DeBruijn(..), deBruijnize, eqDeBruijnType, eqDeBruijnVar,

    BndrMap, xtBndr, lkBndr,

    VarMap, xtVar, lkVar, lkDFreeVar, xtDFreeVar,

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

 -}

 newtype CoercionMap a = CoercionMap (CoercionMapG a)

 -- TODO(22292): derive

 instance Functor CoercionMap where

 type CoercionMapG = GenMap CoercionMapX

 newtype CoercionMapX a = CoercionMapX (TypeMapX a)

 -- TODO(22292): derive

 instance Functor CoercionMapX where

   filterTM f (CoercionMapX core_tm) = CoercionMapX (filterTM f core_tm)

   mapMaybeTM f (CoercionMapX core_tm) = CoercionMapX (mapMaybeTM f core_tm)

 lkC :: DeBruijn Coercion -> CoercionMapX a -> Maybe a

 lkC (D env co) (CoercionMapX core_tm) = lkT (D env $ coercionType co)

                                         core_tm

 xtC (D env co) f (CoercionMapX m)

   = CoercionMapX (xtT (D env $ coercionType co) f m)

 {-

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

 *                                                                      *

 -- but it is strictly internal to this module.  If you are including a 'TypeMap'

 -- inside another 'TrieMap', this is the type you want. Note that this

 -- lookup does not do a kind-check. Thus, all keys in this map must have

 type TypeMapG = GenMap TypeMapX

 -- | @TypeMapX a@ is the base map from @DeBruijn Type@ to @a@, but without the

    filterTM = filterT

    mapMaybeTM = mpT

 -- | An equality relation between two 'Type's (known below as @t1 :: k2@

 -- and @t2 :: k2@)

 data TypeEquality = TNEQ -- ^ @t1 /= t2@

     liftEquality :: Bool -> TypeEquality

     liftEquality False = TNEQ

     hasCast :: TypeEquality -> TypeEquality

     hasCast TEQ = TEQX

                  go (D (extendCME env tv) ty) (D (extendCME env' tv') ty')

           (CoercionTy {}, CoercionTy {})

               -> TEQ

     -- These bangs make 'gos' strict in the CMEnv, which in turn

     -- keeps the CMEnv unboxed across the go/gos mutual recursion

                                       gos e1 e2 tys1 tys2

     gos _  _  _          _          = TNEQ

 eqDeBruijnVar :: DeBruijn Var -> DeBruijn Var -> Bool

 eqDeBruijnVar (D env1 v1) (D env2 v2) =

     case (lookupCME env1 v1, lookupCME env2 v2) of

         (Nothing, Nothing) -> v1 == v2

         _ -> False

 instance {-# OVERLAPPING #-}

          Outputable a => Outputable (TypeMapG a) where

   ppr m = text "TypeMap elts" <+> ppr (foldTM (:) m [])

   filterTM f (LooseTypeMap m) = LooseTypeMap (filterTM f m)

   mapMaybeTM f (LooseTypeMap m) = LooseTypeMap (mapMaybeTM f m)

 {-

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

 *                                                                      *

   | otherwise

   = (env_body', (out_id'', out_rhs))

   where

     (cse_done, out_rhs)  = try_for_cse env_rhs in_rhs

     out_id'' | cse_done  = zapStableUnfolding $

                            delayInlining toplevel out_id'

       }

 instance Outputable SimplFloats where

     = text "SimplFloats"

       <+> braces (vcat [ text "lets: " <+> ppr lf

                        , text "joins:" <+> ppr jf

 emptyFloats :: SimplEnv -> SimplFloats

 emptyFloats env

 -- This function is called inside `exprIsTrivial` so it needs to be

 -- pretty efficient.  It should return False quickly on a big coercion;

 -- it should /not/ traverse the big coercion!

 coercionIsSmall co

 coercion_is_small :: Coercion -> Int# -> Int#

 coercion_is_small co n = go co n

 Note [Compressed TrieMap]

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

 The GenMap constructor augments TrieMaps with leaf compression.  This helps

 solve the performance problem detailed in #9960: suppose we have a handful

 H of entries in a TrieMap, each with a very large key, size K. If you fold over

                                 m_cmm_infos

     tag_sigs = fromMaybe mempty m_stg_infos

       | let not_caffy = elemNameSet nm non_cafs

       , let mb_lf_info = lookupNameEnv lf_infos nm

       , let sig = lookupNameEnv tag_sigs nm

      return (Case scrut' case_bndr' (coreAltsType alts') alts')

 tcIfaceExpr (IfaceLet (IfaceNonRec (IfLetBndr fs ty info ji) rhs) body)

   = do  { name    <- newIfaceName (mkVarOccFS (ifLclNameFS fs))

         ; ty'     <- tcIfaceType ty

         ; id_info <- tcIdInfo False {- Don't ignore prags; we are inside one! -}

                               NotTopLevel name ty' info

         ; let id = mkLocalIdWithInfo name ManyTy ty' id_info

         ; rhs' <- tcIfaceExpr rhs

         ; body' <- extendIfaceIdEnv [id] (tcIfaceExpr body)

         ; return (Let (NonRec id rhs') body') }

   | isCoVarType ty = mkLocalCoVar name   ty

   | otherwise      = mkLocalId    name w ty

 mkLocalIdWithInfo :: HasDebugCallStack => Name -> Mult -> Type -> IdInfo -> Id

 mkLocalIdWithInfo name w ty info =

   Var.mkLocalVar VanillaId name w (assert (not (isCoVarType ty)) ty) info

         -- Note [Free type variables]