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

 See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable for an overview.

 Note [Type substitution]

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

 import GHC.Types.Unique.Supply ( UniqueTag(..) )

 import Control.Monad

 import GHC.Unit.Module

 {-

         -- so that overloaded functions have all their dictionary lambdas manifest

         runWhen do_specialise CoreDoSpecialising,

                 { floatOutLambdas     = Just 0

                 , floatOutConstants   = True

                 , floatOutOverSatApps = False

                 , floatToTopLevelOnly = False

                 , floatJoinsToTop     = False  -- Initially, don't float join points at all

                 -- I have no idea why, but not floating constants to

                 -- top level is very bad in some cases.

                 --

 import GHC.Types.Literal      ( litIsTrivial )

 import GHC.Types.Demand       ( DmdSig, prependArgsDmdSig )

 import GHC.Types.Cpr          ( CprSig, prependArgsCprSig )

 import GHC.Types.Name.Occurrence ( occNameFS )

 import GHC.Types.Unique       ( hasKey )

 import GHC.Types.Tickish      ( tickishIsCode )

     find [] _ _ = []

     find (implic:implics) seen_eqs tv

        | tv `elem` ic_skols implic

        , seen_eqs

        = map fst prs

        | otherwise

   , isTyVarClassPred pred   -- Don't suggest adding (Eq T) to the context, say

   , (skol:skols) <- usefulContext implics pred

   , let what | null skols

              = text "\"required\""

              | otherwise

              = empty

       | implausible_info (ic_info ic) = True

       | otherwise                     = False

     implausible_info _                             = False

     -- Do not suggest adding constraints to an *inferred* type signature

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

 tidySkolemInfoAnon :: TidyEnv -> SkolemInfoAnon -> SkolemInfoAnon

 tidySkolemInfoAnon env (DerivSkol ty)         = DerivSkol (tidyType env ty)

 tidySkolemInfoAnon env (UnifyForAllSkol ty)   = UnifyForAllSkol (tidyType env ty)

 tidySkolemInfoAnon _   info                   = info

             -> TcType -> [(Name,TcTyVar)] -> SkolemInfoAnon

 -- We need to take special care when tidying SigSkol

 -- See Note [SigSkol SkolemInfo] in "GHC.Tc.Types.Origin"

   where

     tv_prs' = mapSnd (tidyTyCoVarOcc env) tv_prs

     inst_env = mkNameEnv tv_prs'

   , SuggestUnliftedTypes(..)

   , DataSort(..), ppDataSort

   , AllowedDataResKind(..)

   , SuggestPartialTypeSignatures(..)

   , suggestPartialTypeSignatures

   , DeriveInstanceErrReason(..)

     Test cases: rename/should_fail/RnStaticPointersFail01

                 rename/should_fail/RnStaticPointersFail03

   -}

   {-| TcRnUselessTypeable is a warning (controlled by -Wderiving-typeable) that

       occurs when trying to derive an instance of the 'Typeable' class. Deriving

   | AnyBoxedKind

   | LiftedKind

 data SuggestPartialTypeSignatures

   = YesSuggestPartialTypeSignatures

   | NoSuggestPartialTypeSignatures

   | otherwise

   = givens

   where

 -- | An error reported after constraint solving.

         TcTypeEnv, TcBinderStack, TcBinder(..),

         TcTyThing(..), tcTyThingTyCon_maybe,

         PromotionErr(..),

         SelfBootInfo(..), bootExports,

         tcTyThingCategory, pprTcTyThingCategory,

         peCategory, pprPECategory,

   -- * TcTyThing

   , TcTyThing(..)

   , IdBindingInfo(..)

   , ClosedTypeId

   , tcTyThingCategory

   , tcTyThingTyCon_maybe

 import GHC.Types.SrcLoc

 import GHC.Types.Name

 import GHC.Types.TyThing

 import GHC.Hs.Extension ( GhcRn )

 import Language.Haskell.Syntax.Type ( LHsSigWcType )

 -}

 instance Outputable IdBindingInfo where

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

 pprTcTyThingCategory :: TcTyThing -> SDoc

 -- So it doesn't matter much if its's incomplete

 checkSkolInfoAnon sk1 sk2 = go sk1 sk2

   where

                                                    and (zipWith eq_pr ids1 ids2)

     go (SigTypeSkol cx1)    (SigTypeSkol cx2)    = cx1==cx2

             -- a programmer-supplied type signature

             -- Location of the binding site is on the TyVar

             -- See Note [SigSkol SkolemInfo]

        UserTypeCtxt        -- What sort of signature

        TcType              -- Original type signature (before skolemisation)

        [(Name,TcTyVar)]    -- Maps the original name of the skolemised tyvar

                            -- to its instantiated version

   | InferSkol

        [(Name,TcType)]  -- We have inferred a type for these (mutually recursive)

                         -- polymorphic Ids, and are now checking that their RHS

                         -- constraints are satisfied.

 pprSkolInfo :: SkolemInfoAnon -> SDoc

 -- Complete the sentence "is a rigid type variable bound by..."

 pprSkolInfo (SigTypeSkol cx)  = pprUserTypeCtxt cx

 pprSkolInfo (ForAllSkol tvs)  = text "an explicit forall" <+> ppr tvs

 pprSkolInfo (IPSkol ips)      = text "the implicit-parameter binding" <> plural ips <+> text "for"

 pprSkolInfo (SpecESkol name)  = text "a SPECIALISE pragma for" <+> quotes (ppr name)

 pprSkolInfo (PatSkol cl mc)   = sep [ pprPatSkolInfo cl

                                     , text "in" <+> pprMatchContext mc ]

                                    2 (vcat [ ppr name <+> dcolon <+> ppr ty

                                            | (name,ty) <- ids ])

 pprSkolInfo (UnifyForAllSkol ty)  = text "the type" <+> ppr ty

 -}

 isStaticSkolInfo :: SkolemInfoAnon -> Bool

 {- *********************************************************************

 import GHC.Data.FastString

 import GHC.Data.List.SetOps

 import GHC.Types.SrcLoc

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

 -- Does not extend the TcBinderStack

 tcExtendRecIds pairs thing_inside

   = tc_extend_local_env NotTopLevel

           | (name, let_id) <- pairs ] $

     thing_inside

 tcExtendSigIds :: TopLevelFlag -> [TcId] -> TcM a -> TcM a

 -- Used for binding the Ids that have a complete user type signature

                               , tct_info = info })

           | id <- sig_ids

           , let closed = isTypeClosedLetBndr id

      thing_inside

                   -> [Scaled TcId] -> TcM a

                   -> TcM a

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

           | Scaled _ id <- ids ] $

     foldr tcCheckUsage thing_inside ids

 tcExtendIdEnv :: [TcId] -> TcM a -> TcM a

 -- For lambda-bound and case-bound Ids

 zonkSkolemInfo (SkolemInfo u sk) = SkolemInfo u <$> zonkSkolemInfoAnon sk

 zonkSkolemInfoAnon :: SkolemInfoAnon -> ZonkM SkolemInfoAnon

   where

     do_one (n, ty) = do { ty' <- zonkTcType ty; return (n, ty') }

 zonkSkolemInfoAnon skol_info = return skol_info

   = do  { new_binds <- mapM go binds

         ; return (HsValBinds x (XValBindsLR (HsVBG new_binds sigs))) }

   where

 zonkLocalBinds (HsIPBinds x (IPBinds dict_binds binds )) = do

     new_binds <- noBinders $ mapM (wrapLocZonkMA zonk_ip_bind) binds