%
\begin{code}
module TcRnTypes(
- TcRn, TcM, RnM, -- The monad is opaque outside this module
+ TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module
+ TcRef,
- -- Standard monadic operations
- thenM, thenM_, returnM, failM,
-
- -- Non-standard operations
- runTcRn, fixM, tryM, ioToTcRn,
- newMutVar, readMutVar, writeMutVar,
- getEnv, setEnv, updEnv, unsafeInterleaveM,
-
-- The environment types
- Env(..), TopEnv(..), TcGblEnv(..),
- TcLclEnv(..), RnLclEnv(..),
+ Env(..),
+ TcGblEnv(..), TcLclEnv(..),
+ IfGblEnv(..), IfLclEnv(..),
-- Ranamer types
- RnMode(..), isInterfaceMode, isCmdLineMode,
- EntityUsage, emptyUsages, ErrCtxt,
+ ErrCtxt,
ImportAvails(..), emptyImportAvails, plusImportAvails,
plusAvail, pruneAvails,
AvailEnv, emptyAvailEnv, unitAvailEnv, plusAvailEnv,
- mkAvailEnv, lookupAvailEnv, availEnvElts, addAvail,
- WhereFrom(..),
+ mkAvailEnv, lookupAvailEnv, lookupAvailEnv_maybe, availEnvElts, addAvail,
+ WhereFrom(..), mkModDeps,
-- Typechecker types
- TcTyThing(..),
+ TcTyThing(..), pprTcTyThingCategory,
+ GadtRefinement,
-- Template Haskell
- Stage(..), topStage, topSpliceStage,
- Level, impLevel, topLevel,
+ ThStage(..), topStage, topSpliceStage,
+ ThLevel, impLevel, topLevel,
+
+ -- Arrows
+ ArrowCtxt(NoArrowCtxt), newArrowScope, escapeArrowScope,
-- Insts
- Inst(..), InstOrigin(..), InstLoc, pprInstLoc,
+ Inst(..), InstOrigin(..), InstLoc(..), pprInstLoc,
+ instLocSrcLoc, instLocSrcSpan,
LIE, emptyLIE, unitLIE, plusLIE, consLIE,
plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE,
-- Misc other types
- TcRef, TcId, TcIdSet
+ TcId, TcIdSet, TcDictBinds
) where
#include "HsVersions.h"
-import HsSyn ( PendingSplice, HsOverLit, MonoBinds, RuleDecl, ForeignDecl )
-import RnHsSyn ( RenamedHsExpr, RenamedPat, RenamedArithSeqInfo )
-import HscTypes ( GhciMode, ExternalPackageState, HomePackageTable, NameCache,
- GlobalRdrEnv, LocalRdrEnv, FixityEnv, TypeEnv, TyThing,
- Avails, GenAvailInfo(..), AvailInfo, availName,
- IsBootInterface, Deprecations, WhetherHasOrphans )
-import Packages ( PackageName )
-import TcType ( TcTyVarSet, TcType, TcTauType, TcThetaType, TcPredType, TcKind,
- tcCmpPred, tcCmpType, tcCmpTypes )
-import InstEnv ( DFunId, InstEnv )
+import HsSyn ( PendingSplice, HsOverLit, LRuleDecl, LForeignDecl,
+ ArithSeqInfo, DictBinds, LHsBinds, LImportDecl, HsGroup,
+ IE )
+import HscTypes ( FixityEnv,
+ HscEnv, TypeEnv, TyThing,
+ GenAvailInfo(..), AvailInfo, HscSource(..),
+ availName, IsBootInterface, Deprecations )
+import Packages ( PackageId, HomeModules )
+import Type ( Type, pprTyThingCategory )
+import TcType ( TcTyVarSet, TcType, TcThetaType, SkolemInfo, TvSubst,
+ TcPredType, TcKind, tcCmpPred, tcCmpType, tcCmpTypes, pprSkolInfo )
+import InstEnv ( Instance, InstEnv )
+import IOEnv
+import RdrName ( GlobalRdrEnv, LocalRdrEnv )
import Name ( Name )
import NameEnv
-import NameSet ( NameSet, emptyNameSet )
-import Type ( Type )
-import Class ( Class )
+import NameSet ( NameSet, unionNameSets, DefUses )
+import OccName ( OccEnv )
import Var ( Id, TyVar )
import VarEnv ( TidyEnv )
import Module
-import SrcLoc ( SrcLoc )
+import SrcLoc ( SrcSpan, SrcLoc, Located, srcSpanStart )
import VarSet ( IdSet )
import ErrUtils ( Messages, Message )
-import CmdLineOpts ( DynFlags )
import UniqSupply ( UniqSupply )
import BasicTypes ( IPName )
import Util ( thenCmp )
import Bag
import Outputable
-import DATA_IOREF ( IORef, newIORef, readIORef, writeIORef )
-import UNSAFE_IO ( unsafeInterleaveIO )
-import FIX_IO ( fixIO )
-import EXCEPTION ( Exception )
import Maybe ( mapMaybe )
-import List ( nub )
-import Panic ( tryMost )
+import ListSetOps ( unionLists )
\end{code}
-\begin{code}
-type TcRef a = IORef a
-type TcId = Id -- Type may be a TcType
-type TcIdSet = IdSet
-\end{code}
-
%************************************************************************
%* *
Standard monad definition for TcRn
%* *
%************************************************************************
-The monad itself has to be defined here,
-because it is mentioned by ErrCtxt
+The monad itself has to be defined here, because it is mentioned by ErrCtxt
\begin{code}
-newtype TcRn m a = TcRn (Env m -> IO a)
-unTcRn (TcRn f) = f
+type TcRef a = IORef a
+type TcId = Id -- Type may be a TcType
+type TcIdSet = IdSet
+type TcDictBinds = DictBinds TcId -- Bag of dictionary bindings
-type TcM a = TcRn TcLclEnv a
-type RnM a = TcRn RnLclEnv a
-returnM :: a -> TcRn m a
-returnM a = TcRn (\ env -> return a)
-thenM :: TcRn m a -> (a -> TcRn m b) -> TcRn m b
-thenM (TcRn m) f = TcRn (\ env -> do { r <- m env ;
- unTcRn (f r) env })
-
-thenM_ :: TcRn m a -> TcRn m b -> TcRn m b
-thenM_ (TcRn m) f = TcRn (\ env -> do { m env ; unTcRn f env })
-
-failM :: TcRn m a
-failM = TcRn (\ env -> ioError (userError "TcRn failure"))
-
-instance Monad (TcRn m) where
- (>>=) = thenM
- (>>) = thenM_
- return = returnM
- fail s = failM -- Ignore the string
-\end{code}
-
-
-%************************************************************************
-%* *
- Fundmantal combinators specific to the monad
-%* *
-%************************************************************************
-
-Running it
-
-\begin{code}
-runTcRn :: Env m -> TcRn m a -> IO a
-runTcRn env (TcRn m) = m env
-\end{code}
-
-The fixpoint combinator
-
-\begin{code}
-{-# NOINLINE fixM #-}
- -- Aargh! Not inlining fixTc alleviates a space leak problem.
- -- Normally fixTc is used with a lazy tuple match: if the optimiser is
- -- shown the definition of fixTc, it occasionally transforms the code
- -- in such a way that the code generator doesn't spot the selector
- -- thunks. Sigh.
-
-fixM :: (a -> TcRn m a) -> TcRn m a
-fixM f = TcRn (\ env -> fixIO (\ r -> unTcRn (f r) env))
-\end{code}
-
-Error recovery
-
-\begin{code}
-tryM :: TcRn m r -> TcRn m (Either Exception r)
--- Reflect exception into TcRn monad
-tryM (TcRn thing) = TcRn (\ env -> tryMost (thing env))
-\end{code}
-
-Lazy interleave
-
-\begin{code}
-unsafeInterleaveM :: TcRn m a -> TcRn m a
-unsafeInterleaveM (TcRn m) = TcRn (\ env -> unsafeInterleaveIO (m env))
-\end{code}
-
-\end{code}
-
-Performing arbitrary I/O, plus the read/write var (for efficiency)
-
-\begin{code}
-ioToTcRn :: IO a -> TcRn m a
-ioToTcRn io = TcRn (\ env -> io)
-
-newMutVar :: a -> TcRn m (TcRef a)
-newMutVar val = TcRn (\ env -> newIORef val)
-
-writeMutVar :: TcRef a -> a -> TcRn m ()
-writeMutVar var val = TcRn (\ env -> writeIORef var val)
-
-readMutVar :: TcRef a -> TcRn m a
-readMutVar var = TcRn (\ env -> readIORef var)
-\end{code}
-
-Getting the environment
-
-\begin{code}
-getEnv :: TcRn m (Env m)
-{-# INLINE getEnv #-}
-getEnv = TcRn (\ env -> return env)
-
-setEnv :: Env n -> TcRn n a -> TcRn m a
-{-# INLINE setEnv #-}
-setEnv new_env (TcRn m) = TcRn (\ env -> m new_env)
-
-updEnv :: (Env m -> Env n) -> TcRn n a -> TcRn m a
-{-# INLINE updEnv #-}
-updEnv upd (TcRn m) = TcRn (\ env -> m (upd env))
+type TcRnIf a b c = IOEnv (Env a b) c
+type IfM lcl a = TcRnIf IfGblEnv lcl a -- Iface stuff
+type IfG a = IfM () a -- Top level
+type IfL a = IfM IfLclEnv a -- Nested
+type TcRn a = TcRnIf TcGblEnv TcLclEnv a
+type RnM a = TcRn a -- Historical
+type TcM a = TcRn a -- Historical
\end{code}
%************************************************************************
\begin{code}
-data Env a -- Changes as we move into an expression
+data Env gbl lcl -- Changes as we move into an expression
= Env {
- env_top :: TopEnv, -- Top-level stuff that never changes
- -- Mainly a bunch of updatable refs
- -- Includes all info about imported things
- env_gbl :: TcGblEnv, -- Info about things defined at the top leve
- -- of the module being compiled
+ env_top :: HscEnv, -- Top-level stuff that never changes
+ -- Includes all info about imported things
- env_lcl :: a, -- Different for the type checker
- -- and the renamer
+ env_us :: TcRef UniqSupply, -- Unique supply for local varibles
- env_loc :: SrcLoc -- Source location
- }
+ env_gbl :: gbl, -- Info about things defined at the top level
+ -- of the module being compiled
-data TopEnv -- Built once at top level then does not change
- -- Concerns imported stuff
- -- Exceptions: error recovery points, meta computation points
- = TopEnv {
- top_mode :: GhciMode,
- top_dflags :: DynFlags,
-
- -- Stuff about imports
- top_eps :: TcRef ExternalPackageState,
- -- PIT, ImportedModuleInfo
- -- DeclsMap, IfaceRules, IfaceInsts, InstGates
- -- TypeEnv, InstEnv, RuleBase
-
- top_hpt :: HomePackageTable,
- -- The home package table that we've accumulated while
- -- compiling the home package,
- -- *excluding* the module we are compiling right now.
- -- (In one-shot mode the current module is the only
- -- home-package module, so tc_hpt is empty. All other
- -- modules count as "external-package" modules.)
- -- tc_hpt is not mutable because we only demand-load
- -- external packages; the home package is eagerly
- -- loaded by the compilation manager.
-
- -- The global name supply
- top_nc :: TcRef NameCache, -- Maps original names to Names
- top_us :: TcRef UniqSupply, -- Unique supply for this module
- top_errs :: TcRef Messages
- }
+ env_lcl :: lcl -- Nested stuff; changes as we go into
+ -- an expression
+ }
-- TcGblEnv describes the top-level of the module at the
-- point at which the typechecker is finished work.
data TcGblEnv
= TcGblEnv {
- tcg_mod :: Module, -- Module being compiled
- tcg_usages :: TcRef EntityUsage, -- What version of what entities
- -- have been used from other home-pkg modules
+ tcg_mod :: Module, -- Module being compiled
+ tcg_src :: HscSource, -- What kind of module
+ -- (regular Haskell, hs-boot, ext-core)
+
tcg_rdr_env :: GlobalRdrEnv, -- Top level envt; used during renaming
- tcg_fix_env :: FixityEnv, -- Ditto
- tcg_default :: [Type], -- Types used for defaulting
+ tcg_default :: Maybe [Type], -- Types used for defaulting
+ -- Nothing => no 'default' decl
+
+ tcg_fix_env :: FixityEnv, -- Just for things in this module
tcg_type_env :: TypeEnv, -- Global type env for the module we are compiling now
-- All TyCons and Classes (for this module) end up in here right away,
--
-- (Ids defined in this module start in the local envt,
-- though they move to the global envt during zonking)
-
- -- Cached things
- tcg_ist :: Name -> Maybe TyThing, -- Imported symbol table
- -- Global type env: a combination of tcg_eps, tcg_hpt
- -- (but *not* tcg_type_env; no deep reason)
- -- When the PCS changes this must be refreshed,
- -- notably after running some compile-time code
-
- tcg_inst_env :: InstEnv, -- Global instance env: a combination of
- -- tc_pcs, tc_hpt, *and* tc_insts
+ tcg_type_env_var :: TcRef TypeEnv,
+ -- Used only to initialise the interface-file
+ -- typechecker in initIfaceTcRn, so that it can see stuff
+ -- bound in this module when dealing with hi-boot recursions
+ -- Updated at intervals (e.g. after dealing with types and classes)
+
+ tcg_inst_env :: InstEnv, -- Instance envt for *home-package* modules
+ -- Includes the dfuns in tcg_insts
-- Now a bunch of things about this module that are simply
-- accumulated, but never consulted until the end.
-- Nevertheless, it's convenient to accumulate them along
-- with the rest of the info from this module.
- tcg_exports :: Avails, -- What is exported
- tcg_imports :: ImportAvails, -- Information about what was imported
- -- from where, including things bound
- -- in this module
- -- The next fields are always fully zonked
- tcg_binds :: MonoBinds Id, -- Value bindings in this module
+ tcg_exports :: NameSet, -- What is exported
+ tcg_imports :: ImportAvails, -- Information about what was imported
+ -- from where, including things bound
+ -- in this module
+
+ tcg_home_mods :: HomeModules,
+ -- Calculated from ImportAvails, allows us to
+ -- call Packages.isHomeModule
+
+ tcg_dus :: DefUses, -- What is defined in this module and what is used.
+ -- The latter is used to generate
+ -- (a) version tracking; no need to recompile if these
+ -- things have not changed version stamp
+ -- (b) unused-import info
+
+ tcg_keep :: TcRef NameSet, -- Locally-defined top-level names to keep alive
+ -- "Keep alive" means give them an Exported flag, so
+ -- that the simplifier does not discard them as dead
+ -- code, and so that they are exposed in the interface file
+ -- (but not to export to the user).
+ --
+ -- Some things, like dict-fun Ids and default-method Ids are
+ -- "born" with the Exported flag on, for exactly the above reason,
+ -- but some we only discover as we go. Specifically:
+ -- * The to/from functions for generic data types
+ -- * Top-level variables appearing free in the RHS of an orphan rule
+ -- * Top-level variables appearing free in a TH bracket
+
+ tcg_inst_uses :: TcRef NameSet, -- Home-package Dfuns actually used
+ -- Used to generate version dependencies
+ -- This records usages, rather like tcg_dus, but it has to
+ -- be a mutable variable so it can be augmented
+ -- when we look up an instance. These uses of dfuns are
+ -- rather like the free variables of the program, but
+ -- are implicit instead of explicit.
+
+ tcg_th_used :: TcRef Bool, -- True <=> Template Haskell syntax used
+ -- We need this so that we can generate a dependency on the
+ -- Template Haskell package, becuase the desugarer is going to
+ -- emit loads of references to TH symbols. It's rather like
+ -- tcg_inst_uses; the reference is implicit rather than explicit,
+ -- so we have to zap a mutable variable.
+
+ tcg_dfun_n :: TcRef Int, -- Allows us to number off the names of DFuns
+ -- It's convenient to allocate an External Name for a DFun, with
+ -- a permanently-fixed unique, just like other top-level functions
+ -- defined in this module. But that means we need a canonical
+ -- occurrence name, distinct from all other dfuns in this module,
+ -- and this name supply serves that purpose (df1, df2, etc).
+
+ -- The next fields accumulate the payload of the module
+ -- The binds, rules and foreign-decl fiels are collected
+ -- initially in un-zonked form and are finally zonked in tcRnSrcDecls
+
+ -- The next fields accumulate the payload of the
+ -- module The binds, rules and foreign-decl fiels are
+ -- collected initially in un-zonked form and are
+ -- finally zonked in tcRnSrcDecls
+
+ tcg_rn_imports :: Maybe [LImportDecl Name],
+ tcg_rn_exports :: Maybe [Located (IE Name)],
+ tcg_rn_decls :: Maybe (HsGroup Name), -- renamed decls, maybe
+ -- Nothing <=> Don't retain renamed decls
+
+ tcg_binds :: LHsBinds Id, -- Value bindings in this module
tcg_deprecs :: Deprecations, -- ...Deprecations
- tcg_insts :: [DFunId], -- ...Instances
- tcg_rules :: [RuleDecl Id], -- ...Rules
- tcg_fords :: [ForeignDecl Id] -- ...Foreign import & exports
+ tcg_insts :: [Instance], -- ...Instances
+ tcg_rules :: [LRuleDecl Id], -- ...Rules
+ tcg_fords :: [LForeignDecl Id] -- ...Foreign import & exports
+ }
+\end{code}
+
+%************************************************************************
+%* *
+ The interface environments
+ Used when dealing with IfaceDecls
+%* *
+%************************************************************************
+
+\begin{code}
+data IfGblEnv
+ = IfGblEnv {
+ -- The type environment for the module being compiled,
+ -- in case the interface refers back to it via a reference that
+ -- was originally a hi-boot file.
+ -- We need the module name so we can test when it's appropriate
+ -- to look in this env.
+ if_rec_types :: Maybe (Module, IfG TypeEnv)
+ -- Allows a read effect, so it can be in a mutable
+ -- variable; c.f. handling the external package type env
+ -- Nothing => interactive stuff, no loops possible
+ }
+
+data IfLclEnv
+ = IfLclEnv {
+ -- The module for the current IfaceDecl
+ -- So if we see f = \x -> x
+ -- it means M.f = \x -> x, where M is the if_mod
+ if_mod :: Module,
+
+ -- The field is used only for error reporting
+ -- if (say) there's a Lint error in it
+ if_loc :: SDoc,
+ -- Where the interface came from:
+ -- .hi file, or GHCi state, or ext core
+ -- plus which bit is currently being examined
+
+ if_tv_env :: OccEnv TyVar, -- Nested tyvar bindings
+ if_id_env :: OccEnv Id -- Nested id binding
}
\end{code}
b) used in the ModDetails of this module
\begin{code}
-data TcLclEnv
+data TcLclEnv -- Changes as we move inside an expression
+ -- Discarded after typecheck/rename; not passed on to desugarer
= TcLclEnv {
- tcl_ctxt :: ErrCtxt, -- Error context
-
- tcl_level :: Stage, -- Template Haskell context
+ tcl_loc :: SrcSpan, -- Source span
+ tcl_ctxt :: ErrCtxt, -- Error context
+ tcl_errs :: TcRef Messages, -- Place to accumulate errors
+
+ tcl_th_ctxt :: ThStage, -- Template Haskell context
+ tcl_arrow_ctxt :: ArrowCtxt, -- Arrow-notation context
+
+ tcl_rdr :: LocalRdrEnv, -- Local name envt
+ -- Maintained during renaming, of course, but also during
+ -- type checking, solely so that when renaming a Template-Haskell
+ -- splice we have the right environment for the renamer.
+ --
+ -- Does *not* include global name envt; may shadow it
+ -- Includes both ordinary variables and type variables;
+ -- they are kept distinct because tyvar have a different
+ -- occurrence contructor (Name.TvOcc)
+ -- We still need the unsullied global name env so that
+ -- we can look up record field names
- tcl_env :: NameEnv TcTyThing, -- The local type environment: Ids and TyVars
- -- defined in this module
+ tcl_env :: NameEnv TcTyThing, -- The local type environment: Ids and TyVars
+ -- defined in this module
tcl_tyvars :: TcRef TcTyVarSet, -- The "global tyvars"
- -- Namely, the in-scope TyVars bound in tcl_lenv,
- -- plus the tyvars mentioned in the types of
- -- Ids bound in tcl_lenv
- -- Why mutable? see notes with tcGetGlobalTyVars
+ -- Namely, the in-scope TyVars bound in tcl_env,
+ -- plus the tyvars mentioned in the types of Ids bound in tcl_lenv
+ -- Why mutable? see notes with tcGetGlobalTyVars
- tcl_lie :: TcRef LIE -- Place to accumulate type constraints
+ tcl_lie :: TcRef LIE -- Place to accumulate type constraints
}
-type Level = Int
+type GadtRefinement = TvSubst
-data Stage
- = Comp -- Ordinary compiling, at level topLevel
- | Splice Level -- Inside a splice
- | Brack Level -- Inside brackets;
- (TcRef [PendingSplice]) -- accumulate pending splices here
- (TcRef LIE) -- and type constraints here
-topStage, topSpliceStage :: Stage
-topStage = Comp
-topSpliceStage = Splice (topLevel - 1) -- Stage for the body of a top-level splice
+{- Note [Given Insts]
+ ~~~~~~~~~~~~~~~~~~
+Because of GADTs, we have to pass inwards the Insts provided by type signatures
+and existential contexts. Consider
+ data T a where { T1 :: b -> b -> T [b] }
+ f :: Eq a => T a -> Bool
+ f (T1 x y) = [x]==[y]
+The constructor T1 binds an existential variable 'b', and we need Eq [b].
+Well, we have it, because Eq a refines to Eq [b], but we can only spot that if we
+pass it inwards.
-impLevel, topLevel :: Level
-topLevel = 1 -- Things dedined at top level of this module
+-}
+
+---------------------------
+-- Template Haskell levels
+---------------------------
+
+type ThLevel = Int
+ -- Indicates how many levels of brackets we are inside
+ -- (always >= 0)
+ -- Incremented when going inside a bracket,
+ -- decremented when going inside a splice
+
+impLevel, topLevel :: ThLevel
+topLevel = 1 -- Things defined at top level of this module
impLevel = 0 -- Imported things; they can be used inside a top level splice
--
-- For example:
-- g1 = $(map ...) is OK
-- g2 = $(f ...) is not OK; because we havn't compiled f yet
-data TcTyThing
- = AGlobal TyThing -- Used only in the return type of a lookup
- | ATcId TcId Level -- Ids defined in this module; may not be fully zonked
- | ATyVar TyVar -- Type variables
- | AThing TcKind -- Used temporarily, during kind checking
--- Here's an example of how the AThing guy is used
--- Suppose we are checking (forall a. T a Int):
--- 1. We first bind (a -> AThink kv), where kv is a kind variable.
--- 2. Then we kind-check the (T a Int) part.
--- 3. Then we zonk the kind variable.
--- 4. Now we know the kind for 'a', and we add (a -> ATyVar a::K) to the environment
-\end{code}
-\begin{code}
-type ErrCtxt = [TidyEnv -> TcM (TidyEnv, Message)]
- -- Innermost first. Monadic so that we have a chance
- -- to deal with bound type variables just before error
- -- message construction
-\end{code}
+data ThStage
+ = Comp -- Ordinary compiling, at level topLevel
+ | Splice ThLevel -- Inside a splice
+ | Brack ThLevel -- Inside brackets;
+ (TcRef [PendingSplice]) -- accumulate pending splices here
+ (TcRef LIE) -- and type constraints here
+topStage, topSpliceStage :: ThStage
+topStage = Comp
+topSpliceStage = Splice (topLevel - 1) -- Stage for the body of a top-level splice
+---------------------------
+-- Arrow-notation context
+---------------------------
-%************************************************************************
-%* *
- The local renamer environment
-%* *
-%************************************************************************
+{-
+In arrow notation, a variable bound by a proc (or enclosed let/kappa)
+is not in scope to the left of an arrow tail (-<) or the head of (|..|).
+For example
-\begin{code}
-data RnLclEnv
- = RnLclEnv {
- rn_mode :: RnMode,
- rn_lenv :: LocalRdrEnv -- Local name envt
- -- Does *not* include global name envt; may shadow it
- -- Includes both ordinary variables and type variables;
- -- they are kept distinct because tyvar have a different
- -- occurrence contructor (Name.TvOcc)
- -- We still need the unsullied global name env so that
- -- we can look up record field names
- }
+ proc x -> (e1 -< e2)
-data RnMode = SourceMode -- Renaming source code
- | InterfaceMode Module -- Renaming interface declarations from M
- | CmdLineMode -- Renaming a command-line expression
+Here, x is not in scope in e1, but it is in scope in e2. This can get
+a bit complicated:
-isInterfaceMode (InterfaceMode _) = True
-isInterfaceMode _ = False
+ let x = 3 in
+ proc y -> (proc z -> e1) -< e2
-isCmdLineMode CmdLineMode = True
-isCmdLineMode _ = False
-\end{code}
+Here, x and z are in scope in e1, but y is not. We implement this by
+recording the environment when passing a proc (using newArrowScope),
+and returning to that (using escapeArrowScope) on the left of -< and the
+head of (|..|).
+-}
+data ArrowCtxt
+ = NoArrowCtxt
+ | ArrowCtxt (Env TcGblEnv TcLclEnv)
-%************************************************************************
-%* *
- EntityUsage
-%* *
-%************************************************************************
+-- Record the current environment (outside a proc)
+newArrowScope :: TcM a -> TcM a
+newArrowScope
+ = updEnv $ \env ->
+ env { env_lcl = (env_lcl env) { tcl_arrow_ctxt = ArrowCtxt env } }
-EntityUsage tells what things are actually need in order to compile this
-module. It is used for generating the usage-version field of the ModIface.
+-- Return to the stored environment (from the enclosing proc)
+escapeArrowScope :: TcM a -> TcM a
+escapeArrowScope
+ = updEnv $ \ env -> case tcl_arrow_ctxt (env_lcl env) of
+ NoArrowCtxt -> env
+ ArrowCtxt env' -> env'
-Note that we do not record version info for entities from
-other (non-home) packages. If the package changes, GHC doesn't help.
+---------------------------
+-- TcTyThing
+---------------------------
+
+data TcTyThing
+ = AGlobal TyThing -- Used only in the return type of a lookup
+
+ | ATcId TcId -- Ids defined in this module; may not be fully zonked
+ ThLevel
+ Bool -- True <=> apply the type refinement to me
+
+ | ATyVar Name TcType -- The type to which the lexically scoped type vaiable
+ -- is currently refined. We only need the Name
+ -- for error-message purposes
+
+ | AThing TcKind -- Used temporarily, during kind checking, for the
+ -- tycons and clases in this recursive group
+
+instance Outputable TcTyThing where -- Debugging only
+ ppr (AGlobal g) = ppr g
+ ppr (ATcId g tl rig) = text "Identifier" <>
+ ifPprDebug (brackets (ppr g <> comma <> ppr tl <+> ppr rig))
+ ppr (ATyVar tv _) = text "Type variable" <+> quotes (ppr tv)
+ ppr (AThing k) = text "AThing" <+> ppr k
+
+pprTcTyThingCategory :: TcTyThing -> SDoc
+pprTcTyThingCategory (AGlobal thing) = pprTyThingCategory thing
+pprTcTyThingCategory (ATyVar {}) = ptext SLIT("Type variable")
+pprTcTyThingCategory (ATcId {}) = ptext SLIT("Local identifier")
+pprTcTyThingCategory (AThing {}) = ptext SLIT("Kinded thing")
+\end{code}
\begin{code}
-type EntityUsage = NameSet
- -- The Names are all the (a) home-package
- -- (b) "big" (i.e. no data cons, class ops)
- -- (c) non-locally-defined
- -- (d) non-wired-in
- -- names that have been slurped in so far.
- -- This is used to generate the "usage" information for this module.
-
-emptyUsages :: EntityUsage
-emptyUsages = emptyNameSet
+type ErrCtxt = [TidyEnv -> TcM (TidyEnv, Message)]
+ -- Innermost first. Monadic so that we have a chance
+ -- to deal with bound type variables just before error
+ -- message construction
\end{code}
%************************************************************************
ImportAvails summarises what was imported from where, irrespective
-of whether the imported htings are actually used or not
-It is used * when porcessing the export list
+of whether the imported things are actually used or not
+It is used * when processing the export list
* when constructing usage info for the inteface file
* to identify the list of directly imported modules
for initialisation purposes
+ * when figuring out what things are really unused
\begin{code}
data ImportAvails
= ImportAvails {
- imp_env :: AvailEnv,
- -- All the things that are available from the import
- -- Its domain is all the "main" things;
- -- i.e. *excluding* class ops and constructors
- -- (which appear inside their parent AvailTC)
-
- imp_unqual :: ModuleEnv AvailEnv,
- -- Used to figure out "module M" export specifiers
- -- Domain is only modules with *unqualified* imports
- -- (see 1.4 Report Section 5.1.1)
- -- We keep the stuff as an AvailEnv so that it's easy to
- -- combine stuff coming from different (unqualified)
- -- imports of the same module
-
- imp_mods :: ModuleEnv (Module, Bool),
+ imp_env :: ModuleEnv NameSet,
+ -- All the things imported, classified by
+ -- the *module qualifier* for its import
+ -- e.g. import List as Foo
+ -- would add a binding Foo |-> ...stuff from List...
+ -- to imp_env.
+ --
+ -- We need to classify them like this so that we can figure out
+ -- "module M" export specifiers in an export list
+ -- (see 1.4 Report Section 5.1.1). Ultimately, we want to find
+ -- everything that is unambiguously in scope as 'M.x'
+ -- and where plain 'x' is (perhaps ambiguously) in scope.
+ -- So the starting point is all things that are in scope as 'M.x',
+ -- which is what this field tells us.
+
+ imp_mods :: ModuleEnv (Module, Bool, SrcSpan),
-- Domain is all directly-imported modules
- -- Bool is True if there was an unrestricted import
- -- (i.e. not a selective list)
+ -- Bool means:
+ -- True => import was "import Foo ()"
+ -- False => import was some other form
+ --
-- We need the Module in the range because we can't get
-- the keys of a ModuleEnv
-- Used
-- (a) to help construct the usage information in
- -- the interface file; if we import everything we
- -- need to recompile if the module version changes
+ -- the interface file; if we import somethign we
+ -- need to recompile if the export version changes
-- (b) to specify what child modules to initialise
- dep_mods :: ModuleEnv (ModuleName, WhetherHasOrphans, IsBootInterface),
- -- For a given import or set of imports,
- -- there's an entry here for
- -- (a) modules below the one being compiled, in the current package
- -- (b) orphan modules below the one being compiled, regardless of package
+ imp_dep_mods :: ModuleEnv (Module, IsBootInterface),
+ -- Home-package modules needed by the module being compiled
--
- -- It doesn't matter whether any of these dependencies are actually
- -- *used* when compiling the module; they are listed if they are below
- -- it at all. For example, suppose M imports A which imports X. Then
- -- compiling M might not need to consult X.hi, but X is still listed
- -- in M's dependencies.
-
- dep_pkgs :: [PackageName]
+ -- It doesn't matter whether any of these dependencies
+ -- are actually *used* when compiling the module; they
+ -- are listed if they are below it at all. For
+ -- example, suppose M imports A which imports X. Then
+ -- compiling M might not need to consult X.hi, but X
+ -- is still listed in M's dependencies.
+
+ imp_dep_pkgs :: [PackageId],
-- Packages needed by the module being compiled, whether
-- directly, or via other modules in this package, or via
-- modules imported from other packages.
+
+ imp_orphs :: [Module]
+ -- Orphan modules below us in the import tree
}
+mkModDeps :: [(Module, IsBootInterface)]
+ -> ModuleEnv (Module, IsBootInterface)
+mkModDeps deps = foldl add emptyModuleEnv deps
+ where
+ add env elt@(m,_) = extendModuleEnv env m elt
+
emptyImportAvails :: ImportAvails
-emptyImportAvails = ImportAvails { imp_env = emptyAvailEnv,
- imp_unqual = emptyModuleEnv,
- imp_mods = emptyModuleEnv,
- dep_mods = emptyModuleEnv,
- dep_pkgs = [] }
+emptyImportAvails = ImportAvails { imp_env = emptyModuleEnv,
+ imp_mods = emptyModuleEnv,
+ imp_dep_mods = emptyModuleEnv,
+ imp_dep_pkgs = [],
+ imp_orphs = [] }
plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails
plusImportAvails
- (ImportAvails { imp_env = env1, imp_unqual = unqual1, imp_mods = mods1,
- dep_mods = dmods1, dep_pkgs = dpkgs1 })
- (ImportAvails { imp_env = env2, imp_unqual = unqual2, imp_mods = mods2,
- dep_mods = dmods2, dep_pkgs = dpkgs2 })
- = ImportAvails { imp_env = env1 `plusAvailEnv` env2,
- imp_unqual = plusModuleEnv_C plusAvailEnv unqual1 unqual2,
- imp_mods = mods1 `plusModuleEnv` mods2,
- dep_mods = plusModuleEnv_C plus_mod_dep dmods1 dmods2,
- dep_pkgs = nub (dpkgs1 ++ dpkgs2) }
+ (ImportAvails { imp_env = env1, imp_mods = mods1,
+ imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1, imp_orphs = orphs1 })
+ (ImportAvails { imp_env = env2, imp_mods = mods2,
+ imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2, imp_orphs = orphs2 })
+ = ImportAvails { imp_env = plusModuleEnv_C unionNameSets env1 env2,
+ imp_mods = mods1 `plusModuleEnv` mods2,
+ imp_dep_mods = plusModuleEnv_C plus_mod_dep dmods1 dmods2,
+ imp_dep_pkgs = dpkgs1 `unionLists` dpkgs2,
+ imp_orphs = orphs1 `unionLists` orphs2 }
where
- plus_mod_dep (m1, orphan1, boot1) (m2, orphan2, boot2)
- = ASSERT( m1 == m2 && orphan1 == orphan2 )
- (m1, orphan1, boot1 && boot2)
- -- If either side can "see" a non-hi-boot interface, use that
+ plus_mod_dep (m1, boot1) (m2, boot2)
+ = WARN( not (m1 == m2), (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )
+ -- Check mod-names match
+ (m1, boot1 && boot2) -- If either side can "see" a non-hi-boot interface, use that
\end{code}
%************************************************************************
\begin{code}
plusAvail (Avail n1) (Avail n2) = Avail n1
-plusAvail (AvailTC n1 ns1) (AvailTC n2 ns2) = AvailTC n2 (nub (ns1 ++ ns2))
+plusAvail (AvailTC n1 ns1) (AvailTC n2 ns2) = AvailTC n2 (ns1 `unionLists` ns2)
-- Added SOF 4/97
#ifdef DEBUG
plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [ppr a1,ppr a2])
plusAvailEnv :: AvailEnv -> AvailEnv -> AvailEnv
plusAvailEnv = plusNameEnv_C plusAvail
-lookupAvailEnv = lookupNameEnv
+lookupAvailEnv_maybe :: AvailEnv -> Name -> Maybe AvailInfo
+lookupAvailEnv_maybe = lookupNameEnv
+
+lookupAvailEnv :: AvailEnv -> Name -> AvailInfo
+lookupAvailEnv env n = case lookupNameEnv env n of
+ Just avail -> avail
+ Nothing -> pprPanic "lookupAvailEnv" (ppr n)
availEnvElts = nameEnvElts
\begin{code}
data WhereFrom
= ImportByUser IsBootInterface -- Ordinary user import (perhaps {-# SOURCE #-})
-
- | ImportForUsage IsBootInterface -- Import when chasing usage info from an interaface file
- -- Failure in this case is not an error
-
| ImportBySystem -- Non user import.
instance Outputable WhereFrom where
ppr (ImportByUser is_boot) | is_boot = ptext SLIT("{- SOURCE -}")
| otherwise = empty
- ppr (ImportForUsage is_boot) | is_boot = ptext SLIT("{- USAGE SOURCE -}")
- | otherwise = ptext SLIT("{- USAGE -}")
ppr ImportBySystem = ptext SLIT("{- SYSTEM -}")
\end{code}
\begin{code}
data Inst
= Dict
- Id
+ Name
TcPredType
InstLoc
TcThetaType -- The (types of the) dictionaries to which the function
-- must be applied to get the method
- TcTauType -- The type of the method
-
InstLoc
- -- INVARIANT: in (Method u f tys theta tau loc)
+ -- INVARIANT 1: in (Method u f tys theta tau loc)
-- type of (f tys dicts(from theta)) = tau
+ -- INVARIANT 2: tau must not be of form (Pred -> Tau)
+ -- Reason: two methods are considered equal if the
+ -- base Id matches, and the instantiating types
+ -- match. The TcThetaType should then match too.
+ -- This only bites in the call to tcInstClassOp in TcClassDcl.mkMethodBind
+
| LitInst
- Id
- HsOverLit -- The literal from the occurrence site
- -- INVARIANT: never a rebindable-syntax literal
- -- Reason: tcSyntaxName does unification, and we
- -- don't want to deal with that during tcSimplify
+ Name
+ (HsOverLit Name) -- The literal from the occurrence site
+ -- INVARIANT: never a rebindable-syntax literal
+ -- Reason: tcSyntaxName does unification, and we
+ -- don't want to deal with that during tcSimplify,
+ -- when resolving LitInsts
TcType -- The type at which the literal is used
InstLoc
\end{code}
EQ -> True
other -> False
-cmpInst (Dict _ pred1 _) (Dict _ pred2 _) = pred1 `tcCmpPred` pred2
-cmpInst (Dict _ _ _) other = LT
+cmpInst (Dict _ pred1 _) (Dict _ pred2 _) = pred1 `tcCmpPred` pred2
+cmpInst (Dict _ _ _) other = LT
-cmpInst (Method _ _ _ _ _ _) (Dict _ _ _) = GT
-cmpInst (Method _ id1 tys1 _ _ _) (Method _ id2 tys2 _ _ _) = (id1 `compare` id2) `thenCmp` (tys1 `tcCmpTypes` tys2)
-cmpInst (Method _ _ _ _ _ _) other = LT
+cmpInst (Method _ _ _ _ _) (Dict _ _ _) = GT
+cmpInst (Method _ id1 tys1 _ _) (Method _ id2 tys2 _ _) = (id1 `compare` id2) `thenCmp` (tys1 `tcCmpTypes` tys2)
+cmpInst (Method _ _ _ _ _) other = LT
-cmpInst (LitInst _ _ _ _) (Dict _ _ _) = GT
-cmpInst (LitInst _ _ _ _) (Method _ _ _ _ _ _) = GT
-cmpInst (LitInst _ lit1 ty1 _) (LitInst _ lit2 ty2 _) = (lit1 `compare` lit2) `thenCmp` (ty1 `tcCmpType` ty2)
+cmpInst (LitInst _ _ _ _) (Dict _ _ _) = GT
+cmpInst (LitInst _ _ _ _) (Method _ _ _ _ _) = GT
+cmpInst (LitInst _ lit1 ty1 _) (LitInst _ lit2 ty2 _) = (lit1 `compare` lit2) `thenCmp` (ty1 `tcCmpType` ty2)
\end{code}
%************************************************************************
\begin{code}
+-- FIXME: Rename this. It clashes with (Located (IE ...))
type LIE = Bag Inst
isEmptyLIE = isEmptyBag
functions that deal with it.
\begin{code}
-type InstLoc = (InstOrigin, SrcLoc, ErrCtxt)
+data InstLoc = InstLoc InstOrigin SrcSpan ErrCtxt
-data InstOrigin
- = OccurrenceOf Name -- Occurrence of an overloaded identifier
-
- | IPOcc (IPName Name) -- Occurrence of an implicit parameter
- | IPBind (IPName Name) -- Binding site of an implicit parameter
-
- | RecordUpdOrigin
+instLocSrcLoc :: InstLoc -> SrcLoc
+instLocSrcLoc (InstLoc _ src_span _) = srcSpanStart src_span
- | DataDeclOrigin -- Typechecking a data declaration
+instLocSrcSpan :: InstLoc -> SrcSpan
+instLocSrcSpan (InstLoc _ src_span _) = src_span
- | InstanceDeclOrigin -- Typechecking an instance decl
-
- | LiteralOrigin HsOverLit -- Occurrence of a literal
-
- | PatOrigin RenamedPat
-
- | ArithSeqOrigin RenamedArithSeqInfo -- [x..], [x..y] etc
- | PArrSeqOrigin RenamedArithSeqInfo -- [:x..y:] and [:x,y..z:]
-
- | SignatureOrigin -- A dict created from a type signature
- | Rank2Origin -- A dict created when typechecking the argument
- -- of a rank-2 typed function
-
- | DoOrigin -- The monad for a do expression
-
- | ClassDeclOrigin -- Manufactured during a class decl
+data InstOrigin
+ = SigOrigin SkolemInfo -- Pattern, class decl, inst decl etc;
+ -- Places that bind type variables and introduce
+ -- available constraints
- | InstanceSpecOrigin Class -- in a SPECIALIZE instance pragma
- Type
+ | IPBindOrigin (IPName Name) -- Binding site of an implicit parameter
- -- When specialising instances the instance info attached to
- -- each class is not yet ready, so we record it inside the
- -- origin information. This is a bit of a hack, but it works
- -- fine. (Patrick is to blame [WDP].)
+ -------------------------------------------------------
+ -- The rest are all occurrences: Insts that are 'wanted'
+ -------------------------------------------------------
+ | OccurrenceOf Name -- Occurrence of an overloaded identifier
- | ValSpecOrigin Name -- in a SPECIALIZE pragma for a value
+ | IPOccOrigin (IPName Name) -- Occurrence of an implicit parameter
- -- Argument or result of a ccall
- -- Dictionaries with this origin aren't actually mentioned in the
- -- translated term, and so need not be bound. Nor should they
- -- be abstracted over.
+ | LiteralOrigin (HsOverLit Name) -- Occurrence of a literal
- | CCallOrigin String -- CCall label
- (Maybe RenamedHsExpr) -- Nothing if it's the result
- -- Just arg, for an argument
+ | ArithSeqOrigin (ArithSeqInfo Name) -- [x..], [x..y] etc
+ | PArrSeqOrigin (ArithSeqInfo Name) -- [:x..y:] and [:x,y..z:]
- | LitLitOrigin String -- the litlit
+ | InstSigOrigin -- A dict occurrence arising from instantiating
+ -- a polymorphic type during a subsumption check
- | UnknownOrigin -- Help! I give up...
+ | RecordUpdOrigin
+ | InstScOrigin -- Typechecking superclasses of an instance declaration
+ | DerivOrigin -- Typechecking deriving
+ | DefaultOrigin -- Typechecking a default decl
+ | DoOrigin -- Arising from a do expression
+ | ProcOrigin -- Arising from a proc expression
\end{code}
\begin{code}
pprInstLoc :: InstLoc -> SDoc
-pprInstLoc (orig, locn, ctxt)
+pprInstLoc (InstLoc orig locn _)
= hsep [text "arising from", pp_orig orig, text "at", ppr locn]
where
- pp_orig (OccurrenceOf name)
- = hsep [ptext SLIT("use of"), quotes (ppr name)]
- pp_orig (IPOcc name)
- = hsep [ptext SLIT("use of implicit parameter"), quotes (ppr name)]
- pp_orig (IPBind name)
- = hsep [ptext SLIT("binding for implicit parameter"), quotes (ppr name)]
- pp_orig RecordUpdOrigin
- = ptext SLIT("a record update")
- pp_orig DataDeclOrigin
- = ptext SLIT("the data type declaration")
- pp_orig InstanceDeclOrigin
- = ptext SLIT("the instance declaration")
- pp_orig (LiteralOrigin lit)
- = hsep [ptext SLIT("the literal"), quotes (ppr lit)]
- pp_orig (PatOrigin pat)
- = hsep [ptext SLIT("the pattern"), quotes (ppr pat)]
- pp_orig (ArithSeqOrigin seq)
- = hsep [ptext SLIT("the arithmetic sequence"), quotes (ppr seq)]
- pp_orig (PArrSeqOrigin seq)
- = hsep [ptext SLIT("the parallel array sequence"), quotes (ppr seq)]
- pp_orig (SignatureOrigin)
- = ptext SLIT("a type signature")
- pp_orig (Rank2Origin)
- = ptext SLIT("a function with an overloaded argument type")
- pp_orig (DoOrigin)
- = ptext SLIT("a do statement")
- pp_orig (ClassDeclOrigin)
- = ptext SLIT("a class declaration")
- pp_orig (InstanceSpecOrigin clas ty)
- = hsep [text "a SPECIALIZE instance pragma; class",
- quotes (ppr clas), text "type:", ppr ty]
- pp_orig (ValSpecOrigin name)
- = hsep [ptext SLIT("a SPECIALIZE user-pragma for"), quotes (ppr name)]
- pp_orig (CCallOrigin clabel Nothing{-ccall result-})
- = hsep [ptext SLIT("the result of the _ccall_ to"), quotes (text clabel)]
- pp_orig (CCallOrigin clabel (Just arg_expr))
- = hsep [ptext SLIT("an argument in the _ccall_ to"), quotes (text clabel) <> comma,
- text "namely", quotes (ppr arg_expr)]
- pp_orig (LitLitOrigin s)
- = hsep [ptext SLIT("the ``literal-literal''"), quotes (text s)]
- pp_orig (UnknownOrigin)
- = ptext SLIT("...oops -- I don't know where the overloading came from!")
+ pp_orig (OccurrenceOf name) = hsep [ptext SLIT("use of"), quotes (ppr name)]
+ pp_orig (IPOccOrigin name) = hsep [ptext SLIT("use of implicit parameter"), quotes (ppr name)]
+ pp_orig (IPBindOrigin name) = hsep [ptext SLIT("binding for implicit parameter"), quotes (ppr name)]
+ pp_orig RecordUpdOrigin = ptext SLIT("a record update")
+ pp_orig (LiteralOrigin lit) = hsep [ptext SLIT("the literal"), quotes (ppr lit)]
+ pp_orig (ArithSeqOrigin seq) = hsep [ptext SLIT("the arithmetic sequence"), quotes (ppr seq)]
+ pp_orig (PArrSeqOrigin seq) = hsep [ptext SLIT("the parallel array sequence"), quotes (ppr seq)]
+ pp_orig InstSigOrigin = ptext SLIT("instantiating a type signature")
+ pp_orig InstScOrigin = ptext SLIT("the superclasses of an instance declaration")
+ pp_orig DerivOrigin = ptext SLIT("the 'deriving' clause of a data type declaration")
+ pp_orig DefaultOrigin = ptext SLIT("a 'default' declaration")
+ pp_orig DoOrigin = ptext SLIT("a do statement")
+ pp_orig ProcOrigin = ptext SLIT("a proc expression")
+ pp_orig (SigOrigin info) = pprSkolInfo info
\end{code}
projects / ghc-hetmet.git / blobdiff