2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
8 module IfaceType, -- Re-export all this
10 IfaceDecl(..), IfaceClassOp(..), IfaceConDecl(..), IfaceConDecls(..),
11 IfaceExpr(..), IfaceAlt, IfaceNote(..),
12 IfaceBinding(..), IfaceConAlt(..), IfaceIdInfo(..),
13 IfaceInfoItem(..), IfaceRule(..), IfaceInst(..), IfaceFamInst(..),
16 ifaceDeclSubBndrs, visibleIfConDecls,
19 GenIfaceEq(..), IfaceEq, (&&&), bool, eqListBy, eqMaybeBy,
20 eqIfDecl, eqIfInst, eqIfRule, checkBootDecl,
23 pprIfaceExpr, pprIfaceDeclHead
26 #include "HsVersions.h"
49 infix 4 `eqIfExt`, `eqIfIdInfo`, `eqIfType`
53 %************************************************************************
55 Data type declarations
57 %************************************************************************
61 = IfaceId { ifName :: OccName,
63 ifIdInfo :: IfaceIdInfo }
65 | IfaceData { ifName :: OccName, -- Type constructor
66 ifTyVars :: [IfaceTvBndr], -- Type variables
67 ifCtxt :: IfaceContext, -- The "stupid theta"
68 ifCons :: IfaceConDecls, -- Includes new/data info
69 ifRec :: RecFlag, -- Recursive or not?
70 ifGadtSyntax :: Bool, -- True <=> declared using
72 ifGeneric :: Bool, -- True <=> generic converter
73 -- functions available
74 -- We need this for imported
75 -- data decls, since the
76 -- imported modules may have
78 -- different flags to the
79 -- current compilation unit
80 ifFamInst :: Maybe (IfaceTyCon, [IfaceType])
81 -- Just <=> instance of family
84 | IfaceSyn { ifName :: OccName, -- Type constructor
85 ifTyVars :: [IfaceTvBndr], -- Type variables
86 ifOpenSyn :: Bool, -- Is an open family?
87 ifSynRhs :: IfaceType -- Type for an ordinary
88 -- synonym and kind for an
92 | IfaceClass { ifCtxt :: IfaceContext, -- Context...
93 ifName :: OccName, -- Name of the class
94 ifTyVars :: [IfaceTvBndr], -- Type variables
95 ifFDs :: [FunDep FastString], -- Functional dependencies
96 ifATs :: [IfaceDecl], -- Associated type families
97 ifSigs :: [IfaceClassOp], -- Method signatures
98 ifRec :: RecFlag -- Is newtype/datatype associated with the class recursive?
101 | IfaceForeign { ifName :: OccName, -- Needs expanding when we move
103 ifExtName :: Maybe FastString }
105 data IfaceClassOp = IfaceClassOp OccName DefMeth IfaceType
106 -- Nothing => no default method
107 -- Just False => ordinary polymorphic default method
108 -- Just True => generic default method
111 = IfAbstractTyCon -- No info
112 | IfOpenDataTyCon -- Open data family
113 | IfOpenNewTyCon -- Open newtype family
114 | IfDataTyCon [IfaceConDecl] -- data type decls
115 | IfNewTyCon IfaceConDecl -- newtype decls
117 visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
118 visibleIfConDecls IfAbstractTyCon = []
119 visibleIfConDecls IfOpenDataTyCon = []
120 visibleIfConDecls IfOpenNewTyCon = []
121 visibleIfConDecls (IfDataTyCon cs) = cs
122 visibleIfConDecls (IfNewTyCon c) = [c]
126 ifConOcc :: OccName, -- Constructor name
127 ifConInfix :: Bool, -- True <=> declared infix
128 ifConUnivTvs :: [IfaceTvBndr], -- Universal tyvars
129 ifConExTvs :: [IfaceTvBndr], -- Existential tyvars
130 ifConEqSpec :: [(OccName,IfaceType)], -- Equality contraints
131 ifConCtxt :: IfaceContext, -- Non-stupid context
132 ifConArgTys :: [IfaceType], -- Arg types
133 ifConFields :: [OccName], -- ...ditto... (field labels)
134 ifConStricts :: [StrictnessMark]} -- Empty (meaning all lazy),
135 -- or 1-1 corresp with arg tys
138 = IfaceInst { ifInstCls :: Name, -- See comments with
139 ifInstTys :: [Maybe IfaceTyCon], -- the defn of Instance
140 ifDFun :: Name, -- The dfun
141 ifOFlag :: OverlapFlag, -- Overlap flag
142 ifInstOrph :: Maybe OccName } -- See is_orph in defn of Instance
143 -- There's always a separate IfaceDecl for the DFun, which gives
144 -- its IdInfo with its full type and version number.
145 -- The instance declarations taken together have a version number,
146 -- and we don't want that to wobble gratuitously
147 -- If this instance decl is *used*, we'll record a usage on the dfun;
148 -- and if the head does not change it won't be used if it wasn't before
151 = IfaceFamInst { ifFamInstFam :: Name -- Family tycon
152 , ifFamInstTys :: [Maybe IfaceTyCon] -- Rough match types
153 , ifFamInstTyCon :: IfaceTyCon -- Instance decl
158 ifRuleName :: RuleName,
159 ifActivation :: Activation,
160 ifRuleBndrs :: [IfaceBndr], -- Tyvars and term vars
161 ifRuleHead :: Name, -- Head of lhs
162 ifRuleArgs :: [IfaceExpr], -- Args of LHS
163 ifRuleRhs :: IfaceExpr,
164 ifRuleOrph :: Maybe OccName -- Just like IfaceInst
168 = NoInfo -- When writing interface file without -O
169 | HasInfo [IfaceInfoItem] -- Has info, and here it is
171 -- Here's a tricky case:
172 -- * Compile with -O module A, and B which imports A.f
173 -- * Change function f in A, and recompile without -O
174 -- * When we read in old A.hi we read in its IdInfo (as a thunk)
175 -- (In earlier GHCs we used to drop IdInfo immediately on reading,
176 -- but we do not do that now. Instead it's discarded when the
177 -- ModIface is read into the various decl pools.)
178 -- * The version comparsion sees that new (=NoInfo) differs from old (=HasInfo *)
179 -- and so gives a new version.
183 | HsStrictness StrictSig
184 | HsInline Activation
187 | HsWorker Name Arity -- Worker, if any see IdInfo.WorkerInfo
188 -- for why we want arity here.
189 -- NB: we need IfaceExtName (not just OccName) because the worker
190 -- can simplify to a function in another module.
191 -- NB: Specialisations and rules come in separately and are
192 -- only later attached to the Id. Partial reason: some are orphans.
194 --------------------------------
196 = IfaceLcl FastString
198 | IfaceType IfaceType
199 | IfaceTuple Boxity [IfaceExpr] -- Saturated; type arguments omitted
200 | IfaceLam IfaceBndr IfaceExpr
201 | IfaceApp IfaceExpr IfaceExpr
202 | IfaceCase IfaceExpr FastString IfaceType [IfaceAlt]
203 | IfaceLet IfaceBinding IfaceExpr
204 | IfaceNote IfaceNote IfaceExpr
205 | IfaceCast IfaceExpr IfaceCoercion
207 | IfaceFCall ForeignCall IfaceType
209 data IfaceNote = IfaceSCC CostCentre
211 | IfaceCoreNote String
213 type IfaceAlt = (IfaceConAlt, [FastString], IfaceExpr)
214 -- Note: FastString, not IfaceBndr (and same with the case binder)
215 -- We reconstruct the kind/type of the thing from the context
216 -- thus saving bulk in interface files
218 data IfaceConAlt = IfaceDefault
220 | IfaceTupleAlt Boxity
221 | IfaceLitAlt Literal
224 = IfaceNonRec IfaceIdBndr IfaceExpr
225 | IfaceRec [(IfaceIdBndr, IfaceExpr)]
227 -- -----------------------------------------------------------------------------
230 ifaceDeclSubBndrs :: IfaceDecl -> [OccName]
231 -- *Excludes* the 'main' name, but *includes* the implicitly-bound names
232 -- Deeply revolting, because it has to predict what gets bound,
233 -- especially the question of whether there's a wrapper for a datacon
235 ifaceDeclSubBndrs (IfaceClass {ifCtxt = sc_ctxt, ifName = cls_occ,
236 ifSigs = sigs, ifATs = ats })
238 [tc_occ, dc_occ, dcww_occ] ++
239 [op | IfaceClassOp op _ _ <- sigs] ++
240 [ifName at | at <- ats ] ++
241 [mkSuperDictSelOcc n cls_occ | n <- [1..n_ctxt]]
243 n_ctxt = length sc_ctxt
245 tc_occ = mkClassTyConOcc cls_occ
246 dc_occ = mkClassDataConOcc cls_occ
247 co_occs | is_newtype = [mkNewTyCoOcc tc_occ]
249 dcww_occ -- | is_newtype = mkDataConWrapperOcc dc_occ -- Newtypes have wrapper but no worker
250 | otherwise = mkDataConWorkerOcc dc_occ -- Otherwise worker but no wrapper
251 is_newtype = n_sigs + n_ctxt == 1 -- Sigh
253 ifaceDeclSubBndrs IfaceData {ifCons = IfAbstractTyCon}
256 ifaceDeclSubBndrs (IfaceData {ifName = tc_occ,
257 ifCons = IfNewTyCon (
258 IfCon { ifConOcc = con_occ,
261 ifFamInst = famInst})
262 = fields ++ [con_occ, mkDataConWorkerOcc con_occ, mkNewTyCoOcc tc_occ]
263 ++ famInstCo famInst tc_occ
265 ifaceDeclSubBndrs (IfaceData {ifName = tc_occ,
266 ifCons = IfDataTyCon cons,
267 ifFamInst = famInst})
268 = nub (concatMap ifConFields cons) -- Eliminate duplicate fields
269 ++ concatMap dc_occs cons
270 ++ famInstCo famInst tc_occ
273 | has_wrapper = [con_occ, work_occ, wrap_occ]
274 | otherwise = [con_occ, work_occ]
276 con_occ = ifConOcc con_decl
277 strs = ifConStricts con_decl
278 wrap_occ = mkDataConWrapperOcc con_occ
279 work_occ = mkDataConWorkerOcc con_occ
280 has_wrapper = any isMarkedStrict strs -- See MkId.mkDataConIds (sigh)
281 || not (null . ifConEqSpec $ con_decl)
283 -- ToDo: may miss strictness in existential dicts
285 ifaceDeclSubBndrs _other = []
287 -- coercion for data/newtype family instances
288 famInstCo Nothing baseOcc = []
289 famInstCo (Just _) baseOcc = [mkInstTyCoOcc baseOcc]
291 ----------------------------- Printing IfaceDecl ------------------------------
293 instance Outputable IfaceDecl where
296 pprIfaceDecl (IfaceId {ifName = var, ifType = ty, ifIdInfo = info})
297 = sep [ ppr var <+> dcolon <+> ppr ty,
300 pprIfaceDecl (IfaceForeign {ifName = tycon})
301 = hsep [ptext SLIT("foreign import type dotnet"), ppr tycon]
303 pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars,
304 ifOpenSyn = False, ifSynRhs = mono_ty})
305 = hang (ptext SLIT("type") <+> pprIfaceDeclHead [] tycon tyvars)
306 4 (equals <+> ppr mono_ty)
308 pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars,
309 ifOpenSyn = True, ifSynRhs = mono_ty})
310 = hang (ptext SLIT("type family") <+> pprIfaceDeclHead [] tycon tyvars)
311 4 (dcolon <+> ppr mono_ty)
313 pprIfaceDecl (IfaceData {ifName = tycon, ifGeneric = gen, ifCtxt = context,
314 ifTyVars = tyvars, ifCons = condecls,
315 ifRec = isrec, ifFamInst = mbFamInst})
316 = hang (pp_nd <+> pprIfaceDeclHead context tycon tyvars)
317 4 (vcat [pprRec isrec, pprGen gen, pp_condecls tycon condecls,
318 pprFamily mbFamInst])
320 pp_nd = case condecls of
321 IfAbstractTyCon -> ptext SLIT("data")
322 IfOpenDataTyCon -> ptext SLIT("data family")
323 IfDataTyCon _ -> ptext SLIT("data")
324 IfNewTyCon _ -> ptext SLIT("newtype")
325 IfOpenNewTyCon -> ptext SLIT("newtype family")
327 pprIfaceDecl (IfaceClass {ifCtxt = context, ifName = clas, ifTyVars = tyvars,
328 ifFDs = fds, ifATs = ats, ifSigs = sigs,
330 = hang (ptext SLIT("class") <+> pprIfaceDeclHead context clas tyvars <+> pprFundeps fds)
331 4 (vcat [pprRec isrec,
335 pprRec isrec = ptext SLIT("RecFlag") <+> ppr isrec
336 pprGen True = ptext SLIT("Generics: yes")
337 pprGen False = ptext SLIT("Generics: no")
339 pprFamily Nothing = ptext SLIT("FamilyInstance: none")
340 pprFamily (Just famInst) = ptext SLIT("FamilyInstance:") <+> ppr famInst
342 instance Outputable IfaceClassOp where
343 ppr (IfaceClassOp n dm ty) = ppr n <+> ppr dm <+> dcolon <+> ppr ty
345 pprIfaceDeclHead :: IfaceContext -> OccName -> [IfaceTvBndr] -> SDoc
346 pprIfaceDeclHead context thing tyvars
347 = hsep [pprIfaceContext context, parenSymOcc thing (ppr thing),
348 pprIfaceTvBndrs tyvars]
350 pp_condecls tc IfAbstractTyCon = ptext SLIT("{- abstract -}")
351 pp_condecls tc IfOpenNewTyCon = empty
352 pp_condecls tc (IfNewTyCon c) = equals <+> pprIfaceConDecl tc c
353 pp_condecls tc IfOpenDataTyCon = empty
354 pp_condecls tc (IfDataTyCon cs) = equals <+> sep (punctuate (ptext SLIT(" |"))
355 (map (pprIfaceConDecl tc) cs))
358 (IfCon { ifConOcc = name, ifConInfix = is_infix,
359 ifConUnivTvs = univ_tvs, ifConExTvs = ex_tvs,
360 ifConEqSpec = eq_spec, ifConCtxt = ctxt, ifConArgTys = arg_tys,
361 ifConStricts = strs, ifConFields = fields })
363 if is_infix then ptext SLIT("Infix") else empty,
364 if null strs then empty
365 else nest 4 (ptext SLIT("Stricts:") <+> hsep (map ppr strs)),
366 if null fields then empty
367 else nest 4 (ptext SLIT("Fields:") <+> hsep (map ppr fields))]
369 main_payload = ppr name <+> dcolon <+>
370 pprIfaceForAllPart (univ_tvs ++ ex_tvs) (eq_ctxt ++ ctxt) (ppr con_tau)
372 eq_ctxt = [(IfaceEqPred (IfaceTyVar (occNameFS tv)) ty)
373 | (tv,ty) <- eq_spec]
374 con_tau = foldr1 IfaceFunTy (arg_tys ++ [tc_app])
375 tc_app = IfaceTyConApp (IfaceTc tc_name)
376 [IfaceTyVar tv | (tv,_) <- univ_tvs]
377 tc_name = mkInternalName (mkBuiltinUnique 1) tc noSrcLoc
378 -- Really Gruesome, but just for debug print
380 instance Outputable IfaceRule where
381 ppr (IfaceRule { ifRuleName = name, ifActivation = act, ifRuleBndrs = bndrs,
382 ifRuleHead = fn, ifRuleArgs = args, ifRuleRhs = rhs })
383 = sep [hsep [doubleQuotes (ftext name), ppr act,
384 ptext SLIT("forall") <+> pprIfaceBndrs bndrs],
385 nest 2 (sep [ppr fn <+> sep (map (pprIfaceExpr parens) args),
386 ptext SLIT("=") <+> ppr rhs])
389 instance Outputable IfaceInst where
390 ppr (IfaceInst {ifDFun = dfun_id, ifOFlag = flag,
391 ifInstCls = cls, ifInstTys = mb_tcs})
392 = hang (ptext SLIT("instance") <+> ppr flag
393 <+> ppr cls <+> brackets (pprWithCommas ppr_rough mb_tcs))
394 2 (equals <+> ppr dfun_id)
396 instance Outputable IfaceFamInst where
397 ppr (IfaceFamInst {ifFamInstFam = fam, ifFamInstTys = mb_tcs,
398 ifFamInstTyCon = tycon_id})
399 = hang (ptext SLIT("family instance") <+>
400 ppr fam <+> brackets (pprWithCommas ppr_rough mb_tcs))
401 2 (equals <+> ppr tycon_id)
403 ppr_rough :: Maybe IfaceTyCon -> SDoc
404 ppr_rough Nothing = dot
405 ppr_rough (Just tc) = ppr tc
409 ----------------------------- Printing IfaceExpr ------------------------------------
412 instance Outputable IfaceExpr where
413 ppr e = pprIfaceExpr noParens e
415 pprIfaceExpr :: (SDoc -> SDoc) -> IfaceExpr -> SDoc
416 -- The function adds parens in context that need
417 -- an atomic value (e.g. function args)
419 pprIfaceExpr add_par (IfaceLcl v) = ppr v
420 pprIfaceExpr add_par (IfaceExt v) = ppr v
421 pprIfaceExpr add_par (IfaceLit l) = ppr l
422 pprIfaceExpr add_par (IfaceFCall cc ty) = braces (ppr cc <+> ppr ty)
423 pprIfaceExpr add_par (IfaceType ty) = char '@' <+> pprParendIfaceType ty
425 pprIfaceExpr add_par app@(IfaceApp _ _) = add_par (pprIfaceApp app [])
426 pprIfaceExpr add_par (IfaceTuple c as) = tupleParens c (interpp'SP as)
428 pprIfaceExpr add_par e@(IfaceLam _ _)
429 = add_par (sep [char '\\' <+> sep (map ppr bndrs) <+> arrow,
430 pprIfaceExpr noParens body])
432 (bndrs,body) = collect [] e
433 collect bs (IfaceLam b e) = collect (b:bs) e
434 collect bs e = (reverse bs, e)
436 pprIfaceExpr add_par (IfaceCase scrut bndr ty [(con, bs, rhs)])
437 = add_par (sep [ptext SLIT("case") <+> char '@' <+> pprParendIfaceType ty
438 <+> pprIfaceExpr noParens scrut <+> ptext SLIT("of")
439 <+> ppr bndr <+> char '{' <+> ppr_con_bs con bs <+> arrow,
440 pprIfaceExpr noParens rhs <+> char '}'])
442 pprIfaceExpr add_par (IfaceCase scrut bndr ty alts)
443 = add_par (sep [ptext SLIT("case") <+> char '@' <+> pprParendIfaceType ty
444 <+> pprIfaceExpr noParens scrut <+> ptext SLIT("of")
445 <+> ppr bndr <+> char '{',
446 nest 2 (sep (map ppr_alt alts)) <+> char '}'])
448 pprIfaceExpr add_par (IfaceCast expr co)
449 = sep [pprIfaceExpr parens expr,
450 nest 2 (ptext SLIT("`cast`")),
451 pprParendIfaceType co]
453 pprIfaceExpr add_par (IfaceLet (IfaceNonRec b rhs) body)
454 = add_par (sep [ptext SLIT("let {"),
455 nest 2 (ppr_bind (b, rhs)),
457 pprIfaceExpr noParens body])
459 pprIfaceExpr add_par (IfaceLet (IfaceRec pairs) body)
460 = add_par (sep [ptext SLIT("letrec {"),
461 nest 2 (sep (map ppr_bind pairs)),
463 pprIfaceExpr noParens body])
465 pprIfaceExpr add_par (IfaceNote note body) = add_par (ppr note <+> pprIfaceExpr parens body)
467 ppr_alt (con, bs, rhs) = sep [ppr_con_bs con bs,
468 arrow <+> pprIfaceExpr noParens rhs]
470 ppr_con_bs (IfaceTupleAlt tup_con) bs = tupleParens tup_con (interpp'SP bs)
471 ppr_con_bs con bs = ppr con <+> hsep (map ppr bs)
473 ppr_bind ((b,ty),rhs) = sep [ppr b <+> dcolon <+> ppr ty,
474 equals <+> pprIfaceExpr noParens rhs]
477 pprIfaceApp (IfaceApp fun arg) args = pprIfaceApp fun (nest 2 (pprIfaceExpr parens arg) : args)
478 pprIfaceApp fun args = sep (pprIfaceExpr parens fun : args)
481 instance Outputable IfaceNote where
482 ppr (IfaceSCC cc) = pprCostCentreCore cc
483 ppr IfaceInlineMe = ptext SLIT("__inline_me")
484 ppr (IfaceCoreNote s) = ptext SLIT("__core_note") <+> pprHsString (mkFastString s)
486 instance Outputable IfaceConAlt where
487 ppr IfaceDefault = text "DEFAULT"
488 ppr (IfaceLitAlt l) = ppr l
489 ppr (IfaceDataAlt d) = ppr d
490 ppr (IfaceTupleAlt b) = panic "ppr IfaceConAlt"
491 -- IfaceTupleAlt is handled by the case-alternative printer
494 instance Outputable IfaceIdInfo where
496 ppr (HasInfo is) = ptext SLIT("{-") <+> fsep (map ppr_hs_info is) <+> ptext SLIT("-}")
498 ppr_hs_info (HsUnfold unf) = ptext SLIT("Unfolding:") <+>
499 parens (pprIfaceExpr noParens unf)
500 ppr_hs_info (HsInline act) = ptext SLIT("Inline:") <+> ppr act
501 ppr_hs_info (HsArity arity) = ptext SLIT("Arity:") <+> int arity
502 ppr_hs_info (HsStrictness str) = ptext SLIT("Strictness:") <+> pprIfaceStrictSig str
503 ppr_hs_info HsNoCafRefs = ptext SLIT("HasNoCafRefs")
504 ppr_hs_info (HsWorker w a) = ptext SLIT("Worker:") <+> ppr w <+> int a
508 %************************************************************************
510 Equality, for interface file version generaion only
512 %************************************************************************
514 Equality over IfaceSyn returns an IfaceEq, not a Bool. The new
515 constructor is EqBut, which gives the set of things whose version must
516 be equal for the whole thing to be equal. So the key function is
517 eqIfExt, which compares Names.
519 Of course, equality is also done modulo alpha conversion.
523 = Equal -- Definitely exactly the same
524 | NotEqual -- Definitely different
525 | EqBut a -- The same provided these Names have not changed
527 type IfaceEq = GenIfaceEq NameSet
529 instance Outputable IfaceEq where
530 ppr Equal = ptext SLIT("Equal")
531 ppr NotEqual = ptext SLIT("NotEqual")
532 ppr (EqBut occset) = ptext SLIT("EqBut") <+> ppr (nameSetToList occset)
534 bool :: Bool -> IfaceEq
536 bool False = NotEqual
538 toBool :: IfaceEq -> Bool
540 toBool (EqBut _) = True
541 toBool NotEqual = False
543 zapEq :: IfaceEq -> IfaceEq -- Used to forget EqBut information
544 zapEq (EqBut _) = Equal
547 (&&&) :: IfaceEq -> IfaceEq -> IfaceEq
549 NotEqual &&& x = NotEqual
550 EqBut nms &&& Equal = EqBut nms
551 EqBut nms &&& NotEqual = NotEqual
552 EqBut nms1 &&& EqBut nms2 = EqBut (nms1 `unionNameSets` nms2)
554 -- This function is the core of the EqBut stuff
555 -- ASSUMPTION: The left-hand argument is the NEW CODE, and hence
556 -- any Names in the left-hand arg have the correct parent in them.
557 eqIfExt :: Name -> Name -> IfaceEq
559 | name1 == name2 = EqBut (unitNameSet name1)
560 | otherwise = NotEqual
562 ---------------------
563 checkBootDecl :: IfaceDecl -- The boot decl
564 -> IfaceDecl -- The real decl
565 -> Bool -- True <=> compatible
566 checkBootDecl (IfaceId s1 t1 _) (IfaceId s2 t2 _)
567 = ASSERT( s1==s2 ) toBool (t1 `eqIfType` t2)
569 checkBootDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
570 = ASSERT (ifName d1 == ifName d2 ) ifExtName d1 == ifExtName d2
572 checkBootDecl d1@(IfaceSyn {}) d2@(IfaceSyn {})
573 = ASSERT( ifName d1 == ifName d2 )
574 toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
575 eq_ifType env (ifSynRhs d1) (ifSynRhs d2)
577 checkBootDecl d1@(IfaceData {}) d2@(IfaceData {})
578 -- We don't check the recursion flags because the boot-one is
579 -- recursive, to be conservative, but the real one may not be.
580 -- I'm not happy with the way recursive flags are dealt with.
581 = ASSERT( ifName d1 == ifName d2 )
582 toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
583 eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
585 IfAbstractTyCon -> Equal
586 cons1 -> eq_hsCD env cons1 (ifCons d2)
588 checkBootDecl d1@(IfaceClass {}) d2@(IfaceClass {})
589 = ASSERT( ifName d1 == ifName d2 )
590 toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
591 eqListBy (eq_hsFD env) (ifFDs d1) (ifFDs d2) &&&
592 case (ifCtxt d1, ifSigs d1) of
594 (cxt1, sigs1) -> eq_ifContext env cxt1 (ifCtxt d2) &&&
595 eqListBy (eq_cls_sig env) sigs1 (ifSigs d2)
597 checkBootDecl _ _ = False -- default case
599 ---------------------
600 eqIfDecl :: IfaceDecl -> IfaceDecl -> IfaceEq
601 eqIfDecl (IfaceId s1 t1 i1) (IfaceId s2 t2 i2)
602 = bool (s1 == s2) &&& (t1 `eqIfType` t2) &&& (i1 `eqIfIdInfo` i2)
604 eqIfDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
605 = bool (ifName d1 == ifName d2 && ifExtName d1 == ifExtName d2)
607 eqIfDecl d1@(IfaceData {}) d2@(IfaceData {})
608 = bool (ifName d1 == ifName d2 &&
609 ifRec d1 == ifRec d2 &&
610 ifGadtSyntax d1 == ifGadtSyntax d2 &&
611 ifGeneric d1 == ifGeneric d2) &&&
612 ifFamInst d1 `eqIfTc_fam` ifFamInst d2 &&&
613 eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
614 eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
615 eq_hsCD env (ifCons d1) (ifCons d2)
617 -- The type variables of the data type do not scope
618 -- over the constructors (any more), but they do scope
619 -- over the stupid context in the IfaceConDecls
621 Nothing `eqIfTc_fam` Nothing = Equal
622 (Just (fam1, tys1)) `eqIfTc_fam` (Just (fam2, tys2)) =
623 fam1 `eqIfTc` fam2 &&& eqListBy eqIfType tys1 tys2
624 _ `eqIfTc_fam` _ = NotEqual
626 eqIfDecl d1@(IfaceSyn {}) d2@(IfaceSyn {})
627 = bool (ifName d1 == ifName d2) &&&
628 eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
629 eq_ifType env (ifSynRhs d1) (ifSynRhs d2)
632 eqIfDecl d1@(IfaceClass {}) d2@(IfaceClass {})
633 = bool (ifName d1 == ifName d2 &&
634 ifRec d1 == ifRec d2) &&&
635 eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
636 eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
637 eqListBy (eq_hsFD env) (ifFDs d1) (ifFDs d2) &&&
638 eqListBy eqIfDecl (ifATs d1) (ifATs d2) &&&
639 eqListBy (eq_cls_sig env) (ifSigs d1) (ifSigs d2)
642 eqIfDecl _ _ = NotEqual -- default case
645 eqWith :: [IfaceTvBndr] -> [IfaceTvBndr] -> (EqEnv -> IfaceEq) -> IfaceEq
646 eqWith = eq_ifTvBndrs emptyEqEnv
648 -----------------------
649 eqIfInst d1 d2 = bool (ifDFun d1 == ifDFun d2 && ifOFlag d1 == ifOFlag d2)
650 -- All other changes are handled via the version info on the dfun
652 eqIfRule (IfaceRule n1 a1 bs1 f1 es1 rhs1 o1)
653 (IfaceRule n2 a2 bs2 f2 es2 rhs2 o2)
654 = bool (n1==n2 && a1==a2 && o1 == o2) &&&
656 eq_ifBndrs emptyEqEnv bs1 bs2 (\env ->
657 zapEq (eqListBy (eq_ifaceExpr env) es1 es2) &&&
658 -- zapEq: for the LHSs, ignore the EqBut part
659 eq_ifaceExpr env rhs1 rhs2)
661 eq_hsCD env (IfDataTyCon c1) (IfDataTyCon c2)
662 = eqListBy (eq_ConDecl env) c1 c2
664 eq_hsCD env (IfNewTyCon c1) (IfNewTyCon c2) = eq_ConDecl env c1 c2
665 eq_hsCD env IfAbstractTyCon IfAbstractTyCon = Equal
666 eq_hsCD env IfOpenDataTyCon IfOpenDataTyCon = Equal
667 eq_hsCD env IfOpenNewTyCon IfOpenNewTyCon = Equal
668 eq_hsCD env d1 d2 = NotEqual
671 = bool (ifConOcc c1 == ifConOcc c2 &&
672 ifConInfix c1 == ifConInfix c2 &&
673 ifConStricts c1 == ifConStricts c2 &&
674 ifConFields c1 == ifConFields c2) &&&
675 eq_ifTvBndrs env (ifConUnivTvs c1) (ifConUnivTvs c2) (\ env ->
676 eq_ifTvBndrs env (ifConExTvs c1) (ifConExTvs c2) (\ env ->
677 eq_ifContext env (ifConCtxt c1) (ifConCtxt c2) &&&
678 eq_ifTypes env (ifConArgTys c1) (ifConArgTys c2)))
680 eq_hsFD env (ns1,ms1) (ns2,ms2)
681 = eqListBy (eqIfOcc env) ns1 ns2 &&& eqListBy (eqIfOcc env) ms1 ms2
683 eq_cls_sig env (IfaceClassOp n1 dm1 ty1) (IfaceClassOp n2 dm2 ty2)
684 = bool (n1==n2 && dm1 == dm2) &&& eq_ifType env ty1 ty2
690 eqIfIdInfo NoInfo NoInfo = Equal
691 eqIfIdInfo (HasInfo is1) (HasInfo is2) = eqListBy eq_item is1 is2
692 eqIfIdInfo i1 i2 = NotEqual
694 eq_item (HsInline a1) (HsInline a2) = bool (a1 == a2)
695 eq_item (HsArity a1) (HsArity a2) = bool (a1 == a2)
696 eq_item (HsStrictness s1) (HsStrictness s2) = bool (s1 == s2)
697 eq_item (HsUnfold u1) (HsUnfold u2) = eq_ifaceExpr emptyEqEnv u1 u2
698 eq_item HsNoCafRefs HsNoCafRefs = Equal
699 eq_item (HsWorker wkr1 a1) (HsWorker wkr2 a2) = bool (a1==a2) &&& (wkr1 `eqIfExt` wkr2)
700 eq_item _ _ = NotEqual
703 eq_ifaceExpr :: EqEnv -> IfaceExpr -> IfaceExpr -> IfaceEq
704 eq_ifaceExpr env (IfaceLcl v1) (IfaceLcl v2) = eqIfOcc env v1 v2
705 eq_ifaceExpr env (IfaceExt v1) (IfaceExt v2) = eqIfExt v1 v2
706 eq_ifaceExpr env (IfaceLit l1) (IfaceLit l2) = bool (l1 == l2)
707 eq_ifaceExpr env (IfaceFCall c1 ty1) (IfaceFCall c2 ty2) = bool (c1==c2) &&& eq_ifType env ty1 ty2
708 eq_ifaceExpr env (IfaceType ty1) (IfaceType ty2) = eq_ifType env ty1 ty2
709 eq_ifaceExpr env (IfaceTuple n1 as1) (IfaceTuple n2 as2) = bool (n1==n2) &&& eqListBy (eq_ifaceExpr env) as1 as2
710 eq_ifaceExpr env (IfaceLam b1 body1) (IfaceLam b2 body2) = eq_ifBndr env b1 b2 (\env -> eq_ifaceExpr env body1 body2)
711 eq_ifaceExpr env (IfaceApp f1 a1) (IfaceApp f2 a2) = eq_ifaceExpr env f1 f2 &&& eq_ifaceExpr env a1 a2
712 eq_ifaceExpr env (IfaceCast e1 co1) (IfaceCast e2 co2) = eq_ifaceExpr env e1 e2 &&& eq_ifType env co1 co2
713 eq_ifaceExpr env (IfaceNote n1 r1) (IfaceNote n2 r2) = eq_ifaceNote env n1 n2 &&& eq_ifaceExpr env r1 r2
715 eq_ifaceExpr env (IfaceCase s1 b1 ty1 as1) (IfaceCase s2 b2 ty2 as2)
716 = eq_ifaceExpr env s1 s2 &&&
717 eq_ifType env ty1 ty2 &&&
718 eq_ifNakedBndr env b1 b2 (\env -> eqListBy (eq_ifaceAlt env) as1 as2)
720 eq_ifaceAlt env (c1,bs1,r1) (c2,bs2,r2)
721 = bool (eq_ifaceConAlt c1 c2) &&&
722 eq_ifNakedBndrs env bs1 bs2 (\env -> eq_ifaceExpr env r1 r2)
724 eq_ifaceExpr env (IfaceLet (IfaceNonRec b1 r1) x1) (IfaceLet (IfaceNonRec b2 r2) x2)
725 = eq_ifaceExpr env r1 r2 &&& eq_ifIdBndr env b1 b2 (\env -> eq_ifaceExpr env x1 x2)
727 eq_ifaceExpr env (IfaceLet (IfaceRec as1) x1) (IfaceLet (IfaceRec as2) x2)
728 = eq_ifIdBndrs env bs1 bs2 (\env -> eqListBy (eq_ifaceExpr env) rs1 rs2 &&& eq_ifaceExpr env x1 x2)
730 (bs1,rs1) = unzip as1
731 (bs2,rs2) = unzip as2
734 eq_ifaceExpr env _ _ = NotEqual
737 eq_ifaceConAlt :: IfaceConAlt -> IfaceConAlt -> Bool
738 eq_ifaceConAlt IfaceDefault IfaceDefault = True
739 eq_ifaceConAlt (IfaceDataAlt n1) (IfaceDataAlt n2) = n1==n2
740 eq_ifaceConAlt (IfaceTupleAlt c1) (IfaceTupleAlt c2) = c1==c2
741 eq_ifaceConAlt (IfaceLitAlt l1) (IfaceLitAlt l2) = l1==l2
742 eq_ifaceConAlt _ _ = False
745 eq_ifaceNote :: EqEnv -> IfaceNote -> IfaceNote -> IfaceEq
746 eq_ifaceNote env (IfaceSCC c1) (IfaceSCC c2) = bool (c1==c2)
747 eq_ifaceNote env IfaceInlineMe IfaceInlineMe = Equal
748 eq_ifaceNote env (IfaceCoreNote s1) (IfaceCoreNote s2) = bool (s1==s2)
749 eq_ifaceNote env _ _ = NotEqual
753 ---------------------
754 eqIfType t1 t2 = eq_ifType emptyEqEnv t1 t2
757 eq_ifType env (IfaceTyVar n1) (IfaceTyVar n2) = eqIfOcc env n1 n2
758 eq_ifType env (IfaceAppTy s1 t1) (IfaceAppTy s2 t2) = eq_ifType env s1 s2 &&& eq_ifType env t1 t2
759 eq_ifType env (IfacePredTy st1) (IfacePredTy st2) = eq_ifPredType env st1 st2
760 eq_ifType env (IfaceTyConApp tc1 ts1) (IfaceTyConApp tc2 ts2) = tc1 `eqIfTc` tc2 &&& eq_ifTypes env ts1 ts2
761 eq_ifType env (IfaceForAllTy tv1 t1) (IfaceForAllTy tv2 t2) = eq_ifTvBndr env tv1 tv2 (\env -> eq_ifType env t1 t2)
762 eq_ifType env (IfaceFunTy s1 t1) (IfaceFunTy s2 t2) = eq_ifType env s1 s2 &&& eq_ifType env t1 t2
763 eq_ifType env _ _ = NotEqual
766 eq_ifTypes env = eqListBy (eq_ifType env)
769 eq_ifContext env a b = eqListBy (eq_ifPredType env) a b
772 eq_ifPredType env (IfaceClassP c1 tys1) (IfaceClassP c2 tys2) = c1 `eqIfExt` c2 &&& eq_ifTypes env tys1 tys2
773 eq_ifPredType env (IfaceIParam n1 ty1) (IfaceIParam n2 ty2) = bool (n1 == n2) &&& eq_ifType env ty1 ty2
774 eq_ifPredType env _ _ = NotEqual
777 eqIfTc (IfaceTc tc1) (IfaceTc tc2) = tc1 `eqIfExt` tc2
778 eqIfTc IfaceIntTc IfaceIntTc = Equal
779 eqIfTc IfaceCharTc IfaceCharTc = Equal
780 eqIfTc IfaceBoolTc IfaceBoolTc = Equal
781 eqIfTc IfaceListTc IfaceListTc = Equal
782 eqIfTc IfacePArrTc IfacePArrTc = Equal
783 eqIfTc (IfaceTupTc bx1 ar1) (IfaceTupTc bx2 ar2) = bool (bx1==bx2 && ar1==ar2)
784 eqIfTc IfaceLiftedTypeKindTc IfaceLiftedTypeKindTc = Equal
785 eqIfTc IfaceOpenTypeKindTc IfaceOpenTypeKindTc = Equal
786 eqIfTc IfaceUnliftedTypeKindTc IfaceUnliftedTypeKindTc = Equal
787 eqIfTc IfaceUbxTupleKindTc IfaceUbxTupleKindTc = Equal
788 eqIfTc IfaceArgTypeKindTc IfaceArgTypeKindTc = Equal
789 eqIfTc _ _ = NotEqual
792 -----------------------------------------------------------
793 Support code for equality checking
794 -----------------------------------------------------------
797 ------------------------------------
798 type EqEnv = UniqFM FastString -- Tracks the mapping from L-variables to R-variables
800 eqIfOcc :: EqEnv -> FastString -> FastString -> IfaceEq
801 eqIfOcc env n1 n2 = case lookupUFM env n1 of
802 Just n1 -> bool (n1 == n2)
803 Nothing -> bool (n1 == n2)
805 extendEqEnv :: EqEnv -> FastString -> FastString -> EqEnv
806 extendEqEnv env n1 n2 | n1 == n2 = env
807 | otherwise = addToUFM env n1 n2
810 emptyEqEnv = emptyUFM
812 ------------------------------------
813 type ExtEnv bndr = EqEnv -> bndr -> bndr -> (EqEnv -> IfaceEq) -> IfaceEq
815 eq_ifNakedBndr :: ExtEnv FastString
816 eq_ifBndr :: ExtEnv IfaceBndr
817 eq_ifTvBndr :: ExtEnv IfaceTvBndr
818 eq_ifIdBndr :: ExtEnv IfaceIdBndr
820 eq_ifNakedBndr env n1 n2 k = k (extendEqEnv env n1 n2)
822 eq_ifBndr env (IfaceIdBndr b1) (IfaceIdBndr b2) k = eq_ifIdBndr env b1 b2 k
823 eq_ifBndr env (IfaceTvBndr b1) (IfaceTvBndr b2) k = eq_ifTvBndr env b1 b2 k
824 eq_ifBndr _ _ _ _ = NotEqual
826 eq_ifTvBndr env (v1, k1) (v2, k2) k = eq_ifType env k1 k2 &&& k (extendEqEnv env v1 v2)
827 eq_ifIdBndr env (v1, t1) (v2, t2) k = eq_ifType env t1 t2 &&& k (extendEqEnv env v1 v2)
829 eq_ifBndrs :: ExtEnv [IfaceBndr]
830 eq_ifIdBndrs :: ExtEnv [IfaceIdBndr]
831 eq_ifTvBndrs :: ExtEnv [IfaceTvBndr]
832 eq_ifNakedBndrs :: ExtEnv [FastString]
833 eq_ifBndrs = eq_bndrs_with eq_ifBndr
834 eq_ifIdBndrs = eq_bndrs_with eq_ifIdBndr
835 eq_ifTvBndrs = eq_bndrs_with eq_ifTvBndr
836 eq_ifNakedBndrs = eq_bndrs_with eq_ifNakedBndr
838 eq_bndrs_with eq env [] [] k = k env
839 eq_bndrs_with eq env (b1:bs1) (b2:bs2) k = eq env b1 b2 (\env -> eq_bndrs_with eq env bs1 bs2 k)
840 eq_bndrs_with eq env _ _ _ = NotEqual
844 eqListBy :: (a->a->IfaceEq) -> [a] -> [a] -> IfaceEq
845 eqListBy eq [] [] = Equal
846 eqListBy eq (x:xs) (y:ys) = eq x y &&& eqListBy eq xs ys
847 eqListBy eq xs ys = NotEqual
849 eqMaybeBy :: (a->a->IfaceEq) -> Maybe a -> Maybe a -> IfaceEq
850 eqMaybeBy eq Nothing Nothing = Equal
851 eqMaybeBy eq (Just x) (Just y) = eq x y
852 eqMaybeBy eq x y = NotEqual