module GHC.Tc.Types.BasicTypes (
  -- * TcBinder
    TcBinderStack
  , TcId
  , TcBinder(..)

  -- * Signatures
  , TcSigFun, TcSigInfo(..), TcIdSig(..)
  , TcCompleteSig(..), TcPartialSig(..), TcPatSynSig(..)
  , TcIdSigInst(..)
  , isPartialSig, hasCompleteSig
  , tcSigInfoName, tcIdSigLoc, completeSigPolyId_maybe

  -- * TcTyThing
  , TcTyThing(..)
  , IdBindingInfo(..)
  , IsGroupClosed(..)
  , RhsNames
  , ClosedTypeId
  , tcTyThingCategory
  , tcTyThingTyCon_maybe
  , pprTcTyThingCategory
  ) where

import GHC.Prelude

import GHC.Tc.Types.Origin( UserTypeCtxt )
import GHC.Tc.Utils.TcType

import GHC.Types.Id
import GHC.Types.Basic
import GHC.Types.Var
import GHC.Types.SrcLoc
import GHC.Types.Name
import GHC.Types.TyThing
import GHC.Types.Name.Env
import GHC.Types.Name.Set

import GHC.Hs.Extension ( GhcRn )

import Language.Haskell.Syntax.Type ( LHsSigWcType )

import GHC.Tc.Errors.Types.PromotionErr (PromotionErr, peCategory)

import GHC.Core.TyCon  ( TyCon, tyConKind )
import GHC.Utils.Outputable
import GHC.Utils.Misc


---------------------------
-- The TcBinderStack
---------------------------

type TcBinderStack = [TcBinder]
type TcId = Id
   -- This is a stack of locally-bound ids and tyvars,
   --   innermost on top
   -- Used only in error reporting (relevantBindings in TcError),
   --   and in tidying
   -- We can't use the tcl_env type environment, because it doesn't
   --   keep track of the nesting order

data TcBinder
  = TcIdBndr
       TcId
       TopLevelFlag    -- Tells whether the binding is syntactically top-level
                       -- (The monomorphic Ids for a recursive group count
                       --  as not-top-level for this purpose.)

  | TcIdBndr_ExpType  -- Variant that allows the type to be specified as
                      -- an ExpType
       Name
       ExpType
       TopLevelFlag

  | TcTvBndr          -- e.g.   case x of P (y::a) -> blah
       Name           -- We bind the lexical name "a" to the type of y,
       TyVar          -- which might be an utterly different (perhaps
                      -- existential) tyvar

instance Outputable TcBinder where
   ppr :: TcBinder -> SDoc
ppr (TcIdBndr TcId
id TopLevelFlag
top_lvl)           = TcId -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcId
id SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
brackets (TopLevelFlag -> SDoc
forall a. Outputable a => a -> SDoc
ppr TopLevelFlag
top_lvl)
   ppr (TcIdBndr_ExpType Name
id ExpType
_ TopLevelFlag
top_lvl) = Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
id SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
brackets (TopLevelFlag -> SDoc
forall a. Outputable a => a -> SDoc
ppr TopLevelFlag
top_lvl)
   ppr (TcTvBndr Name
name TcId
tv)              = Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> TcId -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcId
tv

instance HasOccName TcBinder where
    occName :: TcBinder -> OccName
occName (TcIdBndr TcId
id TopLevelFlag
_)             = Name -> OccName
forall name. HasOccName name => name -> OccName
occName (TcId -> Name
idName TcId
id)
    occName (TcIdBndr_ExpType Name
name ExpType
_ TopLevelFlag
_) = Name -> OccName
forall name. HasOccName name => name -> OccName
occName Name
name
    occName (TcTvBndr Name
name TcId
_)           = Name -> OccName
forall name. HasOccName name => name -> OccName
occName Name
name

{- *********************************************************************
*                                                                      *
                Type signatures
*                                                                      *
********************************************************************* -}

-- These data types need to be here only because
-- GHC.Tc.Solver uses them, and GHC.Tc.Solver is fairly
-- low down in the module hierarchy

type TcSigFun  = Name -> Maybe TcSigInfo

-- TcSigInfo is simply the range of TcSigFun
data TcSigInfo = TcIdSig     TcIdSig
               | TcPatSynSig TcPatSynSig    -- For a pattern synonym

-- See Note [Complete and partial type signatures]
data TcIdSig  -- For an Id
  = TcCompleteSig TcCompleteSig
  | TcPartialSig  TcPartialSig

data TcCompleteSig  -- A complete signature with no wildcards,
                    -- so the complete polymorphic type is known.
  = CSig { TcCompleteSig -> TcId
sig_bndr :: TcId          -- The polymorphic Id with that type

         , TcCompleteSig -> UserTypeCtxt
sig_ctxt :: UserTypeCtxt  -- In the case of type-class default methods,
                                     -- the Name in the FunSigCtxt is not the same
                                     -- as the TcId; the former is 'op', while the
                                     -- latter is '$dmop' or some such

         , TcCompleteSig -> SrcSpan
sig_loc  :: SrcSpan       -- Location of the type signature
         }

data TcPartialSig  -- A partial type signature (i.e. includes one or more
                   -- wildcards). In this case it doesn't make sense to give
                   -- the polymorphic Id, because we are going to /infer/ its
                   -- type, so we can't make the polymorphic Id ab-initio
  = PSig { TcPartialSig -> Name
psig_name  :: Name   -- Name of the function; used when report wildcards
         , TcPartialSig -> LHsSigWcType GhcRn
psig_hs_ty :: LHsSigWcType GhcRn  -- The original partial signature in
                                             -- HsSyn form
         , TcPartialSig -> UserTypeCtxt
psig_ctxt  :: UserTypeCtxt
         , TcPartialSig -> SrcSpan
psig_loc   :: SrcSpan            -- Location of the type signature
         }

data TcPatSynSig
  = PatSig {
        TcPatSynSig -> Name
patsig_name           :: Name,
        TcPatSynSig -> [InvisTVBinder]
patsig_implicit_bndrs :: [InvisTVBinder], -- Implicitly-bound kind vars (Inferred) and
                                                  -- implicitly-bound type vars (Specified)
          -- See Note [The pattern-synonym signature splitting rule] in GHC.Tc.TyCl.PatSyn
        TcPatSynSig -> [InvisTVBinder]
patsig_univ_bndrs     :: [InvisTVBinder], -- Bound by explicit user forall
        TcPatSynSig -> TcThetaType
patsig_req            :: TcThetaType,
        TcPatSynSig -> [InvisTVBinder]
patsig_ex_bndrs       :: [InvisTVBinder], -- Bound by explicit user forall
        TcPatSynSig -> TcThetaType
patsig_prov           :: TcThetaType,
        TcPatSynSig -> TcSigmaType
patsig_body_ty        :: TcSigmaType
    }

{- Note [Complete and partial type signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A type signature is partial when it contains one or more wildcards
(= type holes).  The wildcard can either be:
* A (type) wildcard occurring in sig_theta or sig_tau. These are
  stored in sig_wcs.
      f :: Bool -> _
      g :: Eq _a => _a -> _a -> Bool
* Or an extra-constraints wildcard, stored in sig_cts:
      h :: (Num a, _) => a -> a

A type signature is a complete type signature when there are no
wildcards in the type signature, i.e. iff sig_wcs is empty and
sig_extra_cts is Nothing.
-}

data TcIdSigInst
  = TISI { TcIdSigInst -> TcIdSig
sig_inst_sig :: TcIdSig

         , TcIdSigInst -> [(Name, InvisTVBinder)]
sig_inst_skols :: [(Name, InvisTVBinder)]
               -- Instantiated type and kind variables, TyVarTvs
               -- The Name is the Name that the renamer chose;
               --   but the TcTyVar may come from instantiating
               --   the type and hence have a different unique.
               -- No need to keep track of whether they are truly lexically
               --   scoped because the renamer has named them uniquely
               -- See Note [Binding scoped type variables] in GHC.Tc.Gen.Sig
               --
               -- NB: The order of sig_inst_skols is irrelevant
               --     for a CompleteSig, but for a PartialSig see
               --     Note [Quantified variables in partial type signatures]

         , TcIdSigInst -> TcThetaType
sig_inst_theta  :: TcThetaType
               -- Instantiated theta.  In the case of a
               -- PartialSig, sig_theta does not include
               -- the extra-constraints wildcard

         , TcIdSigInst -> TcSigmaType
sig_inst_tau :: TcSigmaType   -- Instantiated tau
               -- See Note [sig_inst_tau may be polymorphic]

         -- Relevant for partial signature only
         , TcIdSigInst -> [(Name, TcId)]
sig_inst_wcs   :: [(Name, TcTyVar)]
               -- Like sig_inst_skols, but for /named/ wildcards (_a etc).
               -- The named wildcards scope over the binding, and hence
               -- their Names may appear in type signatures in the binding

         , TcIdSigInst -> Maybe TcSigmaType
sig_inst_wcx   :: Maybe TcType
               -- Extra-constraints wildcard to fill in, if any
               -- If this exists, it is surely of the form (meta_tv |> co)
               -- (where the co might be reflexive). This is filled in
               -- only from the return value of GHC.Tc.Gen.HsType.tcAnonWildCardOcc
         }

{- Note [sig_inst_tau may be polymorphic]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Note that "sig_inst_tau" might actually be a polymorphic type,
if the original function had a signature like
   forall a. Eq a => forall b. Ord b => ....
But that's ok: tcFunBindMatches (called by tcRhs) can deal with that
It happens, too!  See Note [Polymorphic methods] in GHC.Tc.TyCl.Class.

Note [Quantified variables in partial type signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
   f :: forall a b. _ -> a -> _ -> b
   f (x,y) p q = q

Then we expect f's final type to be
  f :: forall {x,y}. forall a b. (x,y) -> a -> b -> b

Note that x,y are Inferred, and can't be use for visible type
application (VTA).  But a,b are Specified, and remain Specified
in the final type, so we can use VTA for them.  (Exception: if
it turns out that a's kind mentions b we need to reorder them
with scopedSort.)

The sig_inst_skols of the TISI from a partial signature records
that original order, and is used to get the variables of f's
final type in the correct order.


Note [Wildcards in partial signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The wildcards in psig_wcs may stand for a type mentioning
the universally-quantified tyvars of psig_ty

E.g.  f :: forall a. _ -> a
      f x = x
We get sig_inst_skols = [a]
       sig_inst_tau   = _22 -> a
       sig_inst_wcs   = [_22]
and _22 in the end is unified with the type 'a'

Moreover the kind of a wildcard in sig_inst_wcs may mention
the universally-quantified tyvars sig_inst_skols
e.g.   f :: t a -> t _
Here we get
   sig_inst_skols = [k:*, (t::k ->*), (a::k)]
   sig_inst_tau   = t a -> t _22
   sig_inst_wcs   = [ _22::k ]
-}

instance Outputable TcSigInfo where
  ppr :: TcSigInfo -> SDoc
ppr (TcIdSig TcIdSig
sig)     = TcIdSig -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSig
sig
  ppr (TcPatSynSig TcPatSynSig
sig) = TcPatSynSig -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcPatSynSig
sig

instance Outputable TcIdSig where
  ppr :: TcIdSig -> SDoc
ppr (TcCompleteSig TcCompleteSig
sig) = TcCompleteSig -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcCompleteSig
sig
  ppr (TcPartialSig TcPartialSig
sig)  = TcPartialSig -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcPartialSig
sig

instance Outputable TcCompleteSig where
  ppr :: TcCompleteSig -> SDoc
ppr (CSig { sig_bndr :: TcCompleteSig -> TcId
sig_bndr = TcId
bndr })
      = TcId -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcId
bndr SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> TcSigmaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcId -> TcSigmaType
idType TcId
bndr)

instance Outputable TcPartialSig where
  ppr :: TcPartialSig -> SDoc
ppr (PSig { psig_name :: TcPartialSig -> Name
psig_name = Name
name, psig_hs_ty :: TcPartialSig -> LHsSigWcType GhcRn
psig_hs_ty = LHsSigWcType GhcRn
hs_ty })
      = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"[partial signature]" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsSigType GhcRn))
-> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsSigWcType GhcRn
HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsSigType GhcRn))
hs_ty

instance Outputable TcPatSynSig where
  ppr :: TcPatSynSig -> SDoc
ppr (PatSig { patsig_name :: TcPatSynSig -> Name
patsig_name = Name
name}) = Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name

instance Outputable TcIdSigInst where
  ppr :: TcIdSigInst -> SDoc
ppr (TISI { sig_inst_sig :: TcIdSigInst -> TcIdSig
sig_inst_sig = TcIdSig
sig, sig_inst_skols :: TcIdSigInst -> [(Name, InvisTVBinder)]
sig_inst_skols = [(Name, InvisTVBinder)]
skols
            , sig_inst_theta :: TcIdSigInst -> TcThetaType
sig_inst_theta = TcThetaType
theta, sig_inst_tau :: TcIdSigInst -> TcSigmaType
sig_inst_tau = TcSigmaType
tau })
      = SDoc -> Int -> SDoc -> SDoc
hang (TcIdSig -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSig
sig) Int
2 ([SDoc] -> SDoc
forall doc. IsDoc doc => [doc] -> doc
vcat [ [(Name, InvisTVBinder)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(Name, InvisTVBinder)]
skols, TcThetaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcThetaType
theta SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
darrow SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> TcSigmaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcSigmaType
tau ])

isPartialSig :: TcIdSigInst -> Bool
isPartialSig :: TcIdSigInst -> Bool
isPartialSig (TISI { sig_inst_sig :: TcIdSigInst -> TcIdSig
sig_inst_sig = TcPartialSig {} }) = Bool
True
isPartialSig TcIdSigInst
_                                         = Bool
False

-- | No signature or a partial signature
hasCompleteSig :: TcSigFun -> Name -> Bool
hasCompleteSig :: TcSigFun -> Name -> Bool
hasCompleteSig TcSigFun
sig_fn Name
name
  = case TcSigFun
sig_fn Name
name of
      Just (TcIdSig (TcCompleteSig {})) -> Bool
True
      Maybe TcSigInfo
_                                 -> Bool
False

tcSigInfoName :: TcSigInfo -> Name
tcSigInfoName :: TcSigInfo -> Name
tcSigInfoName (TcIdSig (TcCompleteSig TcCompleteSig
sig)) = TcId -> Name
idName (TcCompleteSig -> TcId
sig_bndr TcCompleteSig
sig)
tcSigInfoName (TcIdSig (TcPartialSig  TcPartialSig
sig)) = TcPartialSig -> Name
psig_name TcPartialSig
sig
tcSigInfoName (TcPatSynSig TcPatSynSig
sig)             = TcPatSynSig -> Name
patsig_name TcPatSynSig
sig

tcIdSigLoc :: TcIdSig -> SrcSpan
tcIdSigLoc :: TcIdSig -> SrcSpan
tcIdSigLoc (TcCompleteSig TcCompleteSig
sig) = TcCompleteSig -> SrcSpan
sig_loc TcCompleteSig
sig
tcIdSigLoc (TcPartialSig  TcPartialSig
sig) = TcPartialSig -> SrcSpan
psig_loc TcPartialSig
sig

completeSigPolyId_maybe :: TcSigInfo -> Maybe TcId
completeSigPolyId_maybe :: TcSigInfo -> Maybe TcId
completeSigPolyId_maybe (TcIdSig (TcCompleteSig TcCompleteSig
sig)) = TcId -> Maybe TcId
forall a. a -> Maybe a
Just (TcCompleteSig -> TcId
sig_bndr TcCompleteSig
sig)
completeSigPolyId_maybe TcSigInfo
_                             = Maybe TcId
forall a. Maybe a
Nothing

{- *********************************************************************
*                                                                      *
             TcTyThing
*                                                                      *
********************************************************************* -}

-- | A typecheckable thing available in a local context.  Could be
-- 'AGlobal' 'TyThing', but also lexically scoped variables, etc.
-- See "GHC.Tc.Utils.Env" for how to retrieve a 'TyThing' given a 'Name'.
data TcTyThing
  = AGlobal TyThing             -- Used only in the return type of a lookup

  | ATcId           -- Ids defined in this module; may not be fully zonked
      { TcTyThing -> TcId
tct_id   :: Id
      , TcTyThing -> IdBindingInfo
tct_info :: IdBindingInfo   -- See Note [Meaning of IdBindingInfo]
      }

  | ATyVar  Name TcTyVar   -- See Note [Type variables in the type environment]

  | ATcTyCon TyCon   -- Used temporarily, during kind checking, for the
                     -- tycons and classes in this recursive group
                     -- The TyCon is always a TcTyCon.  Its kind
                     -- can be a mono-kind or a poly-kind; in TcTyClsDcls see
                     -- Note [Type checking recursive type and class declarations]

  | APromotionErr PromotionErr

-- | Matches on either a global 'TyCon' or a 'TcTyCon'.
tcTyThingTyCon_maybe :: TcTyThing -> Maybe TyCon
tcTyThingTyCon_maybe :: TcTyThing -> Maybe TyCon
tcTyThingTyCon_maybe (AGlobal (ATyCon TyCon
tc)) = TyCon -> Maybe TyCon
forall a. a -> Maybe a
Just TyCon
tc
tcTyThingTyCon_maybe (ATcTyCon TyCon
tc_tc)      = TyCon -> Maybe TyCon
forall a. a -> Maybe a
Just TyCon
tc_tc
tcTyThingTyCon_maybe TcTyThing
_                     = Maybe TyCon
forall a. Maybe a
Nothing

instance Outputable TcTyThing where     -- Debugging only
   ppr :: TcTyThing -> SDoc
ppr (AGlobal TyThing
g)      = TyThing -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyThing
g
   ppr elt :: TcTyThing
elt@(ATcId {})   = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"Identifier" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<>
                          SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
brackets (TcId -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcTyThing -> TcId
tct_id TcTyThing
elt) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc
dcolon
                                 SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> TcSigmaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcId -> TcSigmaType
varType (TcTyThing -> TcId
tct_id TcTyThing
elt)) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc
forall doc. IsLine doc => doc
comma
                                 SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> IdBindingInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcTyThing -> IdBindingInfo
tct_info TcTyThing
elt))
   ppr (ATyVar Name
n TcId
tv)    = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"Type variable" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc -> SDoc
quotes (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
n) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
forall doc. IsLine doc => doc
equals SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> TcId -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcId
tv
                            SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> TcSigmaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcId -> TcSigmaType
varType TcId
tv)
   ppr (ATcTyCon TyCon
tc)    = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"ATcTyCon" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> TyCon -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyCon
tc SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> TcSigmaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyCon -> TcSigmaType
tyConKind TyCon
tc)
   ppr (APromotionErr PromotionErr
err) = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"APromotionErr" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> PromotionErr -> SDoc
forall a. Outputable a => a -> SDoc
ppr PromotionErr
err

-- | IdBindingInfo describes how an Id is bound.
--
-- It is used for the following purposes:
-- a) for static forms in 'GHC.Tc.Gen.Expr.checkClosedInStaticForm' and
-- b) to figure out when a nested binding can be generalised,
--    in 'GHC.Tc.Gen.Bind.decideGeneralisationPlan'.
--
data IdBindingInfo -- See Note [Meaning of IdBindingInfo]
    = NotLetBound
    | ClosedLet
    | NonClosedLet
         RhsNames        -- Used for (static e) checks only
         ClosedTypeId    -- Used for generalisation checks
                         -- and for (static e) checks

-- | IsGroupClosed describes a group of mutually-recursive bindings
data IsGroupClosed
  = IsGroupClosed
      (NameEnv RhsNames)  -- Free var info for the RHS of each binding in the group
                          -- Used only for (static e) checks

      ClosedTypeId        -- True <=> all the free vars of the group are
                          --          imported or ClosedLet or
                          --          NonClosedLet with ClosedTypeId=True.
                          --          In particular, no tyvars, no NotLetBound

type RhsNames = NameSet   -- Names of variables, mentioned on the RHS of
                          -- a definition, that are not Global or ClosedLet

type ClosedTypeId = Bool
  -- See Note [Meaning of IdBindingInfo]

{- Note [Meaning of IdBindingInfo]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
NotLetBound means that
  the Id is not let-bound (e.g. it is bound in a
  lambda-abstraction or in a case pattern)

ClosedLet means that
   - The Id is let-bound,
   - Any free term variables are also Global or ClosedLet
   - Its type has no free variables (NB: a top-level binding subject
     to the MR might have free vars in its type)
   These ClosedLets can definitely be floated to top level; and we
   may need to do so for static forms.

   Property:   ClosedLet
             is equivalent to
               NonClosedLet emptyNameSet True

(NonClosedLet (fvs::RhsNames) (cl::ClosedTypeId)) means that
   - The Id is let-bound

   - The fvs::RhsNames contains the free names of the RHS,
     excluding Global and ClosedLet ones.

   - For the ClosedTypeId field see Note [Bindings with closed types: ClosedTypeId]

For (static e) to be valid, we need for every 'x' free in 'e',
that x's binding is floatable to the top level.  Specifically:
   * x's RhsNames must be empty
   * x's type has no free variables
See Note [Grand plan for static forms] in "GHC.Iface.Tidy.StaticPtrTable".
This test is made in GHC.Tc.Gen.Expr.checkClosedInStaticForm.
Actually knowing x's RhsNames (rather than just its emptiness
or otherwise) is just so we can produce better error messages

Note [Bindings with closed types: ClosedTypeId]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider

  f x = let g ys = map not ys
        in ...

Can we generalise 'g' under the OutsideIn algorithm?  Yes,
because all g's free variables are top-level; that is they themselves
have no free type variables, and it is the type variables in the
environment that makes things tricky for OutsideIn generalisation.

Here's the invariant:
   If an Id has ClosedTypeId=True (in its IdBindingInfo), then
   the Id's type is /definitely/ closed (has no free type variables).
   Specifically,
       a) The Id's actual type is closed (has no free tyvars)
       b) Either the Id has a (closed) user-supplied type signature
          or all its free variables are Global/ClosedLet
             or NonClosedLet with ClosedTypeId=True.
          In particular, none are NotLetBound.

Why is (b) needed?   Consider
    \x. (x :: Int, let y = x+1 in ...)
Initially x::alpha.  If we happen to typecheck the 'let' before the
(x::Int), y's type will have a free tyvar; but if the other way round
it won't.  So we treat any let-bound variable with a free
non-let-bound variable as not ClosedTypeId, regardless of what the
free vars of its type actually are.

But if it has a signature, all is well:
   \x. ...(let { y::Int; y = x+1 } in
           let { v = y+2 } in ...)...
Here the signature on 'v' makes 'y' a ClosedTypeId, so we can
generalise 'v'.

Note that:

  * A top-level binding may not have ClosedTypeId=True, if it suffers
    from the MR

  * A nested binding may be closed (eg 'g' in the example we started
    with). Indeed, that's the point; whether a function is defined at
    top level or nested is orthogonal to the question of whether or
    not it is closed.

  * A binding may be non-closed because it mentions a lexically scoped
    *type variable*  Eg
        f :: forall a. blah
        f x = let g y = ...(y::a)...

Under OutsideIn we are free to generalise an Id all of whose free
variables have ClosedTypeId=True (or imported).  This is an extension
compared to the JFP paper on OutsideIn, which used "top-level" as a
proxy for "closed".  (It's not a good proxy anyway -- the MR can make
a top-level binding with a free type variable.)

Note [Type variables in the type environment]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The type environment has a binding for each lexically-scoped
type variable that is in scope.  For example

  f :: forall a. a -> a
  f x = (x :: a)

  g1 :: [a] -> a
  g1 (ys :: [b]) = head ys :: b

  g2 :: [Int] -> Int
  g2 (ys :: [c]) = head ys :: c

* The forall'd variable 'a' in the signature scopes over f's RHS.

* The pattern-bound type variable 'b' in 'g1' scopes over g1's
  RHS; note that it is bound to a skolem 'a' which is not itself
  lexically in scope.

* The pattern-bound type variable 'c' in 'g2' is bound to
  Int; that is, pattern-bound type variables can stand for
  arbitrary types. (see
    GHC proposal #128 "Allow ScopedTypeVariables to refer to types"
    https://github.com/ghc-proposals/ghc-proposals/pull/128,
  and the paper
    "Type variables in patterns", Haskell Symposium 2018.


This is implemented by the constructor
   ATyVar Name TcTyVar
in the type environment.

* The Name is the name of the original, lexically scoped type
  variable

* The TcTyVar is sometimes a skolem (like in 'f'), and sometimes
  a unification variable (like in 'g1', 'g2').  We never zonk the
  type environment so in the latter case it always stays as a
  unification variable, although that variable may be later
  unified with a type (such as Int in 'g2').
-}

instance Outputable IdBindingInfo where
  ppr :: IdBindingInfo -> SDoc
ppr IdBindingInfo
NotLetBound = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"NotLetBound"
  ppr IdBindingInfo
ClosedLet = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"TopLevelLet"
  ppr (NonClosedLet RhsNames
fvs Bool
closed_type) =
    String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"TopLevelLet" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> RhsNames -> SDoc
forall a. Outputable a => a -> SDoc
ppr RhsNames
fvs SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
closed_type

--------------
pprTcTyThingCategory :: TcTyThing -> SDoc
pprTcTyThingCategory :: TcTyThing -> SDoc
pprTcTyThingCategory = String -> SDoc
forall doc. IsLine doc => String -> doc
text (String -> SDoc) -> (TcTyThing -> String) -> TcTyThing -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
capitalise (String -> String) -> (TcTyThing -> String) -> TcTyThing -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TcTyThing -> String
tcTyThingCategory

tcTyThingCategory :: TcTyThing -> String
tcTyThingCategory :: TcTyThing -> String
tcTyThingCategory (AGlobal TyThing
thing)    = TyThing -> String
tyThingCategory TyThing
thing
tcTyThingCategory (ATyVar {})        = String
"type variable"
tcTyThingCategory (ATcId {})         = String
"local identifier"
tcTyThingCategory (ATcTyCon {})      = String
"local tycon"
tcTyThingCategory (APromotionErr PromotionErr
pe) = PromotionErr -> String
peCategory PromotionErr
pe