2 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
4 %************************************************************************
6 \section[HsCore]{Core-syntax unfoldings in Haskell interface files}
8 %************************************************************************
10 We could either use this, or parameterise @GenCoreExpr@ on @Types@ and
11 @TyVars@ as well. Currently trying the former... MEGA SIGH.
15 module IfaceType, -- Re-export all this
17 IfaceDecl(..), IfaceClassOp(..), IfaceConDecl(..), IfaceConDecls(..),
18 IfaceExpr(..), IfaceAlt, IfaceNote(..),
19 IfaceBinding(..), IfaceConAlt(..), IfaceIdInfo(..),
20 IfaceInfoItem(..), IfaceRule(..), IfaceInst(..),
26 IfaceEq(..), (&&&), bool, eqListBy, eqMaybeBy,
27 eqIfDecl, eqIfInst, eqIfRule, checkBootDecl,
30 pprIfaceExpr, pprIfaceDecl, pprIfaceDeclHead
33 #include "HsVersions.h"
38 import NewDemand ( StrictSig, pprIfaceStrictSig )
39 import TcType ( deNoteType )
40 import Class ( FunDep, DefMeth, pprFundeps )
41 import OccName ( OccName, parenSymOcc, occNameFS,
42 OccSet, unionOccSets, unitOccSet )
43 import UniqFM ( UniqFM, emptyUFM, addToUFM, lookupUFM )
44 import Name ( Name, NamedThing(..), nameOccName, isExternalName )
45 import CostCentre ( CostCentre, pprCostCentreCore )
46 import Literal ( Literal )
47 import ForeignCall ( ForeignCall )
48 import BasicTypes ( Arity, Activation(..), StrictnessMark, OverlapFlag,
49 RecFlag(..), Boxity(..),
50 isAlwaysActive, tupleParens )
53 import Maybes ( catMaybes )
54 import Util ( lengthIs )
57 infix 4 `eqIfExt`, `eqIfIdInfo`, `eqIfType`
61 %************************************************************************
63 Data type declarations
65 %************************************************************************
69 = IfaceId { ifName :: OccName,
71 ifIdInfo :: IfaceIdInfo }
73 | IfaceData { ifName :: OccName, -- Type constructor
74 ifTyVars :: [IfaceTvBndr], -- Type variables
75 ifCtxt :: IfaceContext, -- The "stupid theta"
76 ifCons :: IfaceConDecls, -- Includes new/data info
77 ifRec :: RecFlag, -- Recursive or not?
78 ifGadtSyntax :: Bool, -- True <=> declared using
80 ifGeneric :: Bool, -- True <=> generic converter
81 -- functions available
82 -- We need this for imported
83 -- data decls, since the
84 -- imported modules may have
86 -- different flags to the
87 -- current compilation unit
88 ifFamInst :: Maybe -- Just _ <=> instance of fam
89 (IfaceTyCon, -- Family tycon
90 [IfaceType], -- Instance types
91 Int ) -- Unique index for naming
94 | IfaceSyn { ifName :: OccName, -- Type constructor
95 ifTyVars :: [IfaceTvBndr], -- Type variables
96 ifOpenSyn :: Bool, -- Is an open family?
97 ifSynRhs :: IfaceType -- Type for an ordinary
98 -- synonym and kind for an
102 | IfaceClass { ifCtxt :: IfaceContext, -- Context...
103 ifName :: OccName, -- Name of the class
104 ifTyVars :: [IfaceTvBndr], -- Type variables
105 ifFDs :: [FunDep FastString], -- Functional dependencies
106 ifATs :: [IfaceDecl], -- Associated type families
107 ifSigs :: [IfaceClassOp], -- Method signatures
108 ifRec :: RecFlag -- Is newtype/datatype associated with the class recursive?
111 | IfaceForeign { ifName :: OccName, -- Needs expanding when we move beyond .NET
112 ifExtName :: Maybe FastString }
114 data IfaceClassOp = IfaceClassOp OccName DefMeth IfaceType
115 -- Nothing => no default method
116 -- Just False => ordinary polymorphic default method
117 -- Just True => generic default method
120 = IfAbstractTyCon -- No info
121 | IfOpenDataTyCon -- Open data family
122 | IfOpenNewTyCon -- Open newtype family
123 | IfDataTyCon [IfaceConDecl] -- data type decls
124 | IfNewTyCon IfaceConDecl -- newtype decls
126 visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
127 visibleIfConDecls IfAbstractTyCon = []
128 visibleIfConDecls IfOpenDataTyCon = []
129 visibleIfConDecls IfOpenNewTyCon = []
130 visibleIfConDecls (IfDataTyCon cs) = cs
131 visibleIfConDecls (IfNewTyCon c) = [c]
135 ifConOcc :: OccName, -- Constructor name
136 ifConInfix :: Bool, -- True <=> declared infix
137 ifConUnivTvs :: [IfaceTvBndr], -- Universal tyvars
138 ifConExTvs :: [IfaceTvBndr], -- Existential tyvars
139 ifConEqSpec :: [(OccName,IfaceType)], -- Equality contraints
140 ifConCtxt :: IfaceContext, -- Non-stupid context
141 ifConArgTys :: [IfaceType], -- Arg types
142 ifConFields :: [OccName], -- ...ditto... (field labels)
143 ifConStricts :: [StrictnessMark]} -- Empty (meaning all lazy),
144 -- or 1-1 corresp with arg tys
147 = IfaceInst { ifInstCls :: IfaceExtName, -- See comments with
148 ifInstTys :: [Maybe IfaceTyCon], -- the defn of Instance
149 ifDFun :: OccName, -- The dfun
150 ifOFlag :: OverlapFlag, -- Overlap flag
151 ifInstOrph :: Maybe OccName } -- See is_orph in defn of Instance
152 -- There's always a separate IfaceDecl for the DFun, which gives
153 -- its IdInfo with its full type and version number.
154 -- The instance declarations taken together have a version number,
155 -- and we don't want that to wobble gratuitously
156 -- If this instance decl is *used*, we'll record a usage on the dfun;
157 -- and if the head does not change it won't be used if it wasn't before
161 ifRuleName :: RuleName,
162 ifActivation :: Activation,
163 ifRuleBndrs :: [IfaceBndr], -- Tyvars and term vars
164 ifRuleHead :: IfaceExtName, -- Head of lhs
165 ifRuleArgs :: [IfaceExpr], -- Args of LHS
166 ifRuleRhs :: IfaceExpr,
167 ifRuleOrph :: Maybe OccName -- Just like IfaceInst
171 = NoInfo -- When writing interface file without -O
172 | HasInfo [IfaceInfoItem] -- Has info, and here it is
174 -- Here's a tricky case:
175 -- * Compile with -O module A, and B which imports A.f
176 -- * Change function f in A, and recompile without -O
177 -- * When we read in old A.hi we read in its IdInfo (as a thunk)
178 -- (In earlier GHCs we used to drop IdInfo immediately on reading,
179 -- but we do not do that now. Instead it's discarded when the
180 -- ModIface is read into the various decl pools.)
181 -- * The version comparsion sees that new (=NoInfo) differs from old (=HasInfo *)
182 -- and so gives a new version.
186 | HsStrictness StrictSig
187 | HsInline Activation
190 | HsWorker IfaceExtName Arity -- Worker, if any see IdInfo.WorkerInfo
191 -- for why we want arity here.
192 -- NB: we need IfaceExtName (not just OccName) because the worker
193 -- can simplify to a function in another module.
194 -- NB: Specialisations and rules come in separately and are
195 -- only later attached to the Id. Partial reason: some are orphans.
197 --------------------------------
199 = IfaceLcl FastString
200 | IfaceExt IfaceExtName
201 | IfaceType IfaceType
202 | IfaceTuple Boxity [IfaceExpr] -- Saturated; type arguments omitted
203 | IfaceLam IfaceBndr IfaceExpr
204 | IfaceApp IfaceExpr IfaceExpr
205 | IfaceCase IfaceExpr FastString IfaceType [IfaceAlt]
206 | IfaceLet IfaceBinding IfaceExpr
207 | IfaceNote IfaceNote IfaceExpr
208 | IfaceCast IfaceExpr IfaceCoercion
210 | IfaceFCall ForeignCall IfaceType
212 data IfaceNote = IfaceSCC CostCentre
214 | IfaceCoreNote String
216 type IfaceAlt = (IfaceConAlt, [FastString], IfaceExpr)
217 -- Note: FastString, not IfaceBndr (and same with the case binder)
218 -- We reconstruct the kind/type of the thing from the context
219 -- thus saving bulk in interface files
221 data IfaceConAlt = IfaceDefault
222 | IfaceDataAlt OccName
223 | IfaceTupleAlt Boxity
224 | IfaceLitAlt Literal
227 = IfaceNonRec IfaceIdBndr IfaceExpr
228 | IfaceRec [(IfaceIdBndr, IfaceExpr)]
232 %************************************************************************
234 \subsection[HsCore-print]{Printing Core unfoldings}
236 %************************************************************************
238 ----------------------------- Printing IfaceDecl ------------------------------------
241 instance Outputable IfaceDecl where
244 pprIfaceDecl (IfaceId {ifName = var, ifType = ty, ifIdInfo = info})
245 = sep [ ppr var <+> dcolon <+> ppr ty,
248 pprIfaceDecl (IfaceForeign {ifName = tycon})
249 = hsep [ptext SLIT("foreign import type dotnet"), ppr tycon]
251 pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars,
252 ifOpenSyn = False, ifSynRhs = mono_ty})
253 = hang (ptext SLIT("type") <+> pprIfaceDeclHead [] tycon tyvars)
254 4 (equals <+> ppr mono_ty)
256 pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars,
257 ifOpenSyn = True, ifSynRhs = mono_ty})
258 = hang (ptext SLIT("type family") <+> pprIfaceDeclHead [] tycon tyvars)
259 4 (dcolon <+> ppr mono_ty)
261 pprIfaceDecl (IfaceData {ifName = tycon, ifGeneric = gen, ifCtxt = context,
262 ifTyVars = tyvars, ifCons = condecls,
263 ifRec = isrec, ifFamInst = mbFamInst})
264 = hang (pp_nd <+> pprIfaceDeclHead context tycon tyvars)
265 4 (vcat [pprRec isrec, pprGen gen, pp_condecls tycon condecls,
266 pprFamily mbFamInst])
268 pp_nd = case condecls of
269 IfAbstractTyCon -> ptext SLIT("data")
270 IfOpenDataTyCon -> ptext SLIT("data family")
271 IfDataTyCon _ -> ptext SLIT("data")
272 IfNewTyCon _ -> ptext SLIT("newtype")
273 IfOpenNewTyCon -> ptext SLIT("newtype family")
275 pprIfaceDecl (IfaceClass {ifCtxt = context, ifName = clas, ifTyVars = tyvars,
276 ifFDs = fds, ifATs = ats, ifSigs = sigs,
278 = hang (ptext SLIT("class") <+> pprIfaceDeclHead context clas tyvars <+> pprFundeps fds)
279 4 (vcat [pprRec isrec,
283 pprRec isrec = ptext SLIT("RecFlag") <+> ppr isrec
284 pprGen True = ptext SLIT("Generics: yes")
285 pprGen False = ptext SLIT("Generics: no")
287 pprFamily Nothing = ptext SLIT("FamilyInstance: none")
288 pprFamily (Just (fam, tys, index)) = ptext SLIT("FamilyInstance:") <+>
289 ppr fam <+> hsep (map ppr tys) <+>
292 instance Outputable IfaceClassOp where
293 ppr (IfaceClassOp n dm ty) = ppr n <+> ppr dm <+> dcolon <+> ppr ty
295 pprIfaceDeclHead :: IfaceContext -> OccName -> [IfaceTvBndr] -> SDoc
296 pprIfaceDeclHead context thing tyvars
297 = hsep [pprIfaceContext context, parenSymOcc thing (ppr thing),
298 pprIfaceTvBndrs tyvars]
300 pp_condecls tc IfAbstractTyCon = ptext SLIT("{- abstract -}")
301 pp_condecls tc IfOpenNewTyCon = empty
302 pp_condecls tc (IfNewTyCon c) = equals <+> pprIfaceConDecl tc c
303 pp_condecls tc IfOpenDataTyCon = empty
304 pp_condecls tc (IfDataTyCon cs) = equals <+> sep (punctuate (ptext SLIT(" |"))
305 (map (pprIfaceConDecl tc) cs))
308 (IfCon { ifConOcc = name, ifConInfix = is_infix,
309 ifConUnivTvs = univ_tvs, ifConExTvs = ex_tvs,
310 ifConEqSpec = eq_spec, ifConCtxt = ctxt, ifConArgTys = arg_tys,
311 ifConStricts = strs, ifConFields = fields })
313 if is_infix then ptext SLIT("Infix") else empty,
314 if null strs then empty
315 else nest 4 (ptext SLIT("Stricts:") <+> hsep (map ppr strs)),
316 if null fields then empty
317 else nest 4 (ptext SLIT("Fields:") <+> hsep (map ppr fields))]
319 main_payload = ppr name <+> dcolon <+>
320 pprIfaceForAllPart (univ_tvs ++ ex_tvs) (eq_ctxt ++ ctxt) (ppr con_tau)
322 eq_ctxt = [(IfaceEqPred (IfaceTyVar (occNameFS tv)) ty)
323 | (tv,ty) <- eq_spec]
324 con_tau = foldr1 IfaceFunTy (arg_tys ++ [tc_app])
325 tc_app = IfaceTyConApp (IfaceTc (LocalTop tc))
326 [IfaceTyVar tv | (tv,_) <- univ_tvs]
327 -- Gruesome, but jsut for debug print
329 instance Outputable IfaceRule where
330 ppr (IfaceRule { ifRuleName = name, ifActivation = act, ifRuleBndrs = bndrs,
331 ifRuleHead = fn, ifRuleArgs = args, ifRuleRhs = rhs })
332 = sep [hsep [doubleQuotes (ftext name), ppr act,
333 ptext SLIT("forall") <+> pprIfaceBndrs bndrs],
334 nest 2 (sep [ppr fn <+> sep (map (pprIfaceExpr parens) args),
335 ptext SLIT("=") <+> ppr rhs])
338 instance Outputable IfaceInst where
339 ppr (IfaceInst {ifDFun = dfun_id, ifOFlag = flag,
340 ifInstCls = cls, ifInstTys = mb_tcs})
341 = hang (ptext SLIT("instance") <+> ppr flag
342 <+> ppr cls <+> brackets (pprWithCommas ppr_mb mb_tcs))
343 2 (equals <+> ppr dfun_id)
346 ppr_mb (Just tc) = ppr tc
350 ----------------------------- Printing IfaceExpr ------------------------------------
353 instance Outputable IfaceExpr where
354 ppr e = pprIfaceExpr noParens e
356 pprIfaceExpr :: (SDoc -> SDoc) -> IfaceExpr -> SDoc
357 -- The function adds parens in context that need
358 -- an atomic value (e.g. function args)
360 pprIfaceExpr add_par (IfaceLcl v) = ppr v
361 pprIfaceExpr add_par (IfaceExt v) = ppr v
362 pprIfaceExpr add_par (IfaceLit l) = ppr l
363 pprIfaceExpr add_par (IfaceFCall cc ty) = braces (ppr cc <+> ppr ty)
364 pprIfaceExpr add_par (IfaceType ty) = char '@' <+> pprParendIfaceType ty
366 pprIfaceExpr add_par app@(IfaceApp _ _) = add_par (pprIfaceApp app [])
367 pprIfaceExpr add_par (IfaceTuple c as) = tupleParens c (interpp'SP as)
369 pprIfaceExpr add_par e@(IfaceLam _ _)
370 = add_par (sep [char '\\' <+> sep (map ppr bndrs) <+> arrow,
371 pprIfaceExpr noParens body])
373 (bndrs,body) = collect [] e
374 collect bs (IfaceLam b e) = collect (b:bs) e
375 collect bs e = (reverse bs, e)
378 pprIfaceExpr add_par (IfaceCase scrut bndr ty [(con, bs, rhs)])
380 = add_par (sep [ptext SLIT("case") <+> char '@' <+> pprParendIfaceType ty <+> pprIfaceExpr noParens scrut <+> ptext SLIT("of")
381 <+> ppr bndr <+> char '{' <+> ppr_con_bs con bs <+> arrow,
382 pprIfaceExpr noParens rhs <+> char '}'])
385 pprIfaceExpr add_par (IfaceCase scrut bndr ty alts)
387 = add_par (sep [ptext SLIT("case") <+> char '@' <+> pprParendIfaceType ty <+> pprIfaceExpr noParens scrut <+> ptext SLIT("of")
388 <+> ppr bndr <+> char '{',
389 nest 2 (sep (map ppr_alt alts)) <+> char '}'])
391 pprIfaceExpr add_par (IfaceCast expr co) = add_par (ptext SLIT("cast") <+> ppr expr <+> ppr co)
393 pprIfaceExpr add_par (IfaceLet (IfaceNonRec b rhs) body)
394 = add_par (sep [ptext SLIT("let {"),
395 nest 2 (ppr_bind (b, rhs)),
397 pprIfaceExpr noParens body])
399 pprIfaceExpr add_par (IfaceLet (IfaceRec pairs) body)
400 = add_par (sep [ptext SLIT("letrec {"),
401 nest 2 (sep (map ppr_bind pairs)),
403 pprIfaceExpr noParens body])
405 pprIfaceExpr add_par (IfaceNote note body) = add_par (ppr note <+> pprIfaceExpr parens body)
407 ppr_alt (con, bs, rhs) = sep [ppr_con_bs con bs,
408 arrow <+> pprIfaceExpr noParens rhs]
410 ppr_con_bs (IfaceTupleAlt tup_con) bs = tupleParens tup_con (interpp'SP bs)
411 ppr_con_bs con bs = ppr con <+> hsep (map ppr bs)
413 ppr_bind ((b,ty),rhs) = sep [ppr b <+> dcolon <+> ppr ty,
414 equals <+> pprIfaceExpr noParens rhs]
417 pprIfaceApp (IfaceApp fun arg) args = pprIfaceApp fun (nest 2 (pprIfaceExpr parens arg) : args)
418 pprIfaceApp fun args = sep (pprIfaceExpr parens fun : args)
421 instance Outputable IfaceNote where
422 ppr (IfaceSCC cc) = pprCostCentreCore cc
423 ppr IfaceInlineMe = ptext SLIT("__inline_me")
424 ppr (IfaceCoreNote s) = ptext SLIT("__core_note") <+> pprHsString (mkFastString s)
426 instance Outputable IfaceConAlt where
427 ppr IfaceDefault = text "DEFAULT"
428 ppr (IfaceLitAlt l) = ppr l
429 ppr (IfaceDataAlt d) = ppr d
430 ppr (IfaceTupleAlt b) = panic "ppr IfaceConAlt"
431 -- IfaceTupleAlt is handled by the case-alternative printer
434 instance Outputable IfaceIdInfo where
436 ppr (HasInfo is) = ptext SLIT("{-") <+> fsep (map ppr_hs_info is) <+> ptext SLIT("-}")
438 ppr_hs_info (HsUnfold unf) = ptext SLIT("Unfolding:") <+>
439 parens (pprIfaceExpr noParens unf)
440 ppr_hs_info (HsInline act) = ptext SLIT("Inline:") <+> ppr act
441 ppr_hs_info (HsArity arity) = ptext SLIT("Arity:") <+> int arity
442 ppr_hs_info (HsStrictness str) = ptext SLIT("Strictness:") <+> pprIfaceStrictSig str
443 ppr_hs_info HsNoCafRefs = ptext SLIT("HasNoCafRefs")
444 ppr_hs_info (HsWorker w a) = ptext SLIT("Worker:") <+> ppr w <+> int a
448 %************************************************************************
450 Equality, for interface file version generaion only
452 %************************************************************************
454 Equality over IfaceSyn returns an IfaceEq, not a Bool. The new constructor is
455 EqBut, which gives the set of *locally-defined* things whose version must be equal
456 for the whole thing to be equal. So the key function is eqIfExt, which compares
459 Of course, equality is also done modulo alpha conversion.
463 = Equal -- Definitely exactly the same
464 | NotEqual -- Definitely different
465 | EqBut OccSet -- The same provided these local things have not changed
467 bool :: Bool -> IfaceEq
469 bool False = NotEqual
471 toBool :: IfaceEq -> Bool
473 toBool (EqBut _) = True
474 toBool NotEqual = False
476 zapEq :: IfaceEq -> IfaceEq -- Used to forget EqBut information
477 zapEq (EqBut _) = Equal
480 (&&&) :: IfaceEq -> IfaceEq -> IfaceEq
482 NotEqual &&& x = NotEqual
483 EqBut occs &&& Equal = EqBut occs
484 EqBut occs &&& NotEqual = NotEqual
485 EqBut occs1 &&& EqBut occs2 = EqBut (occs1 `unionOccSets` occs2)
487 ---------------------
488 eqIfExt :: IfaceExtName -> IfaceExtName -> IfaceEq
489 -- This function is the core of the EqBut stuff
490 eqIfExt (ExtPkg mod1 occ1) (ExtPkg mod2 occ2) = bool (mod1==mod2 && occ1==occ2)
491 eqIfExt (HomePkg mod1 occ1 v1) (HomePkg mod2 occ2 v2) = bool (mod1==mod2 && occ1==occ2 && v1==v2)
492 eqIfExt (LocalTop occ1) (LocalTop occ2) | occ1 == occ2 = EqBut (unitOccSet occ1)
493 eqIfExt (LocalTopSub occ1 p1) (LocalTop occ2) | occ1 == occ2 = EqBut (unitOccSet p1)
494 eqIfExt (LocalTopSub occ1 p1) (LocalTopSub occ2 _) | occ1 == occ2 = EqBut (unitOccSet p1)
495 eqIfExt n1 n2 = NotEqual
500 ---------------------
501 checkBootDecl :: IfaceDecl -- The boot decl
502 -> IfaceDecl -- The real decl
503 -> Bool -- True <=> compatible
504 checkBootDecl (IfaceId s1 t1 _) (IfaceId s2 t2 _)
505 = ASSERT( s1==s2 ) toBool (t1 `eqIfType` t2)
507 checkBootDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
508 = ASSERT (ifName d1 == ifName d2 ) ifExtName d1 == ifExtName d2
510 checkBootDecl d1@(IfaceSyn {}) d2@(IfaceSyn {})
511 = ASSERT( ifName d1 == ifName d2 )
512 toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
513 eq_ifType env (ifSynRhs d1) (ifSynRhs d2)
515 checkBootDecl d1@(IfaceData {}) d2@(IfaceData {})
516 -- We don't check the recursion flags because the boot-one is
517 -- recursive, to be conservative, but the real one may not be.
518 -- I'm not happy with the way recursive flags are dealt with.
519 = ASSERT( ifName d1 == ifName d2 )
520 toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
521 eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
523 IfAbstractTyCon -> Equal
524 cons1 -> eq_hsCD env cons1 (ifCons d2)
526 checkBootDecl d1@(IfaceClass {}) d2@(IfaceClass {})
527 = ASSERT( ifName d1 == ifName d2 )
528 toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
529 eqListBy (eq_hsFD env) (ifFDs d1) (ifFDs d2) &&&
530 case (ifCtxt d1, ifSigs d1) of
532 (cxt1, sigs1) -> eq_ifContext env cxt1 (ifCtxt d2) &&&
533 eqListBy (eq_cls_sig env) sigs1 (ifSigs d2)
535 checkBootDecl _ _ = False -- default case
537 ---------------------
538 eqIfDecl :: IfaceDecl -> IfaceDecl -> IfaceEq
539 eqIfDecl (IfaceId s1 t1 i1) (IfaceId s2 t2 i2)
540 = bool (s1 == s2) &&& (t1 `eqIfType` t2) &&& (i1 `eqIfIdInfo` i2)
542 eqIfDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
543 = bool (ifName d1 == ifName d2 && ifExtName d1 == ifExtName d2)
545 eqIfDecl d1@(IfaceData {}) d2@(IfaceData {})
546 = bool (ifName d1 == ifName d2 &&
547 ifRec d1 == ifRec d2 &&
548 ifGadtSyntax d1 == ifGadtSyntax d2 &&
549 ifGeneric d1 == ifGeneric d2) &&&
550 ifFamInst d1 `eqIfTc_fam` ifFamInst d2 &&&
551 eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
552 eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
553 eq_hsCD env (ifCons d1) (ifCons d2)
555 -- The type variables of the data type do not scope
556 -- over the constructors (any more), but they do scope
557 -- over the stupid context in the IfaceConDecls
559 Nothing `eqIfTc_fam` Nothing = Equal
560 (Just (fam1, tys1, co1)) `eqIfTc_fam` (Just (fam2, tys2, co2)) =
561 fam1 `eqIfTc` fam2 &&& eqListBy eqIfType tys1 tys2 &&& bool (co1 == co2)
562 _ `eqIfTc_fam` _ = NotEqual
564 eqIfDecl d1@(IfaceSyn {}) d2@(IfaceSyn {})
565 = bool (ifName d1 == ifName d2) &&&
566 eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
567 eq_ifType env (ifSynRhs d1) (ifSynRhs d2)
570 eqIfDecl d1@(IfaceClass {}) d2@(IfaceClass {})
571 = bool (ifName d1 == ifName d2 &&
572 ifRec d1 == ifRec d2) &&&
573 eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
574 eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
575 eqListBy (eq_hsFD env) (ifFDs d1) (ifFDs d2) &&&
576 eqListBy eqIfDecl (ifATs d1) (ifATs d2) &&&
577 eqListBy (eq_cls_sig env) (ifSigs d1) (ifSigs d2)
580 eqIfDecl _ _ = NotEqual -- default case
583 eqWith :: [IfaceTvBndr] -> [IfaceTvBndr] -> (EqEnv -> IfaceEq) -> IfaceEq
584 eqWith = eq_ifTvBndrs emptyEqEnv
586 -----------------------
587 eqIfInst d1 d2 = bool (ifDFun d1 == ifDFun d2 && ifOFlag d1 == ifOFlag d2)
588 -- All other changes are handled via the version info on the dfun
590 eqIfRule (IfaceRule n1 a1 bs1 f1 es1 rhs1 o1)
591 (IfaceRule n2 a2 bs2 f2 es2 rhs2 o2)
592 = bool (n1==n2 && a1==a2 && o1 == o2) &&&
594 eq_ifBndrs emptyEqEnv bs1 bs2 (\env ->
595 zapEq (eqListBy (eq_ifaceExpr env) es1 es2) &&&
596 -- zapEq: for the LHSs, ignore the EqBut part
597 eq_ifaceExpr env rhs1 rhs2)
599 eq_hsCD env (IfDataTyCon c1) (IfDataTyCon c2)
600 = eqListBy (eq_ConDecl env) c1 c2
602 eq_hsCD env (IfNewTyCon c1) (IfNewTyCon c2) = eq_ConDecl env c1 c2
603 eq_hsCD env IfAbstractTyCon IfAbstractTyCon = Equal
604 eq_hsCD env IfOpenDataTyCon IfOpenDataTyCon = Equal
605 eq_hsCD env IfOpenNewTyCon IfOpenNewTyCon = Equal
606 eq_hsCD env d1 d2 = NotEqual
609 = bool (ifConOcc c1 == ifConOcc c2 &&
610 ifConInfix c1 == ifConInfix c2 &&
611 ifConStricts c1 == ifConStricts c2 &&
612 ifConFields c1 == ifConFields c2) &&&
613 eq_ifTvBndrs env (ifConUnivTvs c1) (ifConUnivTvs c2) (\ env ->
614 eq_ifTvBndrs env (ifConExTvs c1) (ifConExTvs c2) (\ env ->
615 eq_ifContext env (ifConCtxt c1) (ifConCtxt c2) &&&
616 eq_ifTypes env (ifConArgTys c1) (ifConArgTys c2)))
618 eq_hsFD env (ns1,ms1) (ns2,ms2)
619 = eqListBy (eqIfOcc env) ns1 ns2 &&& eqListBy (eqIfOcc env) ms1 ms2
621 eq_cls_sig env (IfaceClassOp n1 dm1 ty1) (IfaceClassOp n2 dm2 ty2)
622 = bool (n1==n2 && dm1 == dm2) &&& eq_ifType env ty1 ty2
628 eqIfIdInfo NoInfo NoInfo = Equal
629 eqIfIdInfo (HasInfo is1) (HasInfo is2) = eqListBy eq_item is1 is2
630 eqIfIdInfo i1 i2 = NotEqual
632 eq_item (HsInline a1) (HsInline a2) = bool (a1 == a2)
633 eq_item (HsArity a1) (HsArity a2) = bool (a1 == a2)
634 eq_item (HsStrictness s1) (HsStrictness s2) = bool (s1 == s2)
635 eq_item (HsUnfold u1) (HsUnfold u2) = eq_ifaceExpr emptyEqEnv u1 u2
636 eq_item HsNoCafRefs HsNoCafRefs = Equal
637 eq_item (HsWorker wkr1 a1) (HsWorker wkr2 a2) = bool (a1==a2) &&& (wkr1 `eqIfExt` wkr2)
638 eq_item _ _ = NotEqual
641 eq_ifaceExpr :: EqEnv -> IfaceExpr -> IfaceExpr -> IfaceEq
642 eq_ifaceExpr env (IfaceLcl v1) (IfaceLcl v2) = eqIfOcc env v1 v2
643 eq_ifaceExpr env (IfaceExt v1) (IfaceExt v2) = eqIfExt v1 v2
644 eq_ifaceExpr env (IfaceLit l1) (IfaceLit l2) = bool (l1 == l2)
645 eq_ifaceExpr env (IfaceFCall c1 ty1) (IfaceFCall c2 ty2) = bool (c1==c2) &&& eq_ifType env ty1 ty2
646 eq_ifaceExpr env (IfaceType ty1) (IfaceType ty2) = eq_ifType env ty1 ty2
647 eq_ifaceExpr env (IfaceTuple n1 as1) (IfaceTuple n2 as2) = bool (n1==n2) &&& eqListBy (eq_ifaceExpr env) as1 as2
648 eq_ifaceExpr env (IfaceLam b1 body1) (IfaceLam b2 body2) = eq_ifBndr env b1 b2 (\env -> eq_ifaceExpr env body1 body2)
649 eq_ifaceExpr env (IfaceApp f1 a1) (IfaceApp f2 a2) = eq_ifaceExpr env f1 f2 &&& eq_ifaceExpr env a1 a2
650 eq_ifaceExpr env (IfaceCast e1 co1) (IfaceCast e2 co2) = eq_ifaceExpr env e1 e2 &&& eq_ifType env co1 co2
651 eq_ifaceExpr env (IfaceNote n1 r1) (IfaceNote n2 r2) = eq_ifaceNote env n1 n2 &&& eq_ifaceExpr env r1 r2
653 eq_ifaceExpr env (IfaceCase s1 b1 ty1 as1) (IfaceCase s2 b2 ty2 as2)
654 = eq_ifaceExpr env s1 s2 &&&
655 eq_ifType env ty1 ty2 &&&
656 eq_ifNakedBndr env b1 b2 (\env -> eqListBy (eq_ifaceAlt env) as1 as2)
658 eq_ifaceAlt env (c1,bs1,r1) (c2,bs2,r2)
659 = bool (eq_ifaceConAlt c1 c2) &&&
660 eq_ifNakedBndrs env bs1 bs2 (\env -> eq_ifaceExpr env r1 r2)
662 eq_ifaceExpr env (IfaceLet (IfaceNonRec b1 r1) x1) (IfaceLet (IfaceNonRec b2 r2) x2)
663 = eq_ifaceExpr env r1 r2 &&& eq_ifIdBndr env b1 b2 (\env -> eq_ifaceExpr env x1 x2)
665 eq_ifaceExpr env (IfaceLet (IfaceRec as1) x1) (IfaceLet (IfaceRec as2) x2)
666 = eq_ifIdBndrs env bs1 bs2 (\env -> eqListBy (eq_ifaceExpr env) rs1 rs2 &&& eq_ifaceExpr env x1 x2)
668 (bs1,rs1) = unzip as1
669 (bs2,rs2) = unzip as2
672 eq_ifaceExpr env _ _ = NotEqual
675 eq_ifaceConAlt :: IfaceConAlt -> IfaceConAlt -> Bool
676 eq_ifaceConAlt IfaceDefault IfaceDefault = True
677 eq_ifaceConAlt (IfaceDataAlt n1) (IfaceDataAlt n2) = n1==n2
678 eq_ifaceConAlt (IfaceTupleAlt c1) (IfaceTupleAlt c2) = c1==c2
679 eq_ifaceConAlt (IfaceLitAlt l1) (IfaceLitAlt l2) = l1==l2
680 eq_ifaceConAlt _ _ = False
683 eq_ifaceNote :: EqEnv -> IfaceNote -> IfaceNote -> IfaceEq
684 eq_ifaceNote env (IfaceSCC c1) (IfaceSCC c2) = bool (c1==c2)
685 eq_ifaceNote env IfaceInlineMe IfaceInlineMe = Equal
686 eq_ifaceNote env (IfaceCoreNote s1) (IfaceCoreNote s2) = bool (s1==s2)
687 eq_ifaceNote env _ _ = NotEqual
691 ---------------------
692 eqIfType t1 t2 = eq_ifType emptyEqEnv t1 t2
695 eq_ifType env (IfaceTyVar n1) (IfaceTyVar n2) = eqIfOcc env n1 n2
696 eq_ifType env (IfaceAppTy s1 t1) (IfaceAppTy s2 t2) = eq_ifType env s1 s2 &&& eq_ifType env t1 t2
697 eq_ifType env (IfacePredTy st1) (IfacePredTy st2) = eq_ifPredType env st1 st2
698 eq_ifType env (IfaceTyConApp tc1 ts1) (IfaceTyConApp tc2 ts2) = tc1 `eqIfTc` tc2 &&& eq_ifTypes env ts1 ts2
699 eq_ifType env (IfaceForAllTy tv1 t1) (IfaceForAllTy tv2 t2) = eq_ifTvBndr env tv1 tv2 (\env -> eq_ifType env t1 t2)
700 eq_ifType env (IfaceFunTy s1 t1) (IfaceFunTy s2 t2) = eq_ifType env s1 s2 &&& eq_ifType env t1 t2
701 eq_ifType env _ _ = NotEqual
704 eq_ifTypes env = eqListBy (eq_ifType env)
707 eq_ifContext env a b = eqListBy (eq_ifPredType env) a b
710 eq_ifPredType env (IfaceClassP c1 tys1) (IfaceClassP c2 tys2) = c1 `eqIfExt` c2 &&& eq_ifTypes env tys1 tys2
711 eq_ifPredType env (IfaceIParam n1 ty1) (IfaceIParam n2 ty2) = bool (n1 == n2) &&& eq_ifType env ty1 ty2
712 eq_ifPredType env _ _ = NotEqual
715 eqIfTc (IfaceTc tc1) (IfaceTc tc2) = tc1 `eqIfExt` tc2
716 eqIfTc IfaceIntTc IfaceIntTc = Equal
717 eqIfTc IfaceCharTc IfaceCharTc = Equal
718 eqIfTc IfaceBoolTc IfaceBoolTc = Equal
719 eqIfTc IfaceListTc IfaceListTc = Equal
720 eqIfTc IfacePArrTc IfacePArrTc = Equal
721 eqIfTc (IfaceTupTc bx1 ar1) (IfaceTupTc bx2 ar2) = bool (bx1==bx2 && ar1==ar2)
722 eqIfTc _ _ = NotEqual
725 -----------------------------------------------------------
726 Support code for equality checking
727 -----------------------------------------------------------
730 ------------------------------------
731 type EqEnv = UniqFM FastString -- Tracks the mapping from L-variables to R-variables
733 eqIfOcc :: EqEnv -> FastString -> FastString -> IfaceEq
734 eqIfOcc env n1 n2 = case lookupUFM env n1 of
735 Just n1 -> bool (n1 == n2)
736 Nothing -> bool (n1 == n2)
738 extendEqEnv :: EqEnv -> FastString -> FastString -> EqEnv
739 extendEqEnv env n1 n2 | n1 == n2 = env
740 | otherwise = addToUFM env n1 n2
743 emptyEqEnv = emptyUFM
745 ------------------------------------
746 type ExtEnv bndr = EqEnv -> bndr -> bndr -> (EqEnv -> IfaceEq) -> IfaceEq
748 eq_ifNakedBndr :: ExtEnv FastString
749 eq_ifBndr :: ExtEnv IfaceBndr
750 eq_ifTvBndr :: ExtEnv IfaceTvBndr
751 eq_ifIdBndr :: ExtEnv IfaceIdBndr
753 eq_ifNakedBndr env n1 n2 k = k (extendEqEnv env n1 n2)
755 eq_ifBndr env (IfaceIdBndr b1) (IfaceIdBndr b2) k = eq_ifIdBndr env b1 b2 k
756 eq_ifBndr env (IfaceTvBndr b1) (IfaceTvBndr b2) k = eq_ifTvBndr env b1 b2 k
757 eq_ifBndr _ _ _ _ = NotEqual
759 eq_ifTvBndr env (v1, k1) (v2, k2) k = eq_ifType env k1 k2 &&& k (extendEqEnv env v1 v2)
760 eq_ifIdBndr env (v1, t1) (v2, t2) k = eq_ifType env t1 t2 &&& k (extendEqEnv env v1 v2)
762 eq_ifBndrs :: ExtEnv [IfaceBndr]
763 eq_ifIdBndrs :: ExtEnv [IfaceIdBndr]
764 eq_ifTvBndrs :: ExtEnv [IfaceTvBndr]
765 eq_ifNakedBndrs :: ExtEnv [FastString]
766 eq_ifBndrs = eq_bndrs_with eq_ifBndr
767 eq_ifIdBndrs = eq_bndrs_with eq_ifIdBndr
768 eq_ifTvBndrs = eq_bndrs_with eq_ifTvBndr
769 eq_ifNakedBndrs = eq_bndrs_with eq_ifNakedBndr
771 eq_bndrs_with eq env [] [] k = k env
772 eq_bndrs_with eq env (b1:bs1) (b2:bs2) k = eq env b1 b2 (\env -> eq_bndrs_with eq env bs1 bs2 k)
773 eq_bndrs_with eq env _ _ _ = NotEqual
777 eqListBy :: (a->a->IfaceEq) -> [a] -> [a] -> IfaceEq
778 eqListBy eq [] [] = Equal
779 eqListBy eq (x:xs) (y:ys) = eq x y &&& eqListBy eq xs ys
780 eqListBy eq xs ys = NotEqual
782 eqMaybeBy :: (a->a->IfaceEq) -> Maybe a -> Maybe a -> IfaceEq
783 eqMaybeBy eq Nothing Nothing = Equal
784 eqMaybeBy eq (Just x) (Just y) = eq x y
785 eqMaybeBy eq x y = NotEqual