compiler/iface/IfaceSyn.lhs

   1 %
   2 % (c) The University of Glasgow 2006
   3 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
   4 %
   5
   6 \begin{code}
   7 module IfaceSyn (
   8         module IfaceType,               -- Re-export all this
   9
  10         IfaceDecl(..), IfaceClassOp(..), IfaceConDecl(..), IfaceConDecls(..),
  11         IfaceExpr(..), IfaceAlt, IfaceNote(..),
  12         IfaceBinding(..), IfaceConAlt(..), IfaceIdInfo(..),
  13         IfaceInfoItem(..), IfaceRule(..), IfaceInst(..), IfaceFamInst(..),
  14
  15         -- Misc
  16         ifaceDeclSubBndrs, visibleIfConDecls,
  17
  18         -- Equality
  19         GenIfaceEq(..), IfaceEq, (&&&), bool, eqListBy, eqMaybeBy,
  20         eqIfDecl, eqIfInst, eqIfRule, checkBootDecl,
  21
  22         -- Pretty printing
  23         pprIfaceExpr, pprIfaceDeclHead
  24     ) where
  25
  26 #include "HsVersions.h"
  27
  28 import CoreSyn
  29 import IfaceType
  30
  31 import NewDemand
  32 import Class
  33 import UniqFM
  34 import Unique
  35 import NameSet
  36 import Name
  37 import CostCentre
  38 import Literal
  39 import ForeignCall
  40 import SrcLoc
  41 import BasicTypes
  42 import Outputable
  43 import FastString
  44
  45 import Data.List
  46 import Data.Maybe
  47
  48 infixl 3 &&&
  49 infix  4 `eqIfExt`, `eqIfIdInfo`, `eqIfType`
  50 \end{code}
  51
  52
  53 %************************************************************************
  54 %*                                                                      *
  55                 Data type declarations
  56 %*                                                                      *
  57 %************************************************************************
  58
  59 \begin{code}
  60 data IfaceDecl
  61   = IfaceId { ifName   :: OccName,
  62               ifType   :: IfaceType,
  63               ifIdInfo :: IfaceIdInfo }
  64
  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
  71                                                 -- GADT syntax
  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
  77                                                 -- been compiled with
  78                                                 -- different flags to the
  79                                                 -- current compilation unit
  80                 ifFamInst    :: Maybe (IfaceTyCon, [IfaceType])
  81                                                 -- Just <=> instance of family
  82     }
  83
  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
  89                                                 -- open family
  90     }
  91
  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?
  99     }
 100
 101   | IfaceForeign { ifName :: OccName,           -- Needs expanding when we move
 102                                                 -- beyond .NET
 103                    ifExtName :: Maybe FastString }
 104
 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
 109
 110 data IfaceConDecls
 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
 116
 117 visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
 118 visibleIfConDecls IfAbstractTyCon  = []
 119 visibleIfConDecls IfOpenDataTyCon  = []
 120 visibleIfConDecls IfOpenNewTyCon   = []
 121 visibleIfConDecls (IfDataTyCon cs) = cs
 122 visibleIfConDecls (IfNewTyCon c)   = [c]
 123
 124 data IfaceConDecl
 125   = IfCon {
 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
 136
 137 data IfaceInst
 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
 149
 150 data IfaceFamInst
 151   = IfaceFamInst { ifFamInstFam   :: Name                -- Family tycon
 152                  , ifFamInstTys   :: [Maybe IfaceTyCon]  -- Rough match types
 153                  , ifFamInstTyCon :: IfaceTyCon          -- Instance decl
 154                  }
 155
 156 data IfaceRule
 157   = IfaceRule {
 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
 165     }
 166
 167 data IfaceIdInfo
 168   = NoInfo                      -- When writing interface file without -O
 169   | HasInfo [IfaceInfoItem]     -- Has info, and here it is
 170
 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.
 180
 181 data IfaceInfoItem
 182   = HsArity      Arity
 183   | HsStrictness StrictSig
 184   | HsInline     Activation
 185   | HsUnfold     IfaceExpr
 186   | HsNoCafRefs
 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.
 193
 194 --------------------------------
 195 data IfaceExpr
 196   = IfaceLcl    FastString
 197   | IfaceExt    Name
 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
 206   | IfaceLit    Literal
 207   | IfaceFCall  ForeignCall IfaceType
 208
 209 data IfaceNote = IfaceSCC CostCentre
 210                | IfaceInlineMe
 211                | IfaceCoreNote String
 212
 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
 217
 218 data IfaceConAlt = IfaceDefault
 219                  | IfaceDataAlt Name
 220                  | IfaceTupleAlt Boxity
 221                  | IfaceLitAlt Literal
 222
 223 data IfaceBinding
 224   = IfaceNonRec IfaceIdBndr IfaceExpr
 225   | IfaceRec    [(IfaceIdBndr, IfaceExpr)]
 226
 227 -- -----------------------------------------------------------------------------
 228 -- Utils on IfaceSyn
 229
 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
 234
 235 ifaceDeclSubBndrs (IfaceClass {ifCtxt = sc_ctxt, ifName = cls_occ,
 236                                ifSigs = sigs, ifATs = ats })
 237   = co_occs ++
 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]]
 242   where
 243     n_ctxt = length sc_ctxt
 244     n_sigs = length sigs
 245     tc_occ  = mkClassTyConOcc cls_occ
 246     dc_occ  = mkClassDataConOcc cls_occ
 247     co_occs | is_newtype = [mkNewTyCoOcc tc_occ]
 248             | otherwise  = []
 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
 252
 253 ifaceDeclSubBndrs IfaceData {ifCons = IfAbstractTyCon}
 254   = []
 255 -- Newtype
 256 ifaceDeclSubBndrs (IfaceData {ifName = tc_occ,
 257                               ifCons = IfNewTyCon (
 258                                          IfCon { ifConOcc = con_occ,
 259                                                            ifConFields = fields
 260                                                          }),
 261                               ifFamInst = famInst})
 262   = fields ++ [con_occ, mkDataConWorkerOcc con_occ, mkNewTyCoOcc tc_occ]
 263     ++ famInstCo famInst tc_occ
 264
 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
 271   where
 272     dc_occs con_decl
 273         | has_wrapper = [con_occ, work_occ, wrap_occ]
 274         | otherwise   = [con_occ, work_occ]
 275         where
 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)
 282                         || isJust famInst
 283                 -- ToDo: may miss strictness in existential dicts
 284
 285 ifaceDeclSubBndrs _other = []
 286
 287 -- coercion for data/newtype family instances
 288 famInstCo Nothing  baseOcc = []
 289 famInstCo (Just _) baseOcc = [mkInstTyCoOcc baseOcc]
 290
 291 ----------------------------- Printing IfaceDecl ------------------------------
 292
 293 instance Outputable IfaceDecl where
 294   ppr = pprIfaceDecl
 295
 296 pprIfaceDecl (IfaceId {ifName = var, ifType = ty, ifIdInfo = info})
 297   = sep [ ppr var <+> dcolon <+> ppr ty,
 298           nest 2 (ppr info) ]
 299
 300 pprIfaceDecl (IfaceForeign {ifName = tycon})
 301   = hsep [ptext SLIT("foreign import type dotnet"), ppr tycon]
 302
 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)
 307
 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)
 312
 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])
 319   where
 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")
 326
 327 pprIfaceDecl (IfaceClass {ifCtxt = context, ifName = clas, ifTyVars = tyvars,
 328                           ifFDs = fds, ifATs = ats, ifSigs = sigs,
 329                           ifRec = isrec})
 330   = hang (ptext SLIT("class") <+> pprIfaceDeclHead context clas tyvars <+> pprFundeps fds)
 331        4 (vcat [pprRec isrec,
 332                 sep (map ppr ats),
 333                 sep (map ppr sigs)])
 334
 335 pprRec isrec = ptext SLIT("RecFlag") <+> ppr isrec
 336 pprGen True  = ptext SLIT("Generics: yes")
 337 pprGen False = ptext SLIT("Generics: no")
 338
 339 pprFamily Nothing        = ptext SLIT("FamilyInstance: none")
 340 pprFamily (Just famInst) = ptext SLIT("FamilyInstance:") <+> ppr famInst
 341
 342 instance Outputable IfaceClassOp where
 343    ppr (IfaceClassOp n dm ty) = ppr n <+> ppr dm <+> dcolon <+> ppr ty
 344
 345 pprIfaceDeclHead :: IfaceContext -> OccName -> [IfaceTvBndr] -> SDoc
 346 pprIfaceDeclHead context thing tyvars
 347   = hsep [pprIfaceContext context, parenSymOcc thing (ppr thing),
 348           pprIfaceTvBndrs tyvars]
 349
 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))
 356
 357 pprIfaceConDecl tc
 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 })
 362   = sep [main_payload,
 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))]
 368   where
 369     main_payload = ppr name <+> dcolon <+>
 370                    pprIfaceForAllPart (univ_tvs ++ ex_tvs) (eq_ctxt ++ ctxt) (ppr con_tau)
 371
 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
 379
 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])
 387       ]
 388
 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)
 395
 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)
 402
 403 ppr_rough :: Maybe IfaceTyCon -> SDoc
 404 ppr_rough Nothing   = dot
 405 ppr_rough (Just tc) = ppr tc
 406 \end{code}
 407
 408
 409 ----------------------------- Printing IfaceExpr ------------------------------------
 410
 411 \begin{code}
 412 instance Outputable IfaceExpr where
 413     ppr e = pprIfaceExpr noParens e
 414
 415 pprIfaceExpr :: (SDoc -> SDoc) -> IfaceExpr -> SDoc
 416         -- The function adds parens in context that need
 417         -- an atomic value (e.g. function args)
 418
 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
 424
 425 pprIfaceExpr add_par app@(IfaceApp _ _) = add_par (pprIfaceApp app [])
 426 pprIfaceExpr add_par (IfaceTuple c as)  = tupleParens c (interpp'SP as)
 427
 428 pprIfaceExpr add_par e@(IfaceLam _ _)
 429   = add_par (sep [char '\\' <+> sep (map ppr bndrs) <+> arrow,
 430                   pprIfaceExpr noParens body])
 431   where
 432     (bndrs,body) = collect [] e
 433     collect bs (IfaceLam b e) = collect (b:bs) e
 434     collect bs e              = (reverse bs, e)
 435
 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 '}'])
 441
 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 '}'])
 447
 448 pprIfaceExpr add_par (IfaceCast expr co)
 449   = sep [pprIfaceExpr parens expr,
 450          nest 2 (ptext SLIT("`cast`")),
 451          pprParendIfaceType co]
 452
 453 pprIfaceExpr add_par (IfaceLet (IfaceNonRec b rhs) body)
 454   = add_par (sep [ptext SLIT("let {"),
 455                   nest 2 (ppr_bind (b, rhs)),
 456                   ptext SLIT("} in"),
 457                   pprIfaceExpr noParens body])
 458
 459 pprIfaceExpr add_par (IfaceLet (IfaceRec pairs) body)
 460   = add_par (sep [ptext SLIT("letrec {"),
 461                   nest 2 (sep (map ppr_bind pairs)),
 462                   ptext SLIT("} in"),
 463                   pprIfaceExpr noParens body])
 464
 465 pprIfaceExpr add_par (IfaceNote note body) = add_par (ppr note <+> pprIfaceExpr parens body)
 466
 467 ppr_alt (con, bs, rhs) = sep [ppr_con_bs con bs,
 468                               arrow <+> pprIfaceExpr noParens rhs]
 469
 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)
 472
 473 ppr_bind ((b,ty),rhs) = sep [ppr b <+> dcolon <+> ppr ty,
 474                              equals <+> pprIfaceExpr noParens rhs]
 475
 476 ------------------
 477 pprIfaceApp (IfaceApp fun arg) args = pprIfaceApp fun (nest 2 (pprIfaceExpr parens arg) : args)
 478 pprIfaceApp fun                args = sep (pprIfaceExpr parens fun : args)
 479
 480 ------------------
 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)
 485
 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
 492
 493 ------------------
 494 instance Outputable IfaceIdInfo where
 495    ppr NoInfo       = empty
 496    ppr (HasInfo is) = ptext SLIT("{-") <+> fsep (map ppr_hs_info is) <+> ptext SLIT("-}")
 497
 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
 505 \end{code}
 506
 507
 508 %************************************************************************
 509 %*                                                                      *
 510         Equality, for interface file version generaion only
 511 %*                                                                      *
 512 %************************************************************************
 513
 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.
 518
 519 Of course, equality is also done modulo alpha conversion.
 520
 521 \begin{code}
 522 data GenIfaceEq a
 523   = Equal               -- Definitely exactly the same
 524   | NotEqual            -- Definitely different
 525   | EqBut a       -- The same provided these Names have not changed
 526
 527 type IfaceEq = GenIfaceEq NameSet
 528
 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)
 533
 534 bool :: Bool -> IfaceEq
 535 bool True  = Equal
 536 bool False = NotEqual
 537
 538 toBool :: IfaceEq -> Bool
 539 toBool Equal     = True
 540 toBool (EqBut _) = True
 541 toBool NotEqual  = False
 542
 543 zapEq :: IfaceEq -> IfaceEq     -- Used to forget EqBut information
 544 zapEq (EqBut _) = Equal
 545 zapEq other     = other
 546
 547 (&&&) :: IfaceEq -> IfaceEq -> IfaceEq
 548 Equal       &&& x           = x
 549 NotEqual    &&& x           = NotEqual
 550 EqBut nms   &&& Equal       = EqBut nms
 551 EqBut nms   &&& NotEqual    = NotEqual
 552 EqBut nms1  &&& EqBut nms2  = EqBut (nms1 `unionNameSets` nms2)
 553
 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
 558 eqIfExt name1 name2
 559   | name1 == name2 = EqBut (unitNameSet name1)
 560   | otherwise      = NotEqual
 561
 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)
 568
 569 checkBootDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
 570   = ASSERT (ifName d1 == ifName d2 ) ifExtName d1 == ifExtName d2
 571
 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)
 576
 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) &&&
 584         case ifCons d1 of
 585             IfAbstractTyCon -> Equal
 586             cons1           -> eq_hsCD env cons1 (ifCons d2)
 587
 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
 593              ([], [])      -> Equal
 594              (cxt1, sigs1) -> eq_ifContext env cxt1 (ifCtxt d2)  &&&
 595                               eqListBy (eq_cls_sig env) sigs1 (ifSigs d2)
 596
 597 checkBootDecl _ _ = False       -- default case
 598
 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)
 603
 604 eqIfDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
 605   = bool (ifName d1 == ifName d2 && ifExtName d1 == ifExtName d2)
 606
 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)
 616         )
 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
 620   where
 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
 625
 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)
 630         )
 631
 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)
 640        )
 641
 642 eqIfDecl _ _ = NotEqual -- default case
 643
 644 -- Helper
 645 eqWith :: [IfaceTvBndr] -> [IfaceTvBndr] -> (EqEnv -> IfaceEq) -> IfaceEq
 646 eqWith = eq_ifTvBndrs emptyEqEnv
 647
 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
 651
 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) &&&
 655          f1 `eqIfExt` f2 &&&
 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)
 660
 661 eq_hsCD env (IfDataTyCon c1) (IfDataTyCon c2)
 662   = eqListBy (eq_ConDecl env) c1 c2
 663
 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
 669
 670 eq_ConDecl env c1 c2
 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)))
 679
 680 eq_hsFD env (ns1,ms1) (ns2,ms2)
 681   = eqListBy (eqIfOcc env) ns1 ns2 &&& eqListBy (eqIfOcc env) ms1 ms2
 682
 683 eq_cls_sig env (IfaceClassOp n1 dm1 ty1) (IfaceClassOp n2 dm2 ty2)
 684   = bool (n1==n2 && dm1 == dm2) &&& eq_ifType env ty1 ty2
 685 \end{code}
 686
 687
 688 \begin{code}
 689 -----------------
 690 eqIfIdInfo NoInfo        NoInfo        = Equal
 691 eqIfIdInfo (HasInfo is1) (HasInfo is2) = eqListBy eq_item is1 is2
 692 eqIfIdInfo i1            i2 = NotEqual
 693
 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
 701
 702 -----------------
 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
 714
 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)
 719   where
 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)
 723
 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)
 726
 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)
 729   where
 730     (bs1,rs1) = unzip as1
 731     (bs2,rs2) = unzip as2
 732
 733
 734 eq_ifaceExpr env _ _ = NotEqual
 735
 736 -----------------
 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
 743
 744 -----------------
 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
 750 \end{code}
 751
 752 \begin{code}
 753 ---------------------
 754 eqIfType t1 t2 = eq_ifType emptyEqEnv t1 t2
 755
 756 -------------------
 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
 764
 765 -------------------
 766 eq_ifTypes env = eqListBy (eq_ifType env)
 767
 768 -------------------
 769 eq_ifContext env a b = eqListBy (eq_ifPredType env) a b
 770
 771 -------------------
 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
 775
 776 -------------------
 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
 790 \end{code}
 791
 792 -----------------------------------------------------------
 793         Support code for equality checking
 794 -----------------------------------------------------------
 795
 796 \begin{code}
 797 ------------------------------------
 798 type EqEnv = UniqFM FastString  -- Tracks the mapping from L-variables to R-variables
 799
 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)
 804
 805 extendEqEnv :: EqEnv -> FastString -> FastString -> EqEnv
 806 extendEqEnv env n1 n2 | n1 == n2  = env
 807                       | otherwise = addToUFM env n1 n2
 808
 809 emptyEqEnv :: EqEnv
 810 emptyEqEnv = emptyUFM
 811
 812 ------------------------------------
 813 type ExtEnv bndr = EqEnv -> bndr -> bndr -> (EqEnv -> IfaceEq) -> IfaceEq
 814
 815 eq_ifNakedBndr :: ExtEnv FastString
 816 eq_ifBndr      :: ExtEnv IfaceBndr
 817 eq_ifTvBndr    :: ExtEnv IfaceTvBndr
 818 eq_ifIdBndr    :: ExtEnv IfaceIdBndr
 819
 820 eq_ifNakedBndr env n1 n2 k = k (extendEqEnv env n1 n2)
 821
 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
 825
 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)
 828
 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
 837
 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
 841 \end{code}
 842
 843 \begin{code}
 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
 848
 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
 853 \end{code}