X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcRnTypes.lhs;h=28bfd8ecb72a8d7c3e35335f1263367334ca1868;hp=98bb936b50ce0fc7271b6c8964c2dddf3237d1d5;hb=c04a5fe3e2867d59ce9757069fdd20c06c326724;hpb=288213d7c2c65fa68ca466c1a1a3378e24fa1151 diff --git a/compiler/typecheck/TcRnTypes.lhs b/compiler/typecheck/TcRnTypes.lhs index 98bb936..28bfd8e 100644 --- a/compiler/typecheck/TcRnTypes.lhs +++ b/compiler/typecheck/TcRnTypes.lhs @@ -3,13 +3,6 @@ % (c) The GRASP Project, Glasgow University, 1992-2002 % \begin{code} -{-# OPTIONS -w #-} --- The above warning supression flag is a temporary kludge. --- While working on this module you are encouraged to remove it and fix --- any warnings in the module. See --- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings --- for details - module TcRnTypes( TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module TcRef, @@ -20,7 +13,7 @@ module TcRnTypes( IfGblEnv(..), IfLclEnv(..), -- Ranamer types - ErrCtxt, RecFieldEnv, + ErrCtxt, RecFieldEnv(..), ImportAvails(..), emptyImportAvails, plusImportAvails, WhereFrom(..), mkModDeps, @@ -28,15 +21,15 @@ module TcRnTypes( TcTyThing(..), pprTcTyThingCategory, RefinementVisibility(..), -- Template Haskell - ThStage(..), topStage, topSpliceStage, + ThStage(..), topStage, topAnnStage, topSpliceStage, ThLevel, impLevel, topLevel, -- Arrows ArrowCtxt(NoArrowCtxt), newArrowScope, escapeArrowScope, -- Insts - Inst(..), InstOrigin(..), InstLoc(..), - pprInstLoc, pprInstArising, instLocSpan, instLocOrigin, + Inst(..), EqInstCo, InstOrigin(..), InstLoc(..), + pprInstLoc, pprInstArising, instLocSpan, instLocOrigin, setInstLoc, LIE, emptyLIE, unitLIE, plusLIE, consLIE, instLoc, instSpan, plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE, @@ -49,10 +42,10 @@ module TcRnTypes( import HsSyn hiding (LIE) import HscTypes -import Packages import Type import Coercion import TcType +import Annotations import InstEnv import FamInstEnv import IOEnv @@ -73,7 +66,7 @@ import Util import Bag import Outputable import ListSetOps -import FiniteMap +import FastString import Data.Maybe import Data.List @@ -133,23 +126,24 @@ data Env gbl lcl -- Changes as we move into an expression data TcGblEnv = TcGblEnv { - tcg_mod :: Module, -- Module being compiled - tcg_src :: HscSource, -- What kind of module - -- (regular Haskell, hs-boot, ext-core) + 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_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_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 :: 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 @@ -157,94 +151,111 @@ data TcGblEnv -- 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_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 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_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_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 :: 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 +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} %************************************************************************ @@ -381,13 +392,14 @@ impLevel = 0 -- Imported things; they can be used inside a top level splice data ThStage - = Comp -- Ordinary compiling, at level topLevel + = Comp ThLevel -- Ordinary compiling, usually at level topLevel but annotations use a lower level | 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 +topStage, topAnnStage, topSpliceStage :: ThStage +topStage = Comp topLevel +topAnnStage = Comp (topLevel - 1) topSpliceStage = Splice (topLevel - 1) -- Stage for the body of a top-level splice --------------------------- @@ -478,15 +490,15 @@ 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") + 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} @@ -504,62 +516,70 @@ type ErrCtxt = [TidyEnv -> TcM (TidyEnv, Message)] %* * %************************************************************************ -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)] @@ -583,13 +603,12 @@ plusImportAvails (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 @@ -610,9 +629,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} @@ -649,7 +668,7 @@ I am not convinced that this duplication is necessary or useful! -=chak data Inst = Dict { tci_name :: Name, - tci_pred :: TcPredType, + tci_pred :: TcPredType, -- Class or implicit parameter only tci_loc :: InstLoc } @@ -711,27 +730,26 @@ data Inst -- co :: ty1 ~ ty2 tci_left :: TcType, -- ty1 -- both types are... tci_right :: TcType, -- ty2 -- ...free of boxes - tci_co :: Either -- co - 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. + 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. + -- 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 @@ -741,26 +759,28 @@ 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 + EQ -> True + _ -> False +cmpInst :: Inst -> Inst -> Ordering cmpInst d1@(Dict {}) d2@(Dict {}) = tci_pred d1 `tcCmpPred` tci_pred d2 -cmpInst (Dict {}) other = LT +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 {}) other = LT +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 {}) other = LT +cmpInst (LitInst {}) _ = LT -- Implication constraints are compared by *name* -- not by type; that is, we make no attempt to do CSE on them @@ -768,14 +788,15 @@ 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 +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_name i1 `compare` tci_name i2 +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} @@ -789,15 +810,31 @@ cmpInst i1@(EqInst {}) i2@(EqInst {}) = tci_name i1 `compare` tci_name i -- 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 -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 @@ -831,6 +868,9 @@ data InstLoc = InstLoc InstOrigin SrcSpan ErrCtxt instLoc :: Inst -> InstLoc instLoc inst = tci_loc inst +setInstLoc :: Inst -> InstLoc -> Inst +setInstLoc inst new_loc = inst { tci_loc = new_loc } + instSpan :: Inst -> SrcSpan instSpan wanted = instLocSpan (instLoc wanted) @@ -841,7 +881,7 @@ instLocOrigin :: InstLoc -> InstOrigin instLocOrigin (InstLoc o _ _) = o pprInstArising :: Inst -> SDoc -pprInstArising loc = ptext SLIT("arising from") <+> pprInstLoc (tci_loc loc) +pprInstArising loc = ptext (sLit "arising from") <+> pprInstLoc (tci_loc loc) pprInstLoc :: InstLoc -> SDoc pprInstLoc (InstLoc orig span _) = sep [ppr orig, text "at" <+> ppr span] @@ -875,7 +915,13 @@ data InstOrigin | ExprSigOrigin -- e :: ty | RecordUpdOrigin | ViewPatOrigin + | InstScOrigin -- Typechecking superclasses of an instance declaration + + | NoScOrigin -- A very special hack; see TcSimplify, + -- Note [Recursive instances and superclases] + + | DerivOrigin -- Typechecking deriving | StandAloneDerivOrigin -- Typechecking stand-alone deriving | DefaultOrigin -- Typechecking a default decl @@ -883,27 +929,31 @@ data InstOrigin | ProcOrigin -- Arising from a proc expression | ImplicOrigin SDoc -- An implication constraint | EqOrigin -- A type equality + | AnnOrigin -- An annotation 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 (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 NoScOrigin = ptext (sLit "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 EqOrigin = ptext (sLit "a type equality") + ppr InstSigOrigin = panic "ppr InstSigOrigin" + ppr AnnOrigin = ptext (sLit "an annotation") \end{code}