compiler/iface/IfaceSyn.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
   3 %
   4 %************************************************************************
   5 %*                                                                      *
   6 \section[HsCore]{Core-syntax unfoldings in Haskell interface files}
   7 %*                                                                      *
   8 %************************************************************************
   9
  10 We could either use this, or parameterise @GenCoreExpr@ on @Types@ and
  11 @TyVars@ as well.  Currently trying the former... MEGA SIGH.
  12
  13 \begin{code}
  14 module IfaceSyn (
  15         module IfaceType,               -- Re-export all this
  16
  17         IfaceDecl(..), IfaceClassOp(..), IfaceConDecl(..), IfaceConDecls(..),
  18         IfaceExpr(..), IfaceAlt, IfaceNote(..),
  19         IfaceBinding(..), IfaceConAlt(..), IfaceIdInfo(..),
  20         IfaceInfoItem(..), IfaceRule(..), IfaceInst(..),
  21
  22         -- Misc
  23         visibleIfConDecls,
  24
  25         -- Converting things to IfaceSyn
  26         tyThingToIfaceDecl, instanceToIfaceInst, coreRuleToIfaceRule,
  27
  28         -- Equality
  29         IfaceEq(..), (&&&), bool, eqListBy, eqMaybeBy,
  30         eqIfDecl, eqIfInst, eqIfRule,
  31
  32         -- Pretty printing
  33         pprIfaceExpr, pprIfaceDecl, pprIfaceDeclHead
  34     ) where
  35
  36 #include "HsVersions.h"
  37
  38 import CoreSyn
  39 import IfaceType
  40
  41 import FunDeps          ( pprFundeps )
  42 import NewDemand        ( StrictSig, pprIfaceStrictSig )
  43 import TcType           ( deNoteType )
  44 import Type             ( TyThing(..), splitForAllTys, funResultTy )
  45 import InstEnv          ( Instance(..), OverlapFlag )
  46 import Id               ( Id, idName, idType, idInfo, idArity, isDataConWorkId_maybe, isFCallId_maybe )
  47 import NewDemand        ( isTopSig )
  48 import IdInfo           ( IdInfo, CafInfo(..), WorkerInfo(..),
  49                           arityInfo, cafInfo, newStrictnessInfo,
  50                           workerInfo, unfoldingInfo, inlinePragInfo )
  51 import TyCon            ( TyCon, ArgVrcs, AlgTyConRhs(..), isRecursiveTyCon, isForeignTyCon,
  52                           isSynTyCon, isAlgTyCon, isPrimTyCon, isFunTyCon,
  53                           isTupleTyCon, tupleTyConBoxity, tyConStupidTheta,
  54                           tyConHasGenerics, tyConArgVrcs, synTyConRhs,
  55                           tyConArity, tyConTyVars, algTyConRhs, tyConExtName  )
  56 import DataCon          ( dataConName, dataConSig, dataConFieldLabels, dataConStrictMarks,
  57                           dataConTyCon, dataConIsInfix, isVanillaDataCon )
  58 import Class            ( FunDep, DefMeth, classExtraBigSig, classTyCon )
  59 import OccName          ( OccName, OccEnv, emptyOccEnv,
  60                           lookupOccEnv, extendOccEnv, parenSymOcc,
  61                           OccSet, unionOccSets, unitOccSet )
  62 import Name             ( Name, NamedThing(..), nameOccName, isExternalName )
  63 import CostCentre       ( CostCentre, pprCostCentreCore )
  64 import Literal          ( Literal )
  65 import ForeignCall      ( ForeignCall )
  66 import TysPrim          ( alphaTyVars )
  67 import BasicTypes       ( Arity, Activation(..), StrictnessMark,
  68                           RecFlag(..), boolToRecFlag, Boxity(..),
  69                           isAlwaysActive, tupleParens )
  70 import Outputable
  71 import FastString
  72 import Maybes           ( catMaybes )
  73 import Util             ( lengthIs )
  74
  75 infixl 3 &&&
  76 infix  4 `eqIfExt`, `eqIfIdInfo`, `eqIfType`
  77 \end{code}
  78
  79
  80 %************************************************************************
  81 %*                                                                      *
  82                 Data type declarations
  83 %*                                                                      *
  84 %************************************************************************
  85
  86 \begin{code}
  87 data IfaceDecl
  88   = IfaceId { ifName   :: OccName,
  89               ifType   :: IfaceType,
  90               ifIdInfo :: IfaceIdInfo }
  91
  92   | IfaceData { ifName     :: OccName,          -- Type constructor
  93                 ifTyVars   :: [IfaceTvBndr],    -- Type variables
  94                 ifCtxt     :: IfaceContext,     -- The "stupid theta"
  95                 ifCons     :: IfaceConDecls,    -- Includes new/data info
  96                 ifRec      :: RecFlag,          -- Recursive or not?
  97                 ifVrcs     :: ArgVrcs,
  98                 ifGeneric  :: Bool              -- True <=> generic converter functions available
  99     }                                           -- We need this for imported data decls, since the
 100                                                 -- imported modules may have been compiled with
 101                                                 -- different flags to the current compilation unit
 102
 103   | IfaceSyn  { ifName   :: OccName,            -- Type constructor
 104                 ifTyVars :: [IfaceTvBndr],      -- Type variables
 105                 ifVrcs   :: ArgVrcs,
 106                 ifSynRhs :: IfaceType           -- synonym expansion
 107     }
 108
 109   | IfaceClass { ifCtxt    :: IfaceContext,     -- Context...
 110                  ifName    :: OccName,          -- Name of the class
 111                  ifTyVars  :: [IfaceTvBndr],    -- Type variables
 112                  ifFDs     :: [FunDep OccName], -- Functional dependencies
 113                  ifSigs    :: [IfaceClassOp],   -- Method signatures
 114                  ifRec     :: RecFlag,          -- Is newtype/datatype associated with the class recursive?
 115                  ifVrcs    :: ArgVrcs           -- ... and what are its argument variances ...
 116     }
 117
 118   | IfaceForeign { ifName :: OccName,           -- Needs expanding when we move beyond .NET
 119                    ifExtName :: Maybe FastString }
 120
 121 data IfaceClassOp = IfaceClassOp OccName DefMeth IfaceType
 122         -- Nothing    => no default method
 123         -- Just False => ordinary polymorphic default method
 124         -- Just True  => generic default method
 125
 126 data IfaceConDecls
 127   = IfAbstractTyCon             -- No info
 128   | IfDataTyCon [IfaceConDecl]  -- data type decls
 129   | IfNewTyCon  IfaceConDecl    -- newtype decls
 130
 131 visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
 132 visibleIfConDecls IfAbstractTyCon  = []
 133 visibleIfConDecls (IfDataTyCon cs) = cs
 134 visibleIfConDecls (IfNewTyCon c)   = [c]
 135
 136 data IfaceConDecl
 137   = IfVanillaCon {
 138         ifConOcc     :: OccName,                -- Constructor name
 139         ifConInfix   :: Bool,                   -- True <=> declared infix
 140         ifConArgTys  :: [IfaceType],            -- Arg types
 141         ifConStricts :: [StrictnessMark],       -- Empty (meaning all lazy), or 1-1 corresp with arg types
 142         ifConFields  :: [OccName] }             -- ...ditto... (field labels)
 143   | IfGadtCon {
 144         ifConOcc     :: OccName,                -- Constructor name
 145         ifConTyVars  :: [IfaceTvBndr],          -- All tyvars
 146         ifConCtxt    :: IfaceContext,           -- Non-stupid context
 147         ifConArgTys  :: [IfaceType],            -- Arg types
 148         ifConResTys  :: [IfaceType],            -- Result type args
 149         ifConStricts :: [StrictnessMark] }      -- Empty (meaning all lazy), or 1-1 corresp with arg types
 150
 151 data IfaceInst
 152   = IfaceInst { ifInstCls  :: IfaceExtName,             -- See comments with
 153                 ifInstTys  :: [Maybe IfaceTyCon],       -- the defn of Instance
 154                 ifDFun     :: OccName,                  -- The dfun
 155                 ifOFlag    :: OverlapFlag,              -- Overlap flag
 156                 ifInstOrph :: Maybe OccName }           -- See is_orph in defn of Instance
 157         -- There's always a separate IfaceDecl for the DFun, which gives
 158         -- its IdInfo with its full type and version number.
 159         -- The instance declarations taken together have a version number,
 160         -- and we don't want that to wobble gratuitously
 161         -- If this instance decl is *used*, we'll record a usage on the dfun;
 162         -- and if the head does not change it won't be used if it wasn't before
 163
 164 data IfaceRule
 165   = IfaceRule {
 166         ifRuleName   :: RuleName,
 167         ifActivation :: Activation,
 168         ifRuleBndrs  :: [IfaceBndr],    -- Tyvars and term vars
 169         ifRuleHead   :: IfaceExtName,   -- Head of lhs
 170         ifRuleArgs   :: [IfaceExpr],    -- Args of LHS
 171         ifRuleRhs    :: IfaceExpr,
 172         ifRuleOrph   :: Maybe OccName   -- Just like IfaceInst
 173     }
 174
 175 data IfaceIdInfo
 176   = NoInfo                      -- When writing interface file without -O
 177   | HasInfo [IfaceInfoItem]     -- Has info, and here it is
 178
 179 -- Here's a tricky case:
 180 --   * Compile with -O module A, and B which imports A.f
 181 --   * Change function f in A, and recompile without -O
 182 --   * When we read in old A.hi we read in its IdInfo (as a thunk)
 183 --      (In earlier GHCs we used to drop IdInfo immediately on reading,
 184 --       but we do not do that now.  Instead it's discarded when the
 185 --       ModIface is read into the various decl pools.)
 186 --   * The version comparsion sees that new (=NoInfo) differs from old (=HasInfo *)
 187 --      and so gives a new version.
 188
 189 data IfaceInfoItem
 190   = HsArity      Arity
 191   | HsStrictness StrictSig
 192   | HsInline     Activation
 193   | HsUnfold     IfaceExpr
 194   | HsNoCafRefs
 195   | HsWorker     IfaceExtName Arity     -- Worker, if any see IdInfo.WorkerInfo
 196                                         -- for why we want arity here.
 197         -- NB: we need IfaceExtName (not just OccName) because the worker
 198         --     can simplify to a function in another module.
 199 -- NB: Specialisations and rules come in separately and are
 200 -- only later attached to the Id.  Partial reason: some are orphans.
 201
 202 --------------------------------
 203 data IfaceExpr
 204   = IfaceLcl    OccName
 205   | IfaceExt    IfaceExtName
 206   | IfaceType   IfaceType
 207   | IfaceTuple  Boxity [IfaceExpr]              -- Saturated; type arguments omitted
 208   | IfaceLam    IfaceBndr IfaceExpr
 209   | IfaceApp    IfaceExpr IfaceExpr
 210   | IfaceCase   IfaceExpr OccName IfaceType [IfaceAlt]
 211   | IfaceLet    IfaceBinding  IfaceExpr
 212   | IfaceNote   IfaceNote IfaceExpr
 213   | IfaceLit    Literal
 214   | IfaceFCall  ForeignCall IfaceType
 215
 216 data IfaceNote = IfaceSCC CostCentre
 217                | IfaceCoerce IfaceType
 218                | IfaceInlineCall
 219                | IfaceInlineMe
 220                | IfaceCoreNote String
 221
 222 type IfaceAlt = (IfaceConAlt, [OccName], IfaceExpr)
 223         -- Note: OccName, not IfaceBndr (and same with the case binder)
 224         -- We reconstruct the kind/type of the thing from the context
 225         -- thus saving bulk in interface files
 226
 227 data IfaceConAlt = IfaceDefault
 228                  | IfaceDataAlt OccName
 229                  | IfaceTupleAlt Boxity
 230                  | IfaceLitAlt Literal
 231
 232 data IfaceBinding
 233   = IfaceNonRec IfaceIdBndr IfaceExpr
 234   | IfaceRec    [(IfaceIdBndr, IfaceExpr)]
 235 \end{code}
 236
 237
 238 %************************************************************************
 239 %*                                                                      *
 240 \subsection[HsCore-print]{Printing Core unfoldings}
 241 %*                                                                      *
 242 %************************************************************************
 243
 244 ----------------------------- Printing IfaceDecl ------------------------------------
 245
 246 \begin{code}
 247 instance Outputable IfaceDecl where
 248   ppr = pprIfaceDecl
 249
 250 pprIfaceDecl (IfaceId {ifName = var, ifType = ty, ifIdInfo = info})
 251   = sep [ ppr var <+> dcolon <+> ppr ty,
 252           nest 2 (ppr info) ]
 253
 254 pprIfaceDecl (IfaceForeign {ifName = tycon})
 255   = hsep [ptext SLIT("foreign import type dotnet"), ppr tycon]
 256
 257 pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars, ifSynRhs = mono_ty, ifVrcs = vrcs})
 258   = hang (ptext SLIT("type") <+> pprIfaceDeclHead [] tycon tyvars)
 259        4 (vcat [equals <+> ppr mono_ty,
 260                 pprVrcs vrcs])
 261
 262 pprIfaceDecl (IfaceData {ifName = tycon, ifGeneric = gen, ifCtxt = context,
 263                          ifTyVars = tyvars, ifCons = condecls,
 264                          ifRec = isrec, ifVrcs = vrcs})
 265   = hang (pp_nd <+> pprIfaceDeclHead context tycon tyvars)
 266        4 (vcat [pprVrcs vrcs, pprRec isrec, pprGen gen, pp_condecls tycon condecls])
 267   where
 268     pp_nd = case condecls of
 269                 IfAbstractTyCon -> ptext SLIT("data")
 270                 IfDataTyCon _   -> ptext SLIT("data")
 271                 IfNewTyCon _    -> ptext SLIT("newtype")
 272
 273 pprIfaceDecl (IfaceClass {ifCtxt = context, ifName = clas, ifTyVars = tyvars,
 274                           ifFDs = fds, ifSigs = sigs, ifVrcs = vrcs, ifRec = isrec})
 275   = hang (ptext SLIT("class") <+> pprIfaceDeclHead context clas tyvars <+> pprFundeps fds)
 276        4 (vcat [pprVrcs vrcs,
 277                 pprRec isrec,
 278                 sep (map ppr sigs)])
 279
 280 pprVrcs vrcs = ptext SLIT("Variances") <+> ppr vrcs
 281 pprRec isrec = ptext SLIT("RecFlag") <+> ppr isrec
 282 pprGen True  = ptext SLIT("Generics: yes")
 283 pprGen False = ptext SLIT("Generics: no")
 284
 285 instance Outputable IfaceClassOp where
 286    ppr (IfaceClassOp n dm ty) = ppr n <+> ppr dm <+> dcolon <+> ppr ty
 287
 288 pprIfaceDeclHead :: IfaceContext -> OccName -> [IfaceTvBndr] -> SDoc
 289 pprIfaceDeclHead context thing tyvars
 290   = hsep [pprIfaceContext context, parenSymOcc thing (ppr thing), pprIfaceTvBndrs tyvars]
 291
 292 pp_condecls tc IfAbstractTyCon  = ptext SLIT("{- abstract -}")
 293 pp_condecls tc (IfNewTyCon c)   = equals <+> pprIfaceConDecl tc c
 294 pp_condecls tc (IfDataTyCon cs) = equals <+> sep (punctuate (ptext SLIT(" |"))
 295                                                      (map (pprIfaceConDecl tc) cs))
 296
 297 pprIfaceConDecl tc (IfVanillaCon {
 298                       ifConOcc = name, ifConInfix = is_infix,
 299                       ifConArgTys = arg_tys,
 300                       ifConStricts = strs, ifConFields = fields })
 301     = sep [ppr name <+> sep (map pprParendIfaceType arg_tys),
 302            if is_infix then ptext SLIT("Infix") else empty,
 303            if null strs then empty
 304               else nest 4 (ptext SLIT("Stricts:") <+> hsep (map ppr strs)),
 305            if null fields then empty
 306               else nest 4 (ptext SLIT("Fields:") <+> hsep (map ppr fields))]
 307
 308 pprIfaceConDecl tc (IfGadtCon {
 309                       ifConOcc = name,
 310                       ifConTyVars = tvs, ifConCtxt = ctxt,
 311                       ifConArgTys = arg_tys, ifConResTys = res_tys,
 312                       ifConStricts = strs })
 313     = sep [ppr name <+> dcolon <+> pprIfaceForAllPart tvs ctxt (ppr con_tau),
 314            if null strs then empty
 315               else nest 4 (ptext SLIT("Stricts:") <+> hsep (map ppr strs))]
 316     where
 317       con_tau = foldr1 IfaceFunTy (arg_tys ++ [tc_app])
 318       tc_app  = IfaceTyConApp (IfaceTc (LocalTop tc)) res_tys
 319         -- Gruesome, but jsut for debug print
 320
 321 instance Outputable IfaceRule where
 322   ppr (IfaceRule { ifRuleName = name, ifActivation = act, ifRuleBndrs = bndrs,
 323                    ifRuleHead = fn, ifRuleArgs = args, ifRuleRhs = rhs })
 324     = sep [hsep [doubleQuotes (ftext name), ppr act,
 325                  ptext SLIT("forall") <+> pprIfaceBndrs bndrs],
 326            nest 2 (sep [ppr fn <+> sep (map (pprIfaceExpr parens) args),
 327                         ptext SLIT("=") <+> ppr rhs])
 328       ]
 329
 330 instance Outputable IfaceInst where
 331   ppr (IfaceInst {ifDFun = dfun_id, ifOFlag = flag,
 332                   ifInstCls = cls, ifInstTys = mb_tcs})
 333     = hang (ptext SLIT("instance") <+> ppr flag
 334                 <+> ppr cls <+> brackets (pprWithCommas ppr_mb mb_tcs))
 335          2 (equals <+> ppr dfun_id)
 336     where
 337       ppr_mb Nothing   = dot
 338       ppr_mb (Just tc) = ppr tc
 339 \end{code}
 340
 341
 342 ----------------------------- Printing IfaceExpr ------------------------------------
 343
 344 \begin{code}
 345 instance Outputable IfaceExpr where
 346     ppr e = pprIfaceExpr noParens e
 347
 348 pprIfaceExpr :: (SDoc -> SDoc) -> IfaceExpr -> SDoc
 349         -- The function adds parens in context that need
 350         -- an atomic value (e.g. function args)
 351
 352 pprIfaceExpr add_par (IfaceLcl v)       = ppr v
 353 pprIfaceExpr add_par (IfaceExt v)       = ppr v
 354 pprIfaceExpr add_par (IfaceLit l)       = ppr l
 355 pprIfaceExpr add_par (IfaceFCall cc ty) = braces (ppr cc <+> ppr ty)
 356 pprIfaceExpr add_par (IfaceType ty)     = char '@' <+> pprParendIfaceType ty
 357
 358 pprIfaceExpr add_par app@(IfaceApp _ _) = add_par (pprIfaceApp app [])
 359 pprIfaceExpr add_par (IfaceTuple c as)  = tupleParens c (interpp'SP as)
 360
 361 pprIfaceExpr add_par e@(IfaceLam _ _)
 362   = add_par (sep [char '\\' <+> sep (map ppr bndrs) <+> arrow,
 363                   pprIfaceExpr noParens body])
 364   where
 365     (bndrs,body) = collect [] e
 366     collect bs (IfaceLam b e) = collect (b:bs) e
 367     collect bs e              = (reverse bs, e)
 368
 369 -- gaw 2004
 370 pprIfaceExpr add_par (IfaceCase scrut bndr ty [(con, bs, rhs)])
 371 -- gaw 2004
 372   = add_par (sep [ptext SLIT("case") <+> char '@' <+> pprParendIfaceType ty <+> pprIfaceExpr noParens scrut <+> ptext SLIT("of")
 373                         <+> ppr bndr <+> char '{' <+> ppr_con_bs con bs <+> arrow,
 374                   pprIfaceExpr noParens rhs <+> char '}'])
 375
 376 -- gaw 2004
 377 pprIfaceExpr add_par (IfaceCase scrut bndr ty alts)
 378 -- gaw 2004
 379   = add_par (sep [ptext SLIT("case") <+> char '@' <+> pprParendIfaceType ty <+> pprIfaceExpr noParens scrut <+> ptext SLIT("of")
 380                         <+> ppr bndr <+> char '{',
 381                   nest 2 (sep (map ppr_alt alts)) <+> char '}'])
 382
 383 pprIfaceExpr add_par (IfaceLet (IfaceNonRec b rhs) body)
 384   = add_par (sep [ptext SLIT("let {"),
 385                   nest 2 (ppr_bind (b, rhs)),
 386                   ptext SLIT("} in"),
 387                   pprIfaceExpr noParens body])
 388
 389 pprIfaceExpr add_par (IfaceLet (IfaceRec pairs) body)
 390   = add_par (sep [ptext SLIT("letrec {"),
 391                   nest 2 (sep (map ppr_bind pairs)),
 392                   ptext SLIT("} in"),
 393                   pprIfaceExpr noParens body])
 394
 395 pprIfaceExpr add_par (IfaceNote note body) = add_par (ppr note <+> pprIfaceExpr parens body)
 396
 397 ppr_alt (con, bs, rhs) = sep [ppr_con_bs con bs,
 398                               arrow <+> pprIfaceExpr noParens rhs]
 399
 400 ppr_con_bs (IfaceTupleAlt tup_con) bs = tupleParens tup_con (interpp'SP bs)
 401 ppr_con_bs con bs                     = ppr con <+> hsep (map ppr bs)
 402
 403 ppr_bind ((b,ty),rhs) = sep [ppr b <+> dcolon <+> ppr ty,
 404                              equals <+> pprIfaceExpr noParens rhs]
 405
 406 ------------------
 407 pprIfaceApp (IfaceApp fun arg) args = pprIfaceApp fun (nest 2 (pprIfaceExpr parens arg) : args)
 408 pprIfaceApp fun                args = sep (pprIfaceExpr parens fun : args)
 409
 410 ------------------
 411 instance Outputable IfaceNote where
 412     ppr (IfaceSCC cc)     = pprCostCentreCore cc
 413     ppr (IfaceCoerce ty)  = ptext SLIT("__coerce") <+> pprParendIfaceType ty
 414     ppr IfaceInlineCall   = ptext SLIT("__inline_call")
 415     ppr IfaceInlineMe     = ptext SLIT("__inline_me")
 416     ppr (IfaceCoreNote s) = ptext SLIT("__core_note") <+> pprHsString (mkFastString s)
 417
 418 instance Outputable IfaceConAlt where
 419     ppr IfaceDefault      = text "DEFAULT"
 420     ppr (IfaceLitAlt l)   = ppr l
 421     ppr (IfaceDataAlt d)  = ppr d
 422     ppr (IfaceTupleAlt b) = panic "ppr IfaceConAlt"
 423         -- IfaceTupleAlt is handled by the case-alternative printer
 424
 425 ------------------
 426 instance Outputable IfaceIdInfo where
 427    ppr NoInfo       = empty
 428    ppr (HasInfo is) = ptext SLIT("{-") <+> fsep (map ppr_hs_info is) <+> ptext SLIT("-}")
 429
 430 ppr_hs_info (HsUnfold unf)      = ptext SLIT("Unfolding:") <+>
 431                                         parens (pprIfaceExpr noParens unf)
 432 ppr_hs_info (HsInline act)      = ptext SLIT("Inline:") <+> ppr act
 433 ppr_hs_info (HsArity arity)     = ptext SLIT("Arity:") <+> int arity
 434 ppr_hs_info (HsStrictness str)  = ptext SLIT("Strictness:") <+> pprIfaceStrictSig str
 435 ppr_hs_info HsNoCafRefs         = ptext SLIT("HasNoCafRefs")
 436 ppr_hs_info (HsWorker w a)      = ptext SLIT("Worker:") <+> ppr w <+> int a
 437 \end{code}
 438
 439
 440 %************************************************************************
 441 %*                                                                      *
 442         Converting things to their Iface equivalents
 443 %*                                                                      *
 444 %************************************************************************
 445
 446
 447 \begin{code}
 448 tyThingToIfaceDecl :: (Name -> IfaceExtName) -> TyThing -> IfaceDecl
 449 -- Assumption: the thing is already tidied, so that locally-bound names
 450 --             (lambdas, for-alls) already have non-clashing OccNames
 451 -- Reason: Iface stuff uses OccNames, and the conversion here does
 452 --         not do tidying on the way
 453 tyThingToIfaceDecl ext (AnId id)
 454   = IfaceId { ifName   = getOccName id,
 455               ifType   = toIfaceType ext (idType id),
 456               ifIdInfo = info }
 457   where
 458     info = case toIfaceIdInfo ext (idInfo id) of
 459                 []    -> NoInfo
 460                 items -> HasInfo items
 461
 462 tyThingToIfaceDecl ext (AClass clas)
 463   = IfaceClass { ifCtxt   = toIfaceContext ext sc_theta,
 464                  ifName   = getOccName clas,
 465                  ifTyVars = toIfaceTvBndrs clas_tyvars,
 466                  ifFDs    = map toIfaceFD clas_fds,
 467                  ifSigs   = map toIfaceClassOp op_stuff,
 468                  ifRec    = boolToRecFlag (isRecursiveTyCon tycon),
 469                  ifVrcs   = tyConArgVrcs tycon }
 470   where
 471     (clas_tyvars, clas_fds, sc_theta, _, op_stuff) = classExtraBigSig clas
 472     tycon = classTyCon clas
 473
 474     toIfaceClassOp (sel_id, def_meth)
 475         = ASSERT(sel_tyvars == clas_tyvars)
 476           IfaceClassOp (getOccName sel_id) def_meth (toIfaceType ext op_ty)
 477         where
 478                 -- Be careful when splitting the type, because of things
 479                 -- like         class Foo a where
 480                 --                op :: (?x :: String) => a -> a
 481                 -- and          class Baz a where
 482                 --                op :: (Ord a) => a -> a
 483           (sel_tyvars, rho_ty) = splitForAllTys (idType sel_id)
 484           op_ty                = funResultTy rho_ty
 485
 486     toIfaceFD (tvs1, tvs2) = (map getOccName tvs1, map getOccName tvs2)
 487
 488 tyThingToIfaceDecl ext (ATyCon tycon)
 489   | isSynTyCon tycon
 490   = IfaceSyn {  ifName   = getOccName tycon,
 491                 ifTyVars = toIfaceTvBndrs tyvars,
 492                 ifVrcs    = tyConArgVrcs tycon,
 493                 ifSynRhs = toIfaceType ext syn_ty }
 494
 495   | isAlgTyCon tycon
 496   = IfaceData { ifName    = getOccName tycon,
 497                 ifTyVars  = toIfaceTvBndrs tyvars,
 498                 ifCtxt    = toIfaceContext ext (tyConStupidTheta tycon),
 499                 ifCons    = ifaceConDecls (algTyConRhs tycon),
 500                 ifRec     = boolToRecFlag (isRecursiveTyCon tycon),
 501                 ifVrcs    = tyConArgVrcs tycon,
 502                 ifGeneric = tyConHasGenerics tycon }
 503
 504   | isForeignTyCon tycon
 505   = IfaceForeign { ifName    = getOccName tycon,
 506                    ifExtName = tyConExtName tycon }
 507
 508   | isPrimTyCon tycon || isFunTyCon tycon
 509         -- Needed in GHCi for ':info Int#', for example
 510   = IfaceData { ifName    = getOccName tycon,
 511                 ifTyVars  = toIfaceTvBndrs (take (tyConArity tycon) alphaTyVars),
 512                 ifCtxt    = [],
 513                 ifCons    = IfAbstractTyCon,
 514                 ifGeneric = False,
 515                 ifRec     = NonRecursive,
 516                 ifVrcs    = tyConArgVrcs tycon }
 517
 518   | otherwise = pprPanic "toIfaceDecl" (ppr tycon)
 519   where
 520     tyvars = tyConTyVars tycon
 521     syn_ty = synTyConRhs tycon
 522
 523     ifaceConDecls (NewTyCon { data_con = con })    = IfNewTyCon  (ifaceConDecl con)
 524     ifaceConDecls (DataTyCon { data_cons = cons }) = IfDataTyCon (map ifaceConDecl cons)
 525     ifaceConDecls AbstractTyCon                    = IfAbstractTyCon
 526         -- The last case happens when a TyCon has been trimmed during tidying
 527         -- Furthermore, tyThingToIfaceDecl is also used
 528         -- in TcRnDriver for GHCi, when browsing a module, in which case the
 529         -- AbstractTyCon case is perfectly sensible.
 530
 531     ifaceConDecl data_con
 532         | isVanillaDataCon data_con
 533         = IfVanillaCon {ifConOcc = getOccName (dataConName data_con),
 534                         ifConInfix = dataConIsInfix data_con,
 535                         ifConArgTys = map (toIfaceType ext) arg_tys,
 536                         ifConStricts = strict_marks,
 537                         ifConFields = map getOccName field_labels }
 538         | otherwise
 539         = IfGadtCon   { ifConOcc = getOccName (dataConName data_con),
 540                         ifConTyVars = toIfaceTvBndrs tyvars,
 541                         ifConCtxt = toIfaceContext ext theta,
 542                         ifConArgTys = map (toIfaceType ext) arg_tys,
 543                         ifConResTys = map (toIfaceType ext) res_tys,
 544                         ifConStricts = strict_marks }
 545         where
 546           (tyvars, theta, arg_tys, _, res_tys) = dataConSig data_con
 547           field_labels = dataConFieldLabels data_con
 548           strict_marks = dataConStrictMarks data_con
 549
 550 tyThingToIfaceDecl ext (ADataCon dc)
 551  = pprPanic "toIfaceDecl" (ppr dc)      -- Should be trimmed out earlier
 552
 553
 554 --------------------------
 555 instanceToIfaceInst :: (Name -> IfaceExtName) -> Instance -> IfaceInst
 556 instanceToIfaceInst ext_lhs ispec@(Instance { is_dfun = dfun_id, is_flag = oflag,
 557                                               is_cls = cls, is_tcs = mb_tcs,
 558                                               is_orph = orph })
 559   = IfaceInst { ifDFun    = getOccName dfun_id,
 560                 ifOFlag   = oflag,
 561                 ifInstCls = ext_lhs cls,
 562                 ifInstTys = map do_rough mb_tcs,
 563                 ifInstOrph = orph }
 564   where
 565     do_rough Nothing  = Nothing
 566     do_rough (Just n) = Just (toIfaceTyCon_name ext_lhs n)
 567
 568 --------------------------
 569 toIfaceIdInfo :: (Name -> IfaceExtName) -> IdInfo -> [IfaceInfoItem]
 570 toIfaceIdInfo ext id_info
 571   = catMaybes [arity_hsinfo, caf_hsinfo, strict_hsinfo,
 572                inline_hsinfo, wrkr_hsinfo,  unfold_hsinfo]
 573   where
 574     ------------  Arity  --------------
 575     arity_info = arityInfo id_info
 576     arity_hsinfo | arity_info == 0 = Nothing
 577                  | otherwise       = Just (HsArity arity_info)
 578
 579     ------------ Caf Info --------------
 580     caf_info   = cafInfo id_info
 581     caf_hsinfo = case caf_info of
 582                    NoCafRefs -> Just HsNoCafRefs
 583                    _other    -> Nothing
 584
 585     ------------  Strictness  --------------
 586         -- No point in explicitly exporting TopSig
 587     strict_hsinfo = case newStrictnessInfo id_info of
 588                         Just sig | not (isTopSig sig) -> Just (HsStrictness sig)
 589                         _other                        -> Nothing
 590
 591     ------------  Worker  --------------
 592     work_info   = workerInfo id_info
 593     has_worker  = case work_info of { HasWorker _ _ -> True; other -> False }
 594     wrkr_hsinfo = case work_info of
 595                     HasWorker work_id wrap_arity ->
 596                         Just (HsWorker (ext (idName work_id)) wrap_arity)
 597                     NoWorker -> Nothing
 598
 599     ------------  Unfolding  --------------
 600     -- The unfolding is redundant if there is a worker
 601     unfold_info  = unfoldingInfo id_info
 602     rhs          = unfoldingTemplate unfold_info
 603     no_unfolding = neverUnfold unfold_info
 604                         -- The CoreTidy phase retains unfolding info iff
 605                         -- we want to expose the unfolding, taking into account
 606                         -- unconditional NOINLINE, etc.  See TidyPgm.addExternal
 607     unfold_hsinfo | no_unfolding = Nothing
 608                   | has_worker   = Nothing      -- Unfolding is implicit
 609                   | otherwise    = Just (HsUnfold (toIfaceExpr ext rhs))
 610
 611     ------------  Inline prag  --------------
 612     inline_prag = inlinePragInfo id_info
 613     inline_hsinfo | isAlwaysActive inline_prag     = Nothing
 614                   | no_unfolding && not has_worker = Nothing
 615                         -- If the iface file give no unfolding info, we
 616                         -- don't need to say when inlining is OK!
 617                   | otherwise                      = Just (HsInline inline_prag)
 618
 619 --------------------------
 620 coreRuleToIfaceRule :: (Name -> IfaceExtName)   -- For the LHS names
 621                     -> (Name -> IfaceExtName)   -- For the RHS names
 622                     -> CoreRule -> IfaceRule
 623 coreRuleToIfaceRule ext_lhs ext_rhs (BuiltinRule { ru_fn = fn})
 624   = pprTrace "toHsRule: builtin" (ppr fn) $
 625     bogusIfaceRule (mkIfaceExtName fn)
 626
 627 coreRuleToIfaceRule ext_lhs ext_rhs
 628     (Rule { ru_name = name, ru_fn = fn, ru_act = act, ru_bndrs = bndrs,
 629             ru_args = args, ru_rhs = rhs, ru_orph = orph })
 630   = IfaceRule { ifRuleName  = name, ifActivation = act,
 631                 ifRuleBndrs = map (toIfaceBndr ext_lhs) bndrs,
 632                 ifRuleHead  = ext_lhs fn,
 633                 ifRuleArgs  = map do_arg args,
 634                 ifRuleRhs   = toIfaceExpr ext_rhs rhs,
 635                 ifRuleOrph  = orph }
 636   where
 637         -- For type args we must remove synonyms from the outermost
 638         -- level.  Reason: so that when we read it back in we'll
 639         -- construct the same ru_rough field as we have right now;
 640         -- see tcIfaceRule
 641     do_arg (Type ty) = IfaceType (toIfaceType ext_lhs (deNoteType ty))
 642     do_arg arg       = toIfaceExpr ext_lhs arg
 643
 644 bogusIfaceRule :: IfaceExtName -> IfaceRule
 645 bogusIfaceRule id_name
 646   = IfaceRule { ifRuleName = FSLIT("bogus"), ifActivation = NeverActive,
 647         ifRuleBndrs = [], ifRuleHead = id_name, ifRuleArgs = [],
 648         ifRuleRhs = IfaceExt id_name, ifRuleOrph = Nothing }
 649
 650 ---------------------
 651 toIfaceExpr :: (Name -> IfaceExtName) -> CoreExpr -> IfaceExpr
 652 toIfaceExpr ext (Var v)       = toIfaceVar ext v
 653 toIfaceExpr ext (Lit l)       = IfaceLit l
 654 toIfaceExpr ext (Type ty)     = IfaceType (toIfaceType ext ty)
 655 toIfaceExpr ext (Lam x b)     = IfaceLam (toIfaceBndr ext x) (toIfaceExpr ext b)
 656 toIfaceExpr ext (App f a)     = toIfaceApp ext f [a]
 657 toIfaceExpr ext (Case s x ty as) = IfaceCase (toIfaceExpr ext s) (getOccName x) (toIfaceType ext ty) (map (toIfaceAlt ext) as)
 658 toIfaceExpr ext (Let b e)     = IfaceLet (toIfaceBind ext b) (toIfaceExpr ext e)
 659 toIfaceExpr ext (Note n e)    = IfaceNote (toIfaceNote ext n) (toIfaceExpr ext e)
 660
 661 ---------------------
 662 toIfaceNote ext (SCC cc)      = IfaceSCC cc
 663 toIfaceNote ext (Coerce t1 _) = IfaceCoerce (toIfaceType ext t1)
 664 toIfaceNote ext InlineCall    = IfaceInlineCall
 665 toIfaceNote ext InlineMe      = IfaceInlineMe
 666 toIfaceNote ext (CoreNote s)  = IfaceCoreNote s
 667
 668 ---------------------
 669 toIfaceBind ext (NonRec b r) = IfaceNonRec (toIfaceIdBndr ext b) (toIfaceExpr ext r)
 670 toIfaceBind ext (Rec prs)    = IfaceRec [(toIfaceIdBndr ext b, toIfaceExpr ext r) | (b,r) <- prs]
 671
 672 ---------------------
 673 toIfaceAlt ext (c,bs,r) = (toIfaceCon c, map getOccName bs, toIfaceExpr ext r)
 674
 675 ---------------------
 676 toIfaceCon (DataAlt dc) | isTupleTyCon tc = IfaceTupleAlt (tupleTyConBoxity tc)
 677                         | otherwise       = IfaceDataAlt (getOccName dc)
 678                         where
 679                           tc = dataConTyCon dc
 680
 681 toIfaceCon (LitAlt l) = IfaceLitAlt l
 682 toIfaceCon DEFAULT    = IfaceDefault
 683
 684 ---------------------
 685 toIfaceApp ext (App f a) as = toIfaceApp ext f (a:as)
 686 toIfaceApp ext (Var v) as
 687   = case isDataConWorkId_maybe v of
 688         -- We convert the *worker* for tuples into IfaceTuples
 689         Just dc |  isTupleTyCon tc && saturated
 690                 -> IfaceTuple (tupleTyConBoxity tc) tup_args
 691           where
 692             val_args  = dropWhile isTypeArg as
 693             saturated = val_args `lengthIs` idArity v
 694             tup_args  = map (toIfaceExpr ext) val_args
 695             tc        = dataConTyCon dc
 696
 697         other -> mkIfaceApps ext (toIfaceVar ext v) as
 698
 699 toIfaceApp ext e as = mkIfaceApps ext (toIfaceExpr ext e) as
 700
 701 mkIfaceApps ext f as = foldl (\f a -> IfaceApp f (toIfaceExpr ext a)) f as
 702
 703 ---------------------
 704 toIfaceVar :: (Name -> IfaceExtName) -> Id -> IfaceExpr
 705 toIfaceVar ext v
 706   | Just fcall <- isFCallId_maybe v = IfaceFCall fcall (toIfaceType ext (idType v))
 707           -- Foreign calls have special syntax
 708   | isExternalName name             = IfaceExt (ext name)
 709   | otherwise                       = IfaceLcl (nameOccName name)
 710   where
 711     name = idName v
 712 \end{code}
 713
 714
 715 %************************************************************************
 716 %*                                                                      *
 717         Equality, for interface file version generaion only
 718 %*                                                                      *
 719 %************************************************************************
 720
 721 Equality over IfaceSyn returns an IfaceEq, not a Bool.  The new constructor is
 722 EqBut, which gives the set of *locally-defined* things whose version must be equal
 723 for the whole thing to be equal.  So the key function is eqIfExt, which compares
 724 IfaceExtNames.
 725
 726 Of course, equality is also done modulo alpha conversion.
 727
 728 \begin{code}
 729 data IfaceEq
 730   = Equal               -- Definitely exactly the same
 731   | NotEqual            -- Definitely different
 732   | EqBut OccSet        -- The same provided these local things have not changed
 733
 734 bool :: Bool -> IfaceEq
 735 bool True  = Equal
 736 bool False = NotEqual
 737
 738 zapEq :: IfaceEq -> IfaceEq     -- Used to forget EqBut information
 739 zapEq (EqBut _) = Equal
 740 zapEq other     = other
 741
 742 (&&&) :: IfaceEq -> IfaceEq -> IfaceEq
 743 Equal       &&& x           = x
 744 NotEqual    &&& x           = NotEqual
 745 EqBut occs  &&& Equal       = EqBut occs
 746 EqBut occs  &&& NotEqual    = NotEqual
 747 EqBut occs1 &&& EqBut occs2 = EqBut (occs1 `unionOccSets` occs2)
 748
 749 ---------------------
 750 eqIfExt :: IfaceExtName -> IfaceExtName -> IfaceEq
 751 -- This function is the core of the EqBut stuff
 752 eqIfExt (ExtPkg mod1 occ1)     (ExtPkg mod2 occ2)     = bool (mod1==mod2 && occ1==occ2)
 753 eqIfExt (HomePkg mod1 occ1 v1) (HomePkg mod2 occ2 v2) = bool (mod1==mod2 && occ1==occ2 && v1==v2)
 754 eqIfExt (LocalTop occ1)       (LocalTop occ2)      | occ1 == occ2 = EqBut (unitOccSet occ1)
 755 eqIfExt (LocalTopSub occ1 p1) (LocalTop occ2)      | occ1 == occ2 = EqBut (unitOccSet p1)
 756 eqIfExt (LocalTopSub occ1 p1) (LocalTopSub occ2 _) | occ1 == occ2 = EqBut (unitOccSet p1)
 757 eqIfExt n1 n2 = NotEqual
 758 \end{code}
 759
 760
 761 \begin{code}
 762 ---------------------
 763 eqIfDecl :: IfaceDecl -> IfaceDecl -> IfaceEq
 764 eqIfDecl (IfaceId s1 t1 i1) (IfaceId s2 t2 i2)
 765   = bool (s1 == s2) &&& (t1 `eqIfType` t2) &&& (i1 `eqIfIdInfo` i2)
 766
 767 eqIfDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
 768   = bool (ifName d1 == ifName d2 && ifExtName d1 == ifExtName d2)
 769
 770 eqIfDecl d1@(IfaceData {}) d2@(IfaceData {})
 771   = bool (ifName d1    == ifName d2 &&
 772           ifRec d1     == ifRec   d2 &&
 773           ifVrcs d1    == ifVrcs   d2 &&
 774           ifGeneric d1 == ifGeneric d2) &&&
 775     eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
 776             eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
 777             eq_hsCD env (ifCons d1) (ifCons d2)
 778         )
 779         -- The type variables of the data type do not scope
 780         -- over the constructors (any more), but they do scope
 781         -- over the stupid context in the IfaceConDecls
 782
 783 eqIfDecl d1@(IfaceSyn {}) d2@(IfaceSyn {})
 784   = bool (ifName d1 == ifName d2) &&&
 785     eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
 786           eq_ifType env (ifSynRhs d1) (ifSynRhs d2)
 787         )
 788
 789 eqIfDecl d1@(IfaceClass {}) d2@(IfaceClass {})
 790   = bool (ifName d1 == ifName d2 &&
 791           ifRec d1  == ifRec  d2 &&
 792           ifVrcs d1 == ifVrcs d2) &&&
 793     eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
 794           eq_ifContext env (ifCtxt d1) (ifCtxt d2)  &&&
 795           eqListBy (eq_hsFD env)    (ifFDs d1)  (ifFDs d2) &&&
 796           eqListBy (eq_cls_sig env) (ifSigs d1) (ifSigs d2)
 797        )
 798
 799 eqIfDecl _ _ = NotEqual -- default case
 800
 801 -- Helper
 802 eqWith :: [IfaceTvBndr] -> [IfaceTvBndr] -> (EqEnv -> IfaceEq) -> IfaceEq
 803 eqWith = eq_ifTvBndrs emptyEqEnv
 804
 805 -----------------------
 806 eqIfInst d1 d2 = bool (ifDFun d1 == ifDFun d2)
 807 -- All other changes are handled via the version info on the dfun
 808
 809 eqIfRule (IfaceRule n1 a1 bs1 f1 es1 rhs1 o1)
 810          (IfaceRule n2 a2 bs2 f2 es2 rhs2 o2)
 811        = bool (n1==n2 && a1==a2 && o1 == o2) &&&
 812          f1 `eqIfExt` f2 &&&
 813          eq_ifBndrs emptyEqEnv bs1 bs2 (\env ->
 814          zapEq (eqListBy (eq_ifaceExpr env) es1 es2) &&&
 815                 -- zapEq: for the LHSs, ignore the EqBut part
 816          eq_ifaceExpr env rhs1 rhs2)
 817
 818 eq_hsCD env (IfDataTyCon c1) (IfDataTyCon c2)
 819   = eqListBy (eq_ConDecl env) c1 c2
 820
 821 eq_hsCD env (IfNewTyCon c1)  (IfNewTyCon c2)  = eq_ConDecl env c1 c2
 822 eq_hsCD env IfAbstractTyCon  IfAbstractTyCon  = Equal
 823 eq_hsCD env d1               d2               = NotEqual
 824
 825 eq_ConDecl env c1@(IfVanillaCon {}) c2@(IfVanillaCon {})
 826   = bool (ifConOcc c1     == ifConOcc c2 &&
 827           ifConInfix c1   == ifConInfix c2 &&
 828           ifConStricts c1 == ifConStricts c2 &&
 829           ifConFields c1  == ifConFields c2) &&&
 830    eq_ifTypes env (ifConArgTys c1) (ifConArgTys c2)
 831
 832 eq_ConDecl env c1@(IfGadtCon {}) c2@(IfGadtCon {})
 833   = bool (ifConOcc c1     == ifConOcc c2 &&
 834           ifConStricts c1 == ifConStricts c2) &&&
 835     eq_ifTvBndrs env (ifConTyVars c1) (ifConTyVars c2) (\ env ->
 836         eq_ifContext env (ifConCtxt c1) (ifConCtxt c2) &&&
 837         eq_ifTypes env (ifConResTys c1) (ifConResTys c2) &&&
 838         eq_ifTypes env (ifConArgTys c1) (ifConArgTys c2))
 839
 840 eq_ConDecl env c1 c2 = NotEqual
 841
 842 eq_hsFD env (ns1,ms1) (ns2,ms2)
 843   = eqListBy (eqIfOcc env) ns1 ns2 &&& eqListBy (eqIfOcc env) ms1 ms2
 844
 845 eq_cls_sig env (IfaceClassOp n1 dm1 ty1) (IfaceClassOp n2 dm2 ty2)
 846   = bool (n1==n2 && dm1 == dm2) &&& eq_ifType env ty1 ty2
 847 \end{code}
 848
 849
 850 \begin{code}
 851 -----------------
 852 eqIfIdInfo NoInfo        NoInfo        = Equal
 853 eqIfIdInfo (HasInfo is1) (HasInfo is2) = eqListBy eq_item is1 is2
 854 eqIfIdInfo i1            i2 = NotEqual
 855
 856 eq_item (HsInline a1)      (HsInline a2)      = bool (a1 == a2)
 857 eq_item (HsArity a1)       (HsArity a2)       = bool (a1 == a2)
 858 eq_item (HsStrictness s1)  (HsStrictness s2)  = bool (s1 == s2)
 859 eq_item (HsUnfold u1)   (HsUnfold u2)         = eq_ifaceExpr emptyEqEnv u1 u2
 860 eq_item HsNoCafRefs        HsNoCafRefs        = Equal
 861 eq_item (HsWorker wkr1 a1) (HsWorker wkr2 a2) = bool (a1==a2) &&& (wkr1 `eqIfExt` wkr2)
 862 eq_item _ _ = NotEqual
 863
 864 -----------------
 865 eq_ifaceExpr :: EqEnv -> IfaceExpr -> IfaceExpr -> IfaceEq
 866 eq_ifaceExpr env (IfaceLcl v1)        (IfaceLcl v2)        = eqIfOcc env v1 v2
 867 eq_ifaceExpr env (IfaceExt v1)        (IfaceExt v2)        = eqIfExt v1 v2
 868 eq_ifaceExpr env (IfaceLit l1)        (IfaceLit l2)        = bool (l1 == l2)
 869 eq_ifaceExpr env (IfaceFCall c1 ty1)  (IfaceFCall c2 ty2)  = bool (c1==c2) &&& eq_ifType env ty1 ty2
 870 eq_ifaceExpr env (IfaceType ty1)      (IfaceType ty2)      = eq_ifType env ty1 ty2
 871 eq_ifaceExpr env (IfaceTuple n1 as1)  (IfaceTuple n2 as2)  = bool (n1==n2) &&& eqListBy (eq_ifaceExpr env) as1 as2
 872 eq_ifaceExpr env (IfaceLam b1 body1)  (IfaceLam b2 body2)  = eq_ifBndr env b1 b2 (\env -> eq_ifaceExpr env body1 body2)
 873 eq_ifaceExpr env (IfaceApp f1 a1)     (IfaceApp f2 a2)     = eq_ifaceExpr env f1 f2 &&& eq_ifaceExpr env a1 a2
 874 eq_ifaceExpr env (IfaceNote n1 r1)    (IfaceNote n2 r2)    = eq_ifaceNote env n1 n2 &&& eq_ifaceExpr env r1 r2
 875
 876 eq_ifaceExpr env (IfaceCase s1 b1 ty1 as1) (IfaceCase s2 b2 ty2 as2)
 877   = eq_ifaceExpr env s1 s2 &&&
 878     eq_ifType env ty1 ty2 &&&
 879     eq_ifNakedBndr env b1 b2 (\env -> eqListBy (eq_ifaceAlt env) as1 as2)
 880   where
 881     eq_ifaceAlt env (c1,bs1,r1) (c2,bs2,r2)
 882         = bool (eq_ifaceConAlt c1 c2) &&&
 883           eq_ifNakedBndrs env bs1 bs2 (\env -> eq_ifaceExpr env r1 r2)
 884
 885 eq_ifaceExpr env (IfaceLet (IfaceNonRec b1 r1) x1) (IfaceLet (IfaceNonRec b2 r2) x2)
 886   = eq_ifaceExpr env r1 r2 &&& eq_ifIdBndr env b1 b2 (\env -> eq_ifaceExpr env x1 x2)
 887
 888 eq_ifaceExpr env (IfaceLet (IfaceRec as1) x1) (IfaceLet (IfaceRec as2) x2)
 889   = eq_ifIdBndrs env bs1 bs2 (\env -> eqListBy (eq_ifaceExpr env) rs1 rs2 &&& eq_ifaceExpr env x1 x2)
 890   where
 891     (bs1,rs1) = unzip as1
 892     (bs2,rs2) = unzip as2
 893
 894
 895 eq_ifaceExpr env _ _ = NotEqual
 896
 897 -----------------
 898 eq_ifaceConAlt :: IfaceConAlt -> IfaceConAlt -> Bool
 899 eq_ifaceConAlt IfaceDefault       IfaceDefault          = True
 900 eq_ifaceConAlt (IfaceDataAlt n1)  (IfaceDataAlt n2)     = n1==n2
 901 eq_ifaceConAlt (IfaceTupleAlt c1) (IfaceTupleAlt c2)    = c1==c2
 902 eq_ifaceConAlt (IfaceLitAlt l1)   (IfaceLitAlt l2)      = l1==l2
 903 eq_ifaceConAlt _ _ = False
 904
 905 -----------------
 906 eq_ifaceNote :: EqEnv -> IfaceNote -> IfaceNote -> IfaceEq
 907 eq_ifaceNote env (IfaceSCC c1)    (IfaceSCC c2)        = bool (c1==c2)
 908 eq_ifaceNote env (IfaceCoerce t1) (IfaceCoerce t2)     = eq_ifType env t1 t2
 909 eq_ifaceNote env IfaceInlineCall  IfaceInlineCall      = Equal
 910 eq_ifaceNote env IfaceInlineMe    IfaceInlineMe        = Equal
 911 eq_ifaceNote env (IfaceCoreNote s1) (IfaceCoreNote s2) = bool (s1==s2)
 912 eq_ifaceNote env _ _ = NotEqual
 913 \end{code}
 914
 915 \begin{code}
 916 ---------------------
 917 eqIfType t1 t2 = eq_ifType emptyEqEnv t1 t2
 918
 919 -------------------
 920 eq_ifType env (IfaceTyVar n1)         (IfaceTyVar n2)         = eqIfOcc env n1 n2
 921 eq_ifType env (IfaceAppTy s1 t1)      (IfaceAppTy s2 t2)      = eq_ifType env s1 s2 &&& eq_ifType env t1 t2
 922 eq_ifType env (IfacePredTy st1)       (IfacePredTy st2)       = eq_ifPredType env st1 st2
 923 eq_ifType env (IfaceTyConApp tc1 ts1) (IfaceTyConApp tc2 ts2) = tc1 `eqIfTc` tc2 &&& eq_ifTypes env ts1 ts2
 924 eq_ifType env (IfaceForAllTy tv1 t1)  (IfaceForAllTy tv2 t2)  = eq_ifTvBndr env tv1 tv2 (\env -> eq_ifType env t1 t2)
 925 eq_ifType env (IfaceFunTy s1 t1)      (IfaceFunTy s2 t2)      = eq_ifType env s1 s2 &&& eq_ifType env t1 t2
 926 eq_ifType env _ _ = NotEqual
 927
 928 -------------------
 929 eq_ifTypes env = eqListBy (eq_ifType env)
 930
 931 -------------------
 932 eq_ifContext env a b = eqListBy (eq_ifPredType env) a b
 933
 934 -------------------
 935 eq_ifPredType env (IfaceClassP c1 tys1) (IfaceClassP c2 tys2) = c1 `eqIfExt` c2 &&&  eq_ifTypes env tys1 tys2
 936 eq_ifPredType env (IfaceIParam n1 ty1) (IfaceIParam n2 ty2)   = bool (n1 == n2) &&& eq_ifType env ty1 ty2
 937 eq_ifPredType env _ _ = NotEqual
 938
 939 -------------------
 940 eqIfTc (IfaceTc tc1) (IfaceTc tc2) = tc1 `eqIfExt` tc2
 941 eqIfTc IfaceIntTc    IfaceIntTc    = Equal
 942 eqIfTc IfaceCharTc   IfaceCharTc   = Equal
 943 eqIfTc IfaceBoolTc   IfaceBoolTc   = Equal
 944 eqIfTc IfaceListTc   IfaceListTc   = Equal
 945 eqIfTc IfacePArrTc   IfacePArrTc   = Equal
 946 eqIfTc (IfaceTupTc bx1 ar1) (IfaceTupTc bx2 ar2) = bool (bx1==bx2 && ar1==ar2)
 947 eqIfTc _ _ = NotEqual
 948 \end{code}
 949
 950 -----------------------------------------------------------
 951         Support code for equality checking
 952 -----------------------------------------------------------
 953
 954 \begin{code}
 955 ------------------------------------
 956 type EqEnv = OccEnv OccName     -- Tracks the mapping from L-variables to R-variables
 957
 958 eqIfOcc :: EqEnv -> OccName -> OccName -> IfaceEq
 959 eqIfOcc env n1 n2 = case lookupOccEnv env n1 of
 960                         Just n1 -> bool (n1 == n2)
 961                         Nothing -> bool (n1 == n2)
 962
 963 extendEqEnv :: EqEnv -> OccName -> OccName -> EqEnv
 964 extendEqEnv env n1 n2 | n1 == n2  = env
 965                       | otherwise = extendOccEnv env n1 n2
 966
 967 emptyEqEnv :: EqEnv
 968 emptyEqEnv = emptyOccEnv
 969
 970 ------------------------------------
 971 type ExtEnv bndr = EqEnv -> bndr -> bndr -> (EqEnv -> IfaceEq) -> IfaceEq
 972
 973 eq_ifNakedBndr :: ExtEnv OccName
 974 eq_ifBndr      :: ExtEnv IfaceBndr
 975 eq_ifTvBndr    :: ExtEnv IfaceTvBndr
 976 eq_ifIdBndr    :: ExtEnv IfaceIdBndr
 977
 978 eq_ifNakedBndr env n1 n2 k = k (extendEqEnv env n1 n2)
 979
 980 eq_ifBndr env (IfaceIdBndr b1) (IfaceIdBndr b2) k = eq_ifIdBndr env b1 b2 k
 981 eq_ifBndr env (IfaceTvBndr b1) (IfaceTvBndr b2) k = eq_ifTvBndr env b1 b2 k
 982 eq_ifBndr _ _ _ _ = NotEqual
 983
 984 eq_ifTvBndr env (v1, k1) (v2, k2) k = bool (k1 == k2)     &&& k (extendEqEnv env v1 v2)
 985 eq_ifIdBndr env (v1, t1) (v2, t2) k = eq_ifType env t1 t2 &&& k (extendEqEnv env v1 v2)
 986
 987 eq_ifBndrs      :: ExtEnv [IfaceBndr]
 988 eq_ifIdBndrs    :: ExtEnv [IfaceIdBndr]
 989 eq_ifTvBndrs    :: ExtEnv [IfaceTvBndr]
 990 eq_ifNakedBndrs :: ExtEnv [OccName]
 991 eq_ifBndrs      = eq_bndrs_with eq_ifBndr
 992 eq_ifIdBndrs    = eq_bndrs_with eq_ifIdBndr
 993 eq_ifTvBndrs    = eq_bndrs_with eq_ifTvBndr
 994 eq_ifNakedBndrs = eq_bndrs_with eq_ifNakedBndr
 995
 996 eq_bndrs_with eq env []       []       k = k env
 997 eq_bndrs_with eq env (b1:bs1) (b2:bs2) k = eq env b1 b2 (\env -> eq_bndrs_with eq env bs1 bs2 k)
 998 eq_bndrs_with eq env _        _        _ = NotEqual
 999 \end{code}
1000
1001 \begin{code}
1002 eqListBy :: (a->a->IfaceEq) -> [a] -> [a] -> IfaceEq
1003 eqListBy eq []     []     = Equal
1004 eqListBy eq (x:xs) (y:ys) = eq x y &&& eqListBy eq xs ys
1005 eqListBy eq xs     ys     = NotEqual
1006
1007 eqMaybeBy :: (a->a->IfaceEq) -> Maybe a -> Maybe a -> IfaceEq
1008 eqMaybeBy eq Nothing Nothing   = Equal
1009 eqMaybeBy eq (Just x) (Just y) = eq x y
1010 eqMaybeBy eq x        y        = NotEqual
1011 \end{code}