X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcRnTypes.lhs;h=86f1dfcc797f43960bcabf50958dfe5a6bfed740;hp=f66abdc67912829d0eb04bb83bc5c58af0fb3507;hb=ebec49fed627b7dd17e297ddc79a9c677a2ce538;hpb=3e83dfb21b2f2220dce97427fff5c19459ae68d1 diff --git a/compiler/typecheck/TcRnTypes.lhs b/compiler/typecheck/TcRnTypes.lhs index f66abdc..86f1dfc 100644 --- a/compiler/typecheck/TcRnTypes.lhs +++ b/compiler/typecheck/TcRnTypes.lhs @@ -1,4 +1,5 @@ -% + +% (c) The University of Glasgow 2006 % (c) The GRASP Project, Glasgow University, 1992-2002 % \begin{code} @@ -12,15 +13,12 @@ module TcRnTypes( IfGblEnv(..), IfLclEnv(..), -- Ranamer types - ErrCtxt, + ErrCtxt, RecFieldEnv, ImportAvails(..), emptyImportAvails, plusImportAvails, - plusAvail, pruneAvails, - AvailEnv, emptyAvailEnv, unitAvailEnv, plusAvailEnv, - mkAvailEnv, lookupAvailEnv, lookupAvailEnv_maybe, availEnvElts, addAvail, WhereFrom(..), mkModDeps, -- Typechecker types - TcTyThing(..), pprTcTyThingCategory, + TcTyThing(..), pprTcTyThingCategory, RefinementVisibility(..), -- Template Haskell ThStage(..), topStage, topSpliceStage, @@ -30,49 +28,47 @@ module TcRnTypes( ArrowCtxt(NoArrowCtxt), newArrowScope, escapeArrowScope, -- Insts - Inst(..), InstOrigin(..), InstLoc(..), pprInstLoc, - instLocSrcLoc, instLocSrcSpan, - LIE, emptyLIE, unitLIE, plusLIE, consLIE, + Inst(..), EqInstCo, InstOrigin(..), InstLoc(..), + pprInstLoc, pprInstArising, instLocSpan, instLocOrigin, + LIE, emptyLIE, unitLIE, plusLIE, consLIE, instLoc, instSpan, plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE, -- Misc other types - TcId, TcIdSet, TcDictBinds + TcId, TcIdSet, TcDictBinds, + ) where #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 Type +import Coercion +import TcType +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 LazyUniqFM +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 FastString + +import Data.Maybe +import Data.List \end{code} @@ -120,8 +116,7 @@ data Env gbl lcl -- Changes as we move into an expression env_gbl :: gbl, -- Info about things defined at the top level -- of the module being compiled - env_lcl :: lcl -- Nested stuff; changes as we go into - -- an expression + env_lcl :: lcl -- Nested stuff; changes as we go into } -- TcGblEnv describes the top-level of the module at the @@ -138,7 +133,8 @@ data TcGblEnv tcg_default :: Maybe [Type], -- Types used for defaulting -- Nothing => no 'default' decl - tcg_fix_env :: FixityEnv, -- Just for things in this module + 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, @@ -147,19 +143,22 @@ data TcGblEnv -- (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_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_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 @@ -209,22 +208,30 @@ data TcGblEnv -- 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 :: [Instance], -- ...Instances - tcg_rules :: [LRuleDecl Id], -- ...Rules - tcg_fords :: [LForeignDecl Id] -- ...Foreign import & exports + tcg_binds :: LHsBinds Id, -- Value bindings in this module + tcg_warns :: Warnings, -- ...Warnings and 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 + tcg_hpc :: AnyHpcUsage -- True if any part of the prog uses hpc instrumentation. } + +type RecFieldEnv = NameEnv [Name] -- Maps a constructor name *in this module* + -- to the fields for that constructor + -- 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 \end{code} %************************************************************************ @@ -297,8 +304,8 @@ data TcLclEnv -- Changes as we move inside an expression 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_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 @@ -348,7 +355,7 @@ type ThLevel = Int -- 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 @@ -419,7 +426,8 @@ data TcTyThing | 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 :: 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, @@ -434,8 +442,21 @@ data TcTyThing | 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))) @@ -444,9 +465,16 @@ instance Outputable TcTyThing where -- Debugging only 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") +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") + \end{code} \begin{code} @@ -468,40 +496,32 @@ 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 + 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), + 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. -- 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_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface), -- Home-package modules needed by the module being compiled @@ -518,8 +538,13 @@ data ImportAvails -- 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)] @@ -529,23 +554,25 @@ mkModDeps deps = foldl add emptyUFM deps 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 = 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_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) ) @@ -555,73 +582,6 @@ plusImportAvails %************************************************************************ %* * - 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} %* * %************************************************************************ @@ -634,9 +594,9 @@ data WhereFrom | 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} @@ -654,75 +614,154 @@ type Int, represented by Method 34 doubleId [Int] origin +In addition to the basic Haskell variants of 'Inst's, they can now also +represent implication constraints 'forall tvs. given => wanted' +and equality constraints 'co :: ty1 ~ ty2'. + +NB: Equalities occur in two flavours: + + (1) Dict {tci_pred = EqPred ty1 ty2} + (2) EqInst {tci_left = ty1, tci_right = ty2, tci_co = coe} + +The former arises from equalities in contexts, whereas the latter is used +whenever the type checker introduces an equality (e.g., during deferring +unification). + +I am not convinced that this duplication is necessary or useful! -=chak + \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 + } + + | ImplicInst { -- An implication constraint + -- forall tvs. given => wanted + tci_name :: Name, + tci_tyvars :: [TcTyVar], -- Quantified type variables + tci_given :: [Inst], -- Only Dicts and EqInsts + -- (no Methods, LitInsts, ImplicInsts) + tci_wanted :: [Inst], -- Only Dicts, EqInst, and ImplicInsts + -- (no Methods or LitInsts) + + tci_loc :: InstLoc + } + -- NB: the tci_given are not necessarily rigid + + | 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. - InstLoc + 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 + } + + | EqInst { -- delayed unification of the form + -- co :: ty1 ~ ty2 + tci_left :: TcType, -- ty1 -- both types are... + tci_right :: TcType, -- ty2 -- ...free of boxes + tci_co :: EqInstCo, -- co + 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. + } + +type EqInstCo = Either -- Distinguish between given and wanted coercions + TcTyVar -- - a wanted equation, with a hole, to be filled + -- with a witness for the equality; for equation + -- arising from deferring unification, '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. \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 - compare = cmpInst + compare = cmpInst + -- Used *only* for AvailEnv in TcSimplify instance Eq Inst where (==) i1 i2 = case i1 `cmpInst` i2 of - 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) + EQ -> True + _ -> False + +cmpInst :: Inst -> Inst -> Ordering +cmpInst d1@(Dict {}) d2@(Dict {}) = tci_pred d1 `tcCmpPred` tci_pred d2 +cmpInst (Dict {}) _ = 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 {}) _ = 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 {}) _ = 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 {}) _ = 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_left i1 `tcCmpType` tci_left i2) `thenCmp` + (tci_right i1 `tcCmpType` tci_right i2) \end{code} @@ -736,15 +775,41 @@ cmpInst (LitInst _ lit1 ty1 _) (LitInst _ lit2 ty2 _) = (lit1 `compare` lit2) ` -- FIXME: Rename this. It clashes with (Located (IE ...)) type LIE = Bag Inst -isEmptyLIE = isEmptyBag -emptyLIE = emptyBag -unitLIE inst = unitBag inst -mkLIE insts = listToBag insts +isEmptyLIE :: LIE -> Bool +isEmptyLIE = isEmptyBag + +emptyLIE :: LIE +emptyLIE = emptyBag + +unitLIE :: Inst -> LIE +unitLIE inst = unitBag inst + +mkLIE :: [Inst] -> LIE +mkLIE insts = listToBag insts + +plusLIE :: LIE -> LIE -> LIE plusLIE lie1 lie2 = lie1 `unionBags` lie2 -consLIE inst lie = inst `consBag` lie -plusLIEs lies = unionManyBags lies -lieToList = bagToList -listToLIE = listToBag + +plusLIEs :: [LIE] -> LIE +plusLIEs lies = unionManyBags lies + +lieToList :: LIE -> [Inst] +lieToList = bagToList + +listToLIE :: [Inst] -> LIE +listToLIE = listToBag + +consLIE :: Inst -> LIE -> LIE +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} @@ -762,14 +827,28 @@ It appears in TcMonad because there are a couple of error-message-generation 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) -instLocSrcSpan :: InstLoc -> SrcSpan -instLocSrcSpan (InstLoc _ src_span _) = src_span +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) + +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 @@ -781,43 +860,53 @@ data InstOrigin -- The rest are all occurrences: Insts that are 'wanted' ------------------------------------------------------- | OccurrenceOf Name -- Occurrence of an overloaded identifier + | SpecPragOrigin Name -- Specialisation pragma for identifier | 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:] + | TupleOrigin -- (..,..) | InstSigOrigin -- A dict occurrence arising from instantiating -- a polymorphic type during a subsumption check + | ExprSigOrigin -- e :: ty | RecordUpdOrigin + | ViewPatOrigin | 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 + | EqOrigin -- A type equality + +instance Outputable InstOrigin where + ppr (OccurrenceOf name) = hsep [ptext (sLit "a use of"), quotes (ppr name)] + ppr (SpecPragOrigin name) = hsep [ptext (sLit "a specialisation pragma for"), 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 ExprSigOrigin = ptext (sLit "an expression type signature") + ppr ViewPatOrigin = ptext (sLit "a view pattern") + 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 TupleOrigin = ptext (sLit "a tuple") + ppr NegateOrigin = ptext (sLit "a use of syntactic negation") + 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") + ppr InstSigOrigin = panic "ppr InstSigOrigin" \end{code}