-%
+
% (c) The University of Glasgow 2006
% (c) The GRASP Project, Glasgow University, 1992-2002
%
IfGblEnv(..), IfLclEnv(..),
-- Ranamer types
- ErrCtxt, RecFieldEnv,
+ ErrCtxt, RecFieldEnv(..),
ImportAvails(..), emptyImportAvails, plusImportAvails,
WhereFrom(..), mkModDeps,
-- Typechecker types
- TcTyThing(..), pprTcTyThingCategory, RefinementVisibility(..),
+ TcTypeEnv, TcTyThing(..), pprTcTyThingCategory,
-- Template Haskell
- ThStage(..), topStage, topSpliceStage,
- ThLevel, impLevel, topLevel,
+ ThStage(..), topStage, topAnnStage, topSpliceStage,
+ ThLevel, impLevel, outerLevel, thLevel,
-- Arrows
ArrowCtxt(NoArrowCtxt), newArrowScope, escapeArrowScope,
- -- Insts
- Inst(..), InstOrigin(..), InstLoc(..),
- pprInstLoc, pprInstArising, instLocSpan, instLocOrigin,
- LIE, emptyLIE, unitLIE, plusLIE, consLIE, instLoc, instSpan,
- plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE,
+ -- Constraints
+ Untouchables,
+ WantedConstraints, emptyWanteds, andWanteds, extendWanteds,
+ WantedConstraint(..), WantedEvVar(..), wantedEvVarLoc,
+ wantedEvVarToVar, wantedEvVarPred, splitWanteds,
+
+ evVarsToWanteds,
+ Implication(..),
+ CtLoc(..), ctLocSpan, ctLocOrigin, setCtLocOrigin,
+ CtOrigin(..), EqOrigin(..),
+ WantedLoc, GivenLoc,
+
+ SkolemInfo(..),
+
+ -- Pretty printing
+ pprEvVarTheta, pprWantedsWithLocs, pprWantedWithLoc,
+ pprEvVars, pprEvVarWithType,
+ pprArising, pprArisingAt,
-- Misc other types
- TcId, TcIdSet, TcDictBinds,
+ TcId, TcIdSet, TcTyVarBind(..), TcTyVarBinds
) where
#include "HsVersions.h"
-import HsSyn hiding (LIE)
+import HsSyn
import HscTypes
-import Packages
import Type
-import Coercion
import TcType
-import TcGadt
+import Annotations
import InstEnv
import FamInstEnv
import IOEnv
import ErrUtils
import UniqSupply
import BasicTypes
-import Util
import Bag
import Outputable
import ListSetOps
-import FiniteMap
+import FastString
+import StaticFlags( opt_ErrorSpans )
-import Data.Maybe
-import Data.List
+import Data.Set (Set)
\end{code}
\begin{code}
type TcRef a = IORef a
-type TcId = Id -- Type may be a TcType
+type TcId = Id -- Type may be a TcType DV: WHAT??????????
type TcIdSet = IdSet
-type TcDictBinds = DictBinds TcId -- Bag of dictionary bindings
+
type TcRnIf a b c = IOEnv (Env a b) c
type IfM lcl a = TcRnIf IfGblEnv lcl a -- Iface stuff
type TcM a = TcRn a -- Historical
\end{code}
+Representation of type bindings to uninstantiated meta variables used during
+constraint solving.
+
+\begin{code}
+data TcTyVarBind = TcTyVarBind TcTyVar TcType
+
+type TcTyVarBinds = Bag TcTyVarBind
+
+instance Outputable TcTyVarBind where
+ ppr (TcTyVarBind tv ty) = ppr tv <+> text ":=" <+> ppr ty
+\end{code}
+
%************************************************************************
%* *
data TcGblEnv
= TcGblEnv {
- 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_default :: Maybe [Type], -- Types used for defaulting
- -- Nothing => no 'default' decl
-
- tcg_fix_env :: FixityEnv, -- Just for things in this module
- tcg_field_env :: RecFieldEnv, -- 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,
- -- along with their derived constructors, selectors.
- --
- -- (Ids defined in this module start in the local envt,
- -- though they move to the global envt during zonking)
-
- tcg_type_env_var :: TcRef TypeEnv,
+ 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_default :: Maybe [Type],
+ -- ^ Types used for defaulting. @Nothing@ => no @default@ decl
+
+ tcg_fix_env :: FixityEnv, -- ^ Just for things in this module
+ tcg_field_env :: RecFieldEnv, -- ^ 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,
+ -- along with their derived constructors, selectors.
+ --
+ -- (Ids defined in this module start in the local envt, though they
+ -- move to the global envt during zonking)
+
+ 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
- tcg_fam_inst_env :: FamInstEnv, -- Ditto for family instances
+ tcg_inst_env :: InstEnv,
+ -- ^ Instance envt for /home-package/ modules; Includes the dfuns in
+ -- tcg_insts
+ tcg_fam_inst_env :: FamInstEnv, -- ^ Ditto for family instances
-- 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 :: [AvailInfo], -- What is exported
- tcg_imports :: ImportAvails, -- Information about what was imported
- -- from where, including things bound
- -- in this module
-
- 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_exports :: [AvailInfo], -- ^ What is exported
+ tcg_imports :: ImportAvails,
+ -- ^ Information about what was imported from where, including
+ -- things bound in this module.
+
+ 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 OccSet,
+ -- ^ Allows us to choose unique DFun names.
+
+ -- 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_exports :: Maybe [Located (IE Name)],
- tcg_rn_decls :: Maybe (HsGroup Name), -- renamed decls, maybe
- -- Nothing <=> Don't retain renamed decls
+ tcg_rn_imports :: [LImportDecl Name],
+ -- Keep the renamed imports regardless. They are not
+ -- voluminous and are needed if you want to report unused imports
+
+ tcg_used_rdrnames :: TcRef (Set RdrName),
+ -- The set of used *imported* (not locally-defined) RdrNames
+ -- Used only to report unused import declarations
+
+ tcg_rn_decls :: Maybe (HsGroup Name),
+ -- ^ Renamed decls, maybe. @Nothing@ <=> Don't retain renamed
+ -- decls.
+ tcg_ev_binds :: Bag EvBind, -- Top-level evidence bindings
tcg_binds :: LHsBinds Id, -- Value bindings in this module
- tcg_deprecs :: Deprecations, -- ...Deprecations
+ tcg_warns :: Warnings, -- ...Warnings and deprecations
+ tcg_anns :: [Annotation], -- ...Annotations
tcg_insts :: [Instance], -- ...Instances
tcg_fam_insts :: [FamInst], -- ...Family instances
tcg_rules :: [LRuleDecl Id], -- ...Rules
tcg_fords :: [LForeignDecl Id], -- ...Foreign import & exports
- tcg_doc :: Maybe (HsDoc Name), -- Maybe Haddock documentation
- tcg_hmi :: HaddockModInfo Name, -- Haddock module information
- tcg_hpc :: AnyHpcUsage -- True if any part of the prog uses hpc instrumentation.
+ tcg_doc_hdr :: Maybe LHsDocString, -- ^ Maybe Haddock header docs
+ tcg_hpc :: AnyHpcUsage, -- ^ @True@ if any part of the
+ -- prog uses hpc instrumentation.
+
+ tcg_main :: Maybe Name -- ^ The Name of the main
+ -- function, if this module is
+ -- the main module.
}
-type RecFieldEnv = NameEnv [Name] -- Maps a constructor name *in this module*
- -- to the fields for that constructor
+data RecFieldEnv
+ = RecFields (NameEnv [Name]) -- Maps a constructor name *in this module*
+ -- to the fields for that constructor
+ NameSet -- Set of all fields declared *in this module*;
+ -- used to suppress name-shadowing complaints
+ -- when using record wild cards
+ -- E.g. let fld = e in C {..}
-- This is used when dealing with ".." notation in record
-- construction and pattern matching.
- -- The FieldEnv deals *only* with constructors defined in
- -- *thie* module. For imported modules, we get the same info
- -- from the TypeEnv
+ -- The FieldEnv deals *only* with constructors defined in *this*
+ -- module. For imported modules, we get the same info from the
+ -- TypeEnv
\end{code}
%************************************************************************
-- Discarded after typecheck/rename; not passed on to desugarer
= TcLclEnv {
tcl_loc :: SrcSpan, -- Source span
- tcl_ctxt :: ErrCtxt, -- Error context
+ tcl_ctxt :: [ErrCtxt], -- Error context, innermost on top
tcl_errs :: TcRef Messages, -- Place to accumulate errors
- tcl_th_ctxt :: ThStage, -- Template Haskell context
- tcl_arrow_ctxt :: ArrowCtxt, -- Arrow-notation context
+ 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
-- 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 :: TcTypeEnv, -- 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_env,
- -- plus the tyvars mentioned in the types of Ids bound in tcl_lenv
- -- Why mutable? see notes with tcGetGlobalTyVars
+ -- 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 WantedConstraints, -- Place to accumulate type constraints
+ tcl_untch :: Untouchables -- Untouchables
}
+type TcTypeEnv = NameEnv TcTyThing
+
{- Note [Given Insts]
~~~~~~~~~~~~~~~~~~
-}
---------------------------
--- Template Haskell levels
+-- Template Haskell stages and levels
---------------------------
+data ThStage -- See Note [Template Haskell state diagram] in TcSplice
+ = Splice -- Top-level splicing
+ -- This code will be run *at compile time*;
+ -- the result replaces the splice
+ -- Binding level = 0
+
+ | Comp -- Ordinary Haskell code
+ -- Binding level = 1
+
+ | Brack -- Inside brackets
+ ThStage -- Binding level = level(stage) + 1
+ (TcRef [PendingSplice]) -- Accumulate pending splices here
+ (TcRef WantedConstraints) -- and type constraints here
+
+topStage, topAnnStage, topSpliceStage :: ThStage
+topStage = Comp
+topAnnStage = Splice
+topSpliceStage = Splice
+
+instance Outputable ThStage where
+ ppr Splice = text "Splice"
+ ppr Comp = text "Comp"
+ ppr (Brack s _ _) = text "Brack" <> parens (ppr s)
+
type ThLevel = Int
- -- Indicates how many levels of brackets we are inside
- -- (always >= 0)
+ -- See Note [Template Haskell levels] in TcSplice
-- Incremented when going inside a bracket,
-- decremented when going inside a splice
-- NB: ThLevel is one greater than the 'n' in Fig 2 of the
- -- original "Template meta-programmign for Haskell" paper
+ -- original "Template meta-programming for Haskell" paper
-impLevel, topLevel :: ThLevel
-topLevel = 1 -- Things defined at top level of this module
+impLevel, outerLevel :: ThLevel
impLevel = 0 -- Imported things; they can be used inside a top level splice
+outerLevel = 1 -- Things defined outside brackets
+-- NB: Things at level 0 are not *necessarily* imported.
+-- eg $( \b -> ... ) here b is bound at level 0
--
-- For example:
-- f = ...
-- g1 = $(map ...) is OK
-- g2 = $(f ...) is not OK; because we havn't compiled f yet
-
-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
+thLevel :: ThStage -> ThLevel
+thLevel Splice = 0
+thLevel Comp = 1
+thLevel (Brack s _ _) = thLevel s + 1
---------------------------
-- Arrow-notation context
= AGlobal TyThing -- Used only in the return type of a lookup
| ATcId { -- Ids defined in this module; may not be fully zonked
- tct_id :: TcId,
- tct_co :: RefinementVisibility, -- Previously: Maybe HsWrapper
- -- Nothing <=> Do not apply a GADT type refinement
- -- I am wobbly, or have no free
- -- type variables
- -- Just co <=> Apply any type refinement to me,
- -- and record it in the coercion
- tct_type :: TcType, -- Type of (coercion applied to id)
+ tct_id :: TcId,
tct_level :: ThLevel }
| ATyVar Name TcType -- The type to which the lexically scoped type vaiable
-- is currently refined. We only need the Name
- -- for error-message purposes
+ -- for error-message purposes; it is the corresponding
+ -- Name in the domain of the envt
| AThing TcKind -- Used temporarily, during kind checking, for the
-- tycons and clases in this recursive group
-data RefinementVisibility
- = Unrefineable -- Do not apply a GADT refinement
- -- I have no free variables
-
- | Rigid HsWrapper -- Apply any refinement to me
- -- and record it in the coercion
-
- | Wobbly -- Do not apply a GADT refinement
- -- I am wobbly
-
- | WobblyInvisible -- Wobbly type, not available inside current
- -- GADT refinement
-
instance Outputable TcTyThing where -- Debugging only
- ppr (AGlobal g) = ppr g
+ ppr (AGlobal g) = pprTyThing g
ppr elt@(ATcId {}) = text "Identifier" <>
- ifPprDebug (brackets (ppr (tct_id elt) <> dcolon <> ppr (tct_type elt) <> comma
- <+> ppr (tct_level elt) <+> ppr (tct_co elt)))
+ brackets (ppr (tct_id elt) <> dcolon
+ <> ppr (varType (tct_id elt)) <> comma
+ <+> ppr (tct_level elt))
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")
-
-instance Outputable RefinementVisibility where
- ppr Unrefineable = ptext SLIT("unrefineable")
- ppr (Rigid co) = ptext SLIT("rigid") <+> ppr co
- ppr Wobbly = ptext SLIT("wobbly")
- ppr WobblyInvisible = ptext SLIT("wobbly-invisible")
-
+pprTcTyThingCategory (ATyVar {}) = ptext (sLit "Type variable")
+pprTcTyThingCategory (ATcId {}) = ptext (sLit "Local identifier")
+pprTcTyThingCategory (AThing {}) = ptext (sLit "Kinded thing")
\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
+type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, Message))
+ -- Monadic so that we have a chance
+ -- to deal with bound type variables just before error
+ -- message construction
+
+ -- Bool: True <=> this is a landmark context; do not
+ -- discard it when trimming for display
\end{code}
%* *
%************************************************************************
-ImportAvails summarises what was imported from where, irrespective
-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 and
- for optimsed overlap checking of family instances
- * when figuring out what things are really unused
-
\begin{code}
+-- | 'ImportAvails' summarises what was imported from where, irrespective of
+-- whether the imported things are actually used or not. It is used:
+--
+-- * when processing the export list,
+--
+-- * when constructing usage info for the interface file,
+--
+-- * to identify the list of directly imported modules for initialisation
+-- purposes and for optimised overlap checking of family instances,
+--
+-- * when figuring out what things are really unused
+--
data ImportAvails
= ImportAvails {
- imp_mods :: ModuleEnv (Module, [(ModuleName, Bool, SrcSpan)]),
- -- Domain is all directly-imported modules
- -- The ModuleName is what the module was imported as, e.g. in
- -- import Foo as Bar
- -- it is Bar.
- -- 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 somethign we
- -- need to recompile if the export version changes
- -- (b) to specify what child modules to initialise
- --
- -- We need a full ModuleEnv rather than a ModuleNameEnv
- -- here, because we might be importing modules of the
- -- same name from different packages. (currently not the case,
- -- but might be in the future).
+ imp_mods :: ModuleEnv [(ModuleName, Bool, SrcSpan)],
+ -- ^ Domain is all directly-imported modules
+ -- The 'ModuleName' is what the module was imported as, e.g. in
+ -- @
+ -- import Foo as Bar
+ -- @
+ -- it is @Bar@.
+ --
+ -- The 'Bool' means:
+ --
+ -- - @True@ => import was @import Foo ()@
+ --
+ -- - @False@ => import was some other form
+ --
+ -- Used
+ --
+ -- (a) to help construct the usage information in the interface
+ -- file; if we import somethign we need to recompile if the
+ -- export version changes
+ --
+ -- (b) to specify what child modules to initialise
+ --
+ -- We need a full ModuleEnv rather than a ModuleNameEnv here,
+ -- because we might be importing modules of the same name from
+ -- different packages. (currently not the case, but might be in the
+ -- future).
imp_dep_mods :: ModuleNameEnv (ModuleName, 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.
+ -- ^ 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.
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.
+ -- ^ 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 (and maybe
- -- including us for imported modules)
+ -- ^ Orphan modules below us in the import tree (and maybe including
+ -- us for imported modules)
imp_finsts :: [Module]
- -- Family instance modules below us in the import tree (and
- -- maybe including us for imported modules)
+ -- ^ Family instance modules below us in the import tree (and maybe
+ -- including us for imported modules)
}
mkModDeps :: [(ModuleName, IsBootInterface)]
(ImportAvails { imp_mods = mods2,
imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2,
imp_orphs = orphs2, imp_finsts = finsts2 })
- = ImportAvails { imp_mods = plusModuleEnv_C plus_mod mods1 mods2,
+ = ImportAvails { imp_mods = plusModuleEnv_C (++) mods1 mods2,
imp_dep_mods = plusUFM_C plus_mod_dep dmods1 dmods2,
imp_dep_pkgs = dpkgs1 `unionLists` dpkgs2,
imp_orphs = orphs1 `unionLists` orphs2,
imp_finsts = finsts1 `unionLists` finsts2 }
where
- plus_mod (m1, xs1) (_, xs2) = (m1, xs1 ++ xs2)
plus_mod_dep (m1, boot1) (m2, boot2)
= WARN( not (m1 == m2), (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )
-- Check mod-names match
| ImportBySystem -- Non user import.
instance Outputable WhereFrom where
- ppr (ImportByUser is_boot) | is_boot = ptext SLIT("{- SOURCE -}")
+ ppr (ImportByUser is_boot) | is_boot = ptext (sLit "{- SOURCE -}")
| otherwise = empty
- ppr ImportBySystem = ptext SLIT("{- SYSTEM -}")
+ ppr ImportBySystem = ptext (sLit "{- SYSTEM -}")
\end{code}
%************************************************************************
%* *
-\subsection[Inst-types]{@Inst@ types}
+ Wanted constraints
+
+ These are forced to be in TcRnTypes because
+ TcLclEnv mentions WantedConstraints
+ WantedConstraint mentions CtLoc
+ CtLoc mentions ErrCtxt
+ ErrCtxt mentions TcM
%* *
v%************************************************************************
-An @Inst@ is either a dictionary, an instance of an overloaded
-literal, or an instance of an overloaded value. We call the latter a
-``method'' even though it may not correspond to a class operation.
-For example, we might have an instance of the @double@ function at
-type Int, represented by
+\begin{code}
+type Untouchables = TcTyVarSet -- All MetaTyVars
- Method 34 doubleId [Int] origin
+type WantedConstraints = Bag WantedConstraint
-In addition to the basic Haskell variants of 'Inst's, they can now also
-represent implication constraints 'forall tvs. (reft, given) => wanted'
-and equality constraints 'co :: ty1 ~ ty2'.
+data WantedConstraint
+ = WcEvVar WantedEvVar
+ | WcImplic Implication
+ -- ToDo: add literals, methods
-\begin{code}
-data Inst
- = Dict {
- tci_name :: Name,
- tci_pred :: TcPredType,
- tci_loc :: InstLoc
- }
+-- EvVar defined in module Var.lhs:
+-- Evidence variables include all *quantifiable* constraints
+-- dictionaries
+-- implicit parameters
+-- coercion variables
- | ImplicInst { -- An implication constraint
- -- forall tvs. (reft, given) => wanted
- tci_name :: Name,
- tci_tyvars :: [TcTyVar], -- Quantified type variables
- -- Includes coercion variables
- -- mentioned in tci_reft
- tci_reft :: Refinement,
- tci_given :: [Inst], -- Only Dicts
- -- (no Methods, LitInsts, ImplicInsts)
- tci_wanted :: [Inst], -- Only Dicts and ImplicInsts
- -- (no Methods or LitInsts)
-
- tci_loc :: InstLoc
- }
- -- NB: the tci_given are not necessarily rigid,
- -- although they will be if the tci_reft is non-trivial
- -- NB: the tci_reft is already applied to tci_given and tci_wanted
+data WantedEvVar -- The sort of constraint over which one can lambda-abstract
+ = WantedEvVar
+ EvVar -- The variable itself; make a binding for it please
+ WantedLoc -- How the constraint arose in the first place
+ -- (used for error messages only)
- | Method {
- tci_id :: TcId, -- The Id for the Inst
+type WantedLoc = CtLoc CtOrigin
+type GivenLoc = CtLoc SkolemInfo
- tci_oid :: TcId, -- The overloaded function
- -- This function will be a global, local, or ClassOpId;
- -- inside instance decls (only) it can also be an InstId!
- -- The id needn't be completely polymorphic.
- -- You'll probably find its name (for documentation purposes)
- -- inside the InstOrigin
+data Implication
+ = Implic {
+ ic_env_tvs :: Untouchables, -- Untouchables: unification variables
+ -- free in the environment
+ ic_env :: TcTypeEnv, -- The type environment
+ -- Used only when generating error messages
+ -- Generally, ic_env_tvs = tvsof(ic_env)
+ -- However, we don't zonk ic_env when zonking the Implication
+ -- Instead we do that when generating a skolem-escape error message
- tci_tys :: [TcType], -- The types to which its polymorphic tyvars
- -- should be instantiated.
- -- These types must saturate the Id's foralls.
+ ic_skols :: TcTyVarSet, -- Introduced skolems
+ -- See Note [Skolems in an implication]
- tci_theta :: TcThetaType,
- -- The (types of the) dictionaries to which the function
- -- must be applied to get the method
+ ic_scoped :: [TcTyVar], -- List of scoped variables to be unified
+ -- bijectively to a subset of ic_tyvars
+ -- Note [Scoped pattern variable]
- tci_loc :: InstLoc
- }
- -- INVARIANT 1: in (Method m f tys theta tau loc)
- -- type of m = type of (f tys dicts(from theta))
-
- -- INVARIANT 2: type of m 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 {
- tci_name :: Name,
- tci_lit :: 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
-
- tci_ty :: TcType, -- The type at which the literal is used
- tci_loc :: InstLoc
- }
+ ic_given :: [EvVar], -- Given evidence variables
+ -- (order does not matter)
- | EqInst { -- delayed unification of the form
- -- co :: ty1 ~ ty2
- tci_left :: TcType, -- ty1
- tci_right :: TcType, -- ty2
- tci_co :: Either -- co
- TcTyVar -- a wanted equation, with a hole, to be
- -- filled with a witness for the equality
- -- for equation generated by the
- -- unifier, 'ty1' is the actual and
- -- 'ty2' the expected type
- Coercion, -- a given equation, with a coercion
- -- witnessing the equality
- -- a coercion that originates from a
- -- signature or a GADT is a CoVar, but
- -- after normalisation of coercions,
- -- they can be arbitrary Coercions
- -- involving constructors and
- -- pseudo-constructors like sym and
- -- trans.
- tci_loc :: InstLoc,
-
- tci_name :: Name -- Debugging help only: this makes it easier to
- -- follow where a constraint is used in a morass
- -- of trace messages! Unlike other Insts, it has
- -- no semantic significance whatsoever.
- }
-\end{code}
+ ic_wanted :: WantedConstraints, -- Wanted constraints
-@Insts@ are ordered by their class/type info, rather than by their
-unique. This allows the context-reduction mechanism to use standard finite
-maps to do their stuff. It's horrible that this code is here, rather
-than with the Avails handling stuff in TcSimplify
+ ic_binds :: EvBindsVar, -- Points to the place to fill in the
+ -- abstraction and bindings
-\begin{code}
-instance Ord Inst where
- compare = cmpInst
-
-instance Eq Inst where
- (==) i1 i2 = case i1 `cmpInst` i2 of
- EQ -> True
- other -> False
-
-cmpInst d1@(Dict {}) d2@(Dict {}) = tci_pred d1 `tcCmpPred` tci_pred d2
-cmpInst (Dict {}) other = LT
-
-cmpInst (Method {}) (Dict {}) = GT
-cmpInst m1@(Method {}) m2@(Method {}) = (tci_oid m1 `compare` tci_oid m2) `thenCmp`
- (tci_tys m1 `tcCmpTypes` tci_tys m2)
-cmpInst (Method {}) other = LT
-
-cmpInst (LitInst {}) (Dict {}) = GT
-cmpInst (LitInst {}) (Method {}) = GT
-cmpInst l1@(LitInst {}) l2@(LitInst {}) = (tci_lit l1 `compare` tci_lit l2) `thenCmp`
- (tci_ty l1 `tcCmpType` tci_ty l2)
-cmpInst (LitInst {}) other = LT
-
- -- Implication constraints are compared by *name*
- -- not by type; that is, we make no attempt to do CSE on them
-cmpInst (ImplicInst {}) (Dict {}) = GT
-cmpInst (ImplicInst {}) (Method {}) = GT
-cmpInst (ImplicInst {}) (LitInst {}) = GT
-cmpInst i1@(ImplicInst {}) i2@(ImplicInst {}) = tci_name i1 `compare` tci_name i2
-cmpInst (ImplicInst {}) other = LT
-
- -- same for Equality constraints
-cmpInst (EqInst {}) (Dict {}) = GT
-cmpInst (EqInst {}) (Method {}) = GT
-cmpInst (EqInst {}) (LitInst {}) = GT
-cmpInst (EqInst {}) (ImplicInst {}) = GT
-cmpInst i1@(EqInst {}) i2@(EqInst {}) = tci_name i1 `compare` tci_name i2
+ ic_loc :: GivenLoc }
+
+evVarsToWanteds :: WantedLoc -> [EvVar] -> WantedConstraints
+evVarsToWanteds loc evs = listToBag [WcEvVar (WantedEvVar ev loc) | ev <- evs]
+
+wantedEvVarLoc :: WantedEvVar -> WantedLoc
+wantedEvVarLoc (WantedEvVar _ loc) = loc
+
+wantedEvVarToVar :: WantedEvVar -> EvVar
+wantedEvVarToVar (WantedEvVar ev _) = ev
+
+wantedEvVarPred :: WantedEvVar -> PredType
+wantedEvVarPred (WantedEvVar ev _) = evVarPred ev
+
+splitWanteds :: WantedConstraints -> (Bag WantedEvVar, Bag Implication)
+splitWanteds wanted = partitionBagWith pick wanted
+ where
+ pick (WcEvVar v) = Left v
+ pick (WcImplic i) = Right i
\end{code}
+Note [Skolems in an implication]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The skolems in an implication are not there to perform a skolem escape
+check. That happens because all the environment variables are in the
+untouchables, and therefore cannot be unified with anything at all,
+let alone the skolems.
-%************************************************************************
-%* *
-\subsection[Inst-collections]{LIE: a collection of Insts}
-%* *
-%************************************************************************
+Instead, ic_skols is used only when considering floating a constraint
+outside the implication in TcSimplify.floatEqualities or
+TcSimplify.approximateImplications
+
+Note [Scoped pattern variables]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ data T where K :: forall a,b. a -> b -> T
+
+ ...(case x of K (p::c) (q::d) -> ...)...
+
+We create fresh MetaTvs for c,d, and later check that they are
+bound bijectively to the skolems we created for a,b. So the
+implication constraint looks like
+ ic_skols = {a',b'} -- Skolem tvs created from a,b
+ ic_scoped = {c',d'} -- Meta tvs created from c,d
\begin{code}
--- FIXME: Rename this. It clashes with (Located (IE ...))
-type LIE = Bag Inst
-
-isEmptyLIE = isEmptyBag
-emptyLIE = emptyBag
-unitLIE inst = unitBag inst
-mkLIE insts = listToBag insts
-plusLIE lie1 lie2 = lie1 `unionBags` lie2
-plusLIEs lies = unionManyBags lies
-lieToList = bagToList
-listToLIE = listToBag
-
-consLIE inst lie = lie `snocBag` inst
--- Putting the new Inst at the *end* of the bag is a half-hearted attempt
--- to ensure that we tend to report the *leftmost* type-constraint error
--- E.g. f :: [a]
--- f = [1,2,3]
--- we'd like to complain about the '1', not the '3'.
---
--- "Half-hearted" because the rest of the type checker makes no great
--- claims for retaining order in the constraint set. Still, this
--- seems to improve matters slightly. Exampes: mdofail001, tcfail015
-\end{code}
+emptyWanteds :: WantedConstraints
+emptyWanteds = emptyBag
+
+andWanteds :: WantedConstraints -> WantedConstraints -> WantedConstraints
+andWanteds = unionBags
+extendWanteds :: WantedConstraints -> WantedConstraint -> WantedConstraints
+extendWanteds = snocBag
+\end{code}
+
+\begin{code}
+pprEvVars :: [EvVar] -> SDoc -- Print with their types
+pprEvVars ev_vars = vcat (map pprEvVarWithType ev_vars)
+
+pprEvVarTheta :: [EvVar] -> SDoc
+pprEvVarTheta ev_vars = pprTheta (map evVarPred ev_vars)
+
+pprEvVarWithType :: EvVar -> SDoc
+pprEvVarWithType v = ppr v <+> dcolon <+> pprPred (evVarPred v)
+
+pprWantedsWithLocs :: Bag WantedConstraint -> SDoc
+pprWantedsWithLocs = foldrBag (($$) . pprWantedWithLoc) empty
+
+pprWantedWithLoc :: WantedConstraint -> SDoc
+pprWantedWithLoc (WcImplic i) = ppr i
+pprWantedWithLoc (WcEvVar v) = pprWantedEvVarWithLoc v
+
+instance Outputable WantedConstraint where
+ ppr (WcEvVar v) = ppr v
+ ppr (WcImplic i) = ppr i
+
+-- Adding -ferror-spans makes the output more voluminous
+instance Outputable WantedEvVar where
+ ppr wev | opt_ErrorSpans = pprWantedEvVarWithLoc wev
+ | otherwise = pprWantedEvVar wev
+
+pprWantedEvVarWithLoc, pprWantedEvVar :: WantedEvVar -> SDoc
+pprWantedEvVarWithLoc (WantedEvVar v loc) = hang (pprEvVarWithType v)
+ 2 (pprArisingAt loc)
+pprWantedEvVar (WantedEvVar v _) = pprEvVarWithType v
+
+instance Outputable Implication where
+ ppr (Implic { ic_env_tvs = env_tvs, ic_skols = skols, ic_given = given
+ , ic_wanted = wanted, ic_binds = binds, ic_loc = loc })
+ = ptext (sLit "Implic") <+> braces
+ (sep [ ptext (sLit "Untouchables = ") <+> ppr env_tvs
+ , ptext (sLit "Skolems = ") <+> ppr skols
+ , ptext (sLit "Given = ") <+> pprEvVars given
+ , ptext (sLit "Wanted = ") <+> ppr wanted
+ , ptext (sLit "Binds = ") <+> ppr binds
+ , pprSkolInfo (ctLocOrigin loc)
+ , ppr (ctLocSpan loc) ])
+\end{code}
%************************************************************************
%* *
-\subsection[Inst-origin]{The @InstOrigin@ type}
+ CtLoc, CtOrigin
%* *
%************************************************************************
-The @InstOrigin@ type gives information about where a dictionary came from.
-This is important for decent error message reporting because dictionaries
-don't appear in the original source code. Doubtless this type will evolve...
-
-It appears in TcMonad because there are a couple of error-message-generation
-functions that deal with it.
+The 'CtLoc' and 'CtOrigin' types gives information about where a
+*wanted constraint* came from. This is important for decent error
+message reporting because dictionaries don't appear in the original
+source code. Doubtless this type will evolve...
\begin{code}
-------------------------------------------
-data InstLoc = InstLoc InstOrigin SrcSpan ErrCtxt
-
-instLoc :: Inst -> InstLoc
-instLoc inst = tci_loc inst
+data CtLoc orig = CtLoc orig SrcSpan [ErrCtxt]
-instSpan :: Inst -> SrcSpan
-instSpan wanted = instLocSpan (instLoc wanted)
+ctLocSpan :: CtLoc o -> SrcSpan
+ctLocSpan (CtLoc _ s _) = s
-instLocSpan :: InstLoc -> SrcSpan
-instLocSpan (InstLoc _ s _) = s
+ctLocOrigin :: CtLoc o -> o
+ctLocOrigin (CtLoc o _ _) = o
-instLocOrigin :: InstLoc -> InstOrigin
-instLocOrigin (InstLoc o _ _) = o
+setCtLocOrigin :: CtLoc o -> o' -> CtLoc o'
+setCtLocOrigin (CtLoc _ s c) o = CtLoc o s c
-pprInstArising :: Inst -> SDoc
-pprInstArising loc = ptext SLIT("arising from") <+> pprInstLoc (tci_loc loc)
+pprArising :: CtOrigin -> SDoc
+pprArising (TypeEqOrigin {}) = empty
+pprArising orig = text "arising from" <+> ppr orig
-pprInstLoc :: InstLoc -> SDoc
-pprInstLoc (InstLoc orig span _) = sep [ppr orig, text "at" <+> ppr span]
+pprArisingAt :: CtLoc CtOrigin -> SDoc
+pprArisingAt (CtLoc o s _) = sep [pprArising o, text "at" <+> ppr s]
-------------------------------------------
-data InstOrigin
- = SigOrigin SkolemInfo -- Pattern, class decl, inst decl etc;
- -- Places that bind type variables and introduce
- -- available constraints
+-- CtOrigin gives the origin of *wanted* constraints
+data CtOrigin
+ = OccurrenceOf Name -- Occurrence of an overloaded identifier
+ | AppOrigin -- An application of some kind
- | IPBindOrigin (IPName Name) -- Binding site of an implicit parameter
+ | SpecPragOrigin Name -- Specialisation pragma for identifier
- -------------------------------------------------------
- -- The rest are all occurrences: Insts that are 'wanted'
- -------------------------------------------------------
- | OccurrenceOf Name -- Occurrence of an overloaded identifier
+ | TypeEqOrigin EqOrigin
| IPOccOrigin (IPName Name) -- Occurrence of an implicit parameter
| LiteralOrigin (HsOverLit Name) -- Occurrence of a literal
+ | NegateOrigin -- Occurrence of syntactic negation
| ArithSeqOrigin (ArithSeqInfo Name) -- [x..], [x..y] etc
| PArrSeqOrigin (ArithSeqInfo Name) -- [:x..y:] and [:x,y..z:]
-
- | InstSigOrigin -- A dict occurrence arising from instantiating
- -- a polymorphic type during a subsumption check
-
+ | SectionOrigin
+ | TupleOrigin -- (..,..)
+ | ExprSigOrigin -- e :: ty
+ | PatSigOrigin -- p :: ty
+ | PatOrigin -- Instantiating a polytyped pattern at a constructor
| RecordUpdOrigin
- | InstScOrigin -- Typechecking superclasses of an instance declaration
+ | ViewPatOrigin
+
+ | ScOrigin -- Typechecking superclasses of an instance declaration
| DerivOrigin -- Typechecking deriving
| StandAloneDerivOrigin -- Typechecking stand-alone deriving
| DefaultOrigin -- Typechecking a default decl
| DoOrigin -- Arising from a do expression
| ProcOrigin -- Arising from a proc expression
- | ImplicOrigin SDoc -- An implication constraint
- | EqOrigin -- A type equality
-
-instance Outputable InstOrigin where
- ppr (OccurrenceOf name) = hsep [ptext SLIT("a use of"), quotes (ppr name)]
- ppr (IPOccOrigin name) = hsep [ptext SLIT("a use of implicit parameter"), quotes (ppr name)]
- ppr (IPBindOrigin name) = hsep [ptext SLIT("a binding for implicit parameter"), quotes (ppr name)]
- ppr RecordUpdOrigin = ptext SLIT("a record update")
- ppr (LiteralOrigin lit) = hsep [ptext SLIT("the literal"), quotes (ppr lit)]
- ppr (ArithSeqOrigin seq) = hsep [ptext SLIT("the arithmetic sequence"), quotes (ppr seq)]
- ppr (PArrSeqOrigin seq) = hsep [ptext SLIT("the parallel array sequence"), quotes (ppr seq)]
- ppr InstSigOrigin = ptext SLIT("instantiating a type signature")
- ppr InstScOrigin = ptext SLIT("the superclasses of an instance declaration")
- ppr DerivOrigin = ptext SLIT("the 'deriving' clause of a data type declaration")
- ppr StandAloneDerivOrigin = ptext SLIT("a 'deriving' declaration")
- ppr DefaultOrigin = ptext SLIT("a 'default' declaration")
- ppr DoOrigin = ptext SLIT("a do statement")
- ppr ProcOrigin = ptext SLIT("a proc expression")
- ppr (ImplicOrigin doc) = doc
- ppr (SigOrigin info) = pprSkolInfo info
- ppr EqOrigin = ptext SLIT("a type equality")
-
+ | AnnOrigin -- An annotation
+
+data EqOrigin
+ = UnifyOrigin
+ { uo_actual :: TcType
+ , uo_expected :: TcType }
+
+instance Outputable CtOrigin where
+ ppr orig = pprO orig
+
+pprO :: CtOrigin -> SDoc
+pprO (OccurrenceOf name) = hsep [ptext (sLit "a use of"), quotes (ppr name)]
+pprO AppOrigin = ptext (sLit "an application")
+pprO (SpecPragOrigin name) = hsep [ptext (sLit "a specialisation pragma for"), quotes (ppr name)]
+pprO (IPOccOrigin name) = hsep [ptext (sLit "a use of implicit parameter"), quotes (ppr name)]
+pprO RecordUpdOrigin = ptext (sLit "a record update")
+pprO ExprSigOrigin = ptext (sLit "an expression type signature")
+pprO PatSigOrigin = ptext (sLit "a pattern type signature")
+pprO PatOrigin = ptext (sLit "a pattern")
+pprO ViewPatOrigin = ptext (sLit "a view pattern")
+pprO (LiteralOrigin lit) = hsep [ptext (sLit "the literal"), quotes (ppr lit)]
+pprO (ArithSeqOrigin seq) = hsep [ptext (sLit "the arithmetic sequence"), quotes (ppr seq)]
+pprO (PArrSeqOrigin seq) = hsep [ptext (sLit "the parallel array sequence"), quotes (ppr seq)]
+pprO SectionOrigin = ptext (sLit "an operator section")
+pprO TupleOrigin = ptext (sLit "a tuple")
+pprO NegateOrigin = ptext (sLit "a use of syntactic negation")
+pprO ScOrigin = ptext (sLit "the superclasses of an instance declaration")
+pprO DerivOrigin = ptext (sLit "the 'deriving' clause of a data type declaration")
+pprO StandAloneDerivOrigin = ptext (sLit "a 'deriving' declaration")
+pprO DefaultOrigin = ptext (sLit "a 'default' declaration")
+pprO DoOrigin = ptext (sLit "a do statement")
+pprO ProcOrigin = ptext (sLit "a proc expression")
+pprO (TypeEqOrigin eq) = ptext (sLit "an equality") <+> ppr eq
+pprO AnnOrigin = ptext (sLit "an annotation")
+
+instance Outputable EqOrigin where
+ ppr (UnifyOrigin t1 t2) = ppr t1 <+> char '~' <+> ppr t2
\end{code}
projects / ghc-hetmet.git / blobdiff