X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcRnTypes.lhs;h=ebf410169c8c29c8aaf0769d01fc768125bb9cd1;hp=a33faa16916a25cb58f32f95ff4083d43cdf8ad9;hb=7539ed8cade66d09fae1e0ccc66c519cafa3b55b;hpb=30c122df62ec75f9ed7f392f24c2925675bf1d06 diff --git a/compiler/typecheck/TcRnTypes.lhs b/compiler/typecheck/TcRnTypes.lhs index a33faa1..ebf4101 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, @@ -49,7 +42,6 @@ module TcRnTypes( import HsSyn hiding (LIE) import HscTypes -import Packages import Type import Coercion import TcType @@ -73,7 +65,6 @@ import Util import Bag import Outputable import ListSetOps -import FiniteMap import FastString import Data.Maybe @@ -228,7 +219,7 @@ data TcGblEnv -- 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_insts :: [Instance], -- ...Instances tcg_fam_insts :: [FamInst], -- ...Family instances tcg_rules :: [LRuleDecl Id], -- ...Rules @@ -243,9 +234,9 @@ 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 + -- The FieldEnv deals *only* with constructors defined in *thie* + -- module. For imported modules, we get the same info from the + -- TypeEnv \end{code} %************************************************************************ @@ -479,15 +470,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} @@ -517,7 +508,7 @@ It is used * when processing the export list \begin{code} data ImportAvails = ImportAvails { - imp_mods :: ModuleEnv (Module, [(ModuleName, 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 @@ -526,8 +517,6 @@ data ImportAvails -- 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 @@ -584,13 +573,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 @@ -611,9 +599,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} @@ -742,26 +730,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 @@ -769,14 +759,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} @@ -790,15 +781,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 @@ -842,7 +849,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] @@ -886,25 +893,26 @@ data InstOrigin | 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 (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 EqOrigin = ptext (sLit "a type equality") + ppr InstSigOrigin = panic "ppr InstSigOrigin" \end{code}