%
+% (c) The University of Glasgow 2006
% (c) The GRASP Project, Glasgow University, 1992-2002
%
\begin{code}
-- Ranamer types
ErrCtxt,
ImportAvails(..), emptyImportAvails, plusImportAvails,
- plusAvail, pruneAvails,
- AvailEnv, emptyAvailEnv, unitAvailEnv, plusAvailEnv,
- mkAvailEnv, lookupAvailEnv, lookupAvailEnv_maybe, availEnvElts, addAvail,
WhereFrom(..), mkModDeps,
-- Typechecker types
ArrowCtxt(NoArrowCtxt), newArrowScope, escapeArrowScope,
-- Insts
- Inst(..), InstOrigin(..), InstLoc(..), pprInstLoc,
- instLocSrcLoc, instLocSrcSpan,
- LIE, emptyLIE, unitLIE, plusLIE, consLIE,
+ Inst(..), InstOrigin(..), InstLoc(..),
+ pprInstLoc, pprInstArising, instLocSpan, instLocOrigin,
+ LIE, emptyLIE, unitLIE, plusLIE, consLIE, instLoc, instSpan,
plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE,
-- Misc other types
#include "HsVersions.h"
-import HsSyn ( PendingSplice, HsOverLit, LRuleDecl, LForeignDecl,
- ArithSeqInfo, DictBinds, LHsBinds, LImportDecl, HsGroup,
- ExprCoFn, IE )
-import HscTypes ( FixityEnv,
- HscEnv, TypeEnv, TyThing,
- GenAvailInfo(..), AvailInfo, HscSource(..),
- availName, IsBootInterface, Deprecations )
-import Packages ( PackageId )
-import Type ( Type, pprTyThingCategory )
-import TcType ( TcTyVarSet, TcType, TcThetaType, SkolemInfo, TvSubst,
- TcPredType, TcKind, tcCmpPred, tcCmpType, tcCmpTypes, pprSkolInfo )
-import InstEnv ( Instance, InstEnv )
+import HsSyn hiding (LIE)
+import HscTypes
+import Packages
+import Type
+import TcType
+import TcGadt
+import InstEnv
+import FamInstEnv
import IOEnv
-import RdrName ( GlobalRdrEnv, LocalRdrEnv )
-import Name ( Name )
+import RdrName
+import Name
import NameEnv
-import NameSet ( NameSet, unionNameSets, DefUses )
-import Var ( Id, TyVar )
-import VarEnv ( TidyEnv )
+import NameSet
+import Var
+import VarEnv
import Module
import UniqFM
-import SrcLoc ( SrcSpan, SrcLoc, Located, srcSpanStart )
-import VarSet ( IdSet )
-import ErrUtils ( Messages, Message )
-import UniqFM ( UniqFM )
-import UniqSupply ( UniqSupply )
-import BasicTypes ( IPName )
-import Util ( thenCmp )
+import SrcLoc
+import VarSet
+import ErrUtils
+import UniqSupply
+import BasicTypes
+import Util
import Bag
import Outputable
-import Maybe ( mapMaybe )
-import ListSetOps ( unionLists )
+import ListSetOps
+
+import Data.Maybe
+import Data.List
\end{code}
-- 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_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 :: NameSet, -- What is exported
+ tcg_exports :: [AvailInfo], -- What is exported
tcg_imports :: ImportAvails, -- Information about what was imported
-- from where, including things bound
-- in this module
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 :: [Instance], -- ...Instances
- tcg_rules :: [LRuleDecl Id], -- ...Rules
- tcg_fords :: [LForeignDecl Id] -- ...Foreign import & exports
+ tcg_binds :: LHsBinds Id, -- Value bindings in this module
+ tcg_deprecs :: Deprecations, -- ...Deprecations
+ 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
}
\end{code}
-- 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.
+ --
+ -- Used only for names bound within a value binding (bound by
+ -- lambda, case, where, let etc), but *not* for top-level names.
+ --
+ -- 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)
--
- -- 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
| ATcId { -- Ids defined in this module; may not be fully zonked
tct_id :: TcId,
- tct_co :: Maybe ExprCoFn, -- Nothing <=> Do not apply a GADT type refinement
+ tct_co :: 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,
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
+ for initialisation purposes and
+ for optimsed overlap checking of family instances
* when figuring out what things are really unused
\begin{code}
data ImportAvails
= ImportAvails {
- imp_env :: ModuleNameEnv 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 means:
-- 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
-- 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
+ imp_orphs :: [Module],
+ -- 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)
}
mkModDeps :: [(ModuleName, IsBootInterface)]
add env elt@(m,_) = addToUFM env m elt
emptyImportAvails :: ImportAvails
-emptyImportAvails = ImportAvails { imp_env = emptyUFM,
- imp_mods = emptyModuleEnv,
+emptyImportAvails = ImportAvails { imp_mods = emptyModuleEnv,
imp_dep_mods = emptyUFM,
imp_dep_pkgs = [],
- imp_orphs = [] }
+ imp_orphs = [],
+ imp_finsts = [] }
plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails
plusImportAvails
- (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 = plusUFM_C unionNameSets env1 env2,
- imp_mods = mods1 `plusModuleEnv` mods2,
+ (ImportAvails { imp_mods = mods1,
+ imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1,
+ imp_orphs = orphs1, imp_finsts = finsts1 })
+ (ImportAvails { imp_mods = mods2,
+ imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2,
+ imp_orphs = orphs2, imp_finsts = finsts2 })
+ = ImportAvails { imp_mods = mods1 `plusModuleEnv` mods2,
imp_dep_mods = plusUFM_C plus_mod_dep dmods1 dmods2,
imp_dep_pkgs = dpkgs1 `unionLists` dpkgs2,
- imp_orphs = orphs1 `unionLists` orphs2 }
+ imp_orphs = orphs1 `unionLists` orphs2,
+ imp_finsts = finsts1 `unionLists` finsts2 }
where
plus_mod_dep (m1, boot1) (m2, boot2)
= WARN( not (m1 == m2), (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )
%************************************************************************
%* *
- Avails, AvailEnv, etc
-%* *
-v%************************************************************************
-
-\begin{code}
-plusAvail (Avail n1) (Avail n2) = Avail n1
-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])
-#endif
-
--------------------------
-pruneAvails :: (Name -> Bool) -- Keep if this is True
- -> [AvailInfo]
- -> [AvailInfo]
-pruneAvails keep avails
- = mapMaybe del avails
- where
- del :: AvailInfo -> Maybe AvailInfo -- Nothing => nothing left!
- del (Avail n) | keep n = Just (Avail n)
- | otherwise = Nothing
- del (AvailTC n ns) | null ns' = Nothing
- | otherwise = Just (AvailTC n ns')
- where
- ns' = filter keep ns
-\end{code}
-
----------------------------------------
- AvailEnv and friends
----------------------------------------
-
-\begin{code}
-type AvailEnv = NameEnv AvailInfo -- Maps a Name to the AvailInfo that contains it
-
-emptyAvailEnv :: AvailEnv
-emptyAvailEnv = emptyNameEnv
-
-unitAvailEnv :: AvailInfo -> AvailEnv
-unitAvailEnv a = unitNameEnv (availName a) a
-
-plusAvailEnv :: AvailEnv -> AvailEnv -> AvailEnv
-plusAvailEnv = plusNameEnv_C plusAvail
-
-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
-
-addAvail :: AvailEnv -> AvailInfo -> AvailEnv
-addAvail avails avail = extendNameEnv_C plusAvail avails (availName avail) avail
-
-mkAvailEnv :: [AvailInfo] -> AvailEnv
- -- 'avails' may have several items with the same availName
- -- E.g import Ix( Ix(..), index )
- -- will give Ix(Ix,index,range) and Ix(index)
- -- We want to combine these; addAvail does that
-mkAvailEnv avails = foldl addAvail emptyAvailEnv avails
-\end{code}
-
-%************************************************************************
-%* *
\subsection{Where from}
%* *
%************************************************************************
\begin{code}
data Inst
- = Dict
- Name
- TcPredType
- InstLoc
-
- | Method
- Id
-
- 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
-
- [TcType] -- The types to which its polymorphic tyvars
- -- should be instantiated.
- -- These types must saturate the Id's foralls.
-
- TcThetaType -- The (types of the) dictionaries to which the function
- -- must be applied to get the method
+ = Dict {
+ tci_name :: Name,
+ tci_pred :: TcPredType,
+ tci_loc :: InstLoc
+ }
- InstLoc
+ | 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
+
+ | Method {
+ tci_id :: TcId, -- The Id for the Inst
+
+ 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
+
+ tci_tys :: [TcType], -- The types to which its polymorphic tyvars
+ -- should be instantiated.
+ -- These types must saturate the Id's foralls.
+
+ tci_theta :: TcThetaType,
+ -- The (types of the) dictionaries to which the function
+ -- must be applied to get the method
- -- INVARIANT 1: in (Method u f tys theta tau loc)
- -- type of (f tys dicts(from theta)) = tau
+ 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: tau must not be of form (Pred -> Tau)
+ -- 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
- 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
+ | 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
+ }
\end{code}
@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.
+maps to do their stuff. It's horrible that this code is here, rather
+than with the Avails handling stuff in TcSimplify
\begin{code}
instance Ord Inst where
EQ -> True
other -> False
-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 (LitInst _ _ _ _) (Dict _ _ _) = GT
-cmpInst (LitInst _ _ _ _) (Method _ _ _ _ _) = GT
-cmpInst (LitInst _ lit1 ty1 _) (LitInst _ lit2 ty2 _) = (lit1 `compare` lit2) `thenCmp` (ty1 `tcCmpType` ty2)
+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
\end{code}
unitLIE inst = unitBag inst
mkLIE insts = listToBag insts
plusLIE lie1 lie2 = lie1 `unionBags` lie2
-consLIE inst lie = inst `consBag` lie
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}
functions that deal with it.
\begin{code}
+-------------------------------------------
data InstLoc = InstLoc InstOrigin SrcSpan ErrCtxt
-instLocSrcLoc :: InstLoc -> SrcLoc
-instLocSrcLoc (InstLoc _ src_span _) = srcSpanStart src_span
+instLoc :: Inst -> InstLoc
+instLoc inst = tci_loc inst
+
+instSpan :: Inst -> SrcSpan
+instSpan wanted = instLocSpan (instLoc wanted)
+
+instLocSpan :: InstLoc -> SrcSpan
+instLocSpan (InstLoc _ s _) = s
+
+instLocOrigin :: InstLoc -> InstOrigin
+instLocOrigin (InstLoc o _ _) = o
+
+pprInstArising :: Inst -> SDoc
+pprInstArising loc = ptext SLIT("arising from") <+> pprInstLoc (tci_loc loc)
-instLocSrcSpan :: InstLoc -> SrcSpan
-instLocSrcSpan (InstLoc _ src_span _) = src_span
+pprInstLoc :: InstLoc -> SDoc
+pprInstLoc (InstLoc orig span _) = sep [ppr orig, text "at" <+> ppr span]
+-------------------------------------------
data InstOrigin
= SigOrigin SkolemInfo -- Pattern, class decl, inst decl etc;
-- Places that bind type variables and introduce
| RecordUpdOrigin
| InstScOrigin -- 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
-\end{code}
-
-\begin{code}
-pprInstLoc :: InstLoc -> SDoc
-pprInstLoc (InstLoc orig locn _)
- = sep [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 (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
+ | ImplicOrigin SDoc -- An implication constraint
+
+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
\end{code}
projects / ghc-hetmet.git / blobdiff