X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Frename%2FParseIface.y;h=f2882c3e4205e1a5851fd41ee7a7251c3d8a2198;hb=864ce5bdfa24cf352c466d6de8e9f938302d4253;hp=26a1fc00c4e47b770ed3c7dbedd1f49dbf37cba7;hpb=cae34044d89a87bd3da83b0e867b4a5d6994079a;p=ghc-hetmet.git diff --git a/ghc/compiler/rename/ParseIface.y b/ghc/compiler/rename/ParseIface.y index 26a1fc0..f2882c3 100644 --- a/ghc/compiler/rename/ParseIface.y +++ b/ghc/compiler/rename/ParseIface.y @@ -34,7 +34,7 @@ module ParseIface ( parseIface, IfaceStuff(..) ) where import HsSyn -- quite a bit of stuff import RdrHsSyn -- oodles of synonyms -import HsTypes ( mkHsForAllTy, mkHsUsForAllTy, mkHsTupCon ) +import HsTypes ( mkHsForAllTy, mkHsTupCon ) import HsCore import Demand ( mkStrictnessInfo ) import Literal ( Literal(..), mkMachInt, mkMachInt64, mkMachWord, mkMachWord64 ) @@ -43,27 +43,27 @@ import BasicTypes ( Fixity(..), FixityDirection(..), ) import CostCentre ( CostCentre(..), IsCafCC(..), IsDupdCC(..) ) import CallConv ( cCallConv ) -import HsPragmas ( noDataPragmas, noClassPragmas ) -import Type ( Kind, mkArrowKind, boxedTypeKind, openTypeKind, UsageAnn(..) ) -import IdInfo ( ArityInfo, exactArity, CprInfo(..), InlinePragInfo(..) ) +import Type ( Kind, mkArrowKind, boxedTypeKind, openTypeKind, usageTypeKind ) +import IdInfo ( exactArity, InlinePragInfo(..) ) import PrimOp ( CCall(..), CCallTarget(..) ) import Lex -import RnMonad ( ImportVersion, ParsedIface(..), WhatsImported(..), - RdrNamePragma, ExportItem, RdrAvailInfo, GenAvailInfo(..), - WhetherHasOrphans, IsBootInterface - ) -import RdrName ( RdrName, mkRdrUnqual, mkSysQual, mkSysUnqual, mkRdrNameWkr ) -import Name ( OccName, Provenance ) +import RnMonad ( ParsedIface(..), ExportItem, IfaceDeprecs ) +import HscTypes ( WhetherHasOrphans, IsBootInterface, GenAvailInfo(..), + ImportVersion, WhatsImported(..), + RdrAvailInfo ) + +import RdrName ( RdrName, mkRdrUnqual, mkIfaceOrig ) +import Name ( OccName ) import OccName ( mkSysOccFS, - tcName, varName, ipName, dataName, clsName, tvName, uvName, + tcName, varName, ipName, dataName, clsName, tvName, EncodedFS ) -import Module ( ModuleName, PackageName, mkSysModuleFS, mkModule ) +import Module ( ModuleName, PackageName, mkSysModuleNameFS, mkModule ) import SrcLoc ( SrcLoc ) -import CmdLineOpts ( opt_InPackage ) +import CmdLineOpts ( opt_InPackage, opt_IgnoreIfacePragmas ) import Outputable -import List ( insert ) +import Class ( DefMeth (..) ) import GlaExts import FastString ( tailFS ) @@ -135,7 +135,6 @@ import FastString ( tailFS ) '__sccC' { ITsccAllCafs } '__u' { ITusage } - '__fuall' { ITfuall } '__A' { ITarity } '__P' { ITspecialise } @@ -154,15 +153,14 @@ import FastString ( tailFS ) '<-' { ITlarrow } '->' { ITrarrow } '@' { ITat } - '~' { ITtilde } '=>' { ITdarrow } '-' { ITminus } '!' { ITbang } - '/\\' { ITbiglam } -- GHC-extension symbols - '{' { ITocurly } -- special symbols '}' { ITccurly } + '{|' { ITocurlybar } -- special symbols + '|}' { ITccurlybar } -- special symbols '[' { ITobrack } ']' { ITcbrack } '(' { IToparen } @@ -171,6 +169,7 @@ import FastString ( tailFS ) '#)' { ITcubxparen } ';' { ITsemi } ',' { ITcomma } + '.' { ITdot } VARID { ITvarid $$ } -- identifiers CONID { ITconid $$ } @@ -203,9 +202,7 @@ iface_stuff :: { IfaceStuff } iface_stuff : iface { PIface $1 } | type { PType $1 } | id_info { PIdInfo $1 } - | '__R' rules { PRules $2 } - | '__D' deprecs { PDeprecs $2 } - + | rules_and_deprecs { PRulesAndDeprecs $1 } iface :: { ParsedIface } iface : '__interface' package mod_name @@ -216,21 +213,21 @@ iface : '__interface' package mod_name fix_decl_part instance_decl_part decls_part - rules_and_deprecs + rules_and_deprecs_part { ParsedIface { pi_mod = mkModule $3 $2, -- Module itself pi_vers = $4, -- Module version pi_orphan = $6, - pi_exports = $9, -- Exports + pi_exports = (fst $5, $9), -- Exports pi_usages = $10, -- Usages - pi_fixity = (fst $5,$11), -- Fixies + pi_fixity = $11, -- Fixies pi_insts = $12, -- Local instances pi_decls = $13, -- Decls pi_rules = (snd $5,fst $14), -- Rules pi_deprecs = snd $14 -- Deprecations } } --- Versions for fixities and rules (optional) +-- Versions for exports and rules (optional) sub_versions :: { (Version,Version) } : '[' version version ']' { ($2,$3) } | {- empty -} { (initialVersion, initialVersion) } @@ -243,7 +240,7 @@ import_part : { [] } import_decl :: { ImportVersion OccName } import_decl : 'import' mod_name orphans is_boot whats_imported ';' - { (mkSysModuleFS $2, $3, $4, $5) } + { ({-mkSysModuleNameFS-} $2, $3, $4, $5) } orphans :: { WhetherHasOrphans } orphans : { False } @@ -256,7 +253,8 @@ is_boot : { False } whats_imported :: { WhatsImported OccName } whats_imported : { NothingAtAll } | '::' version { Everything $2 } - | '::' version version version name_version_pairs { Specifically $2 $3 $4 $5 } + | '::' version version version name_version_pairs { Specifically $2 (Just $3) $5 $4 } + | '::' version version name_version_pairs { Specifically $2 Nothing $4 $3 } name_version_pairs :: { [(OccName, Version)] } name_version_pairs : { [] } @@ -272,7 +270,7 @@ name_version_pair : var_occ version { ($1, $2) } exports_part :: { [ExportItem] } exports_part : { [] } | '__export' mod_name entities ';' - exports_part { (mkSysModuleFS $2, $3) : $5 } + exports_part { ({-mkSysModuleNameFS-} $2, $3) : $5 } entities :: { [RdrAvailInfo] } entities : { [] } @@ -282,11 +280,8 @@ entity :: { RdrAvailInfo } entity : var_occ { Avail $1 } | tc_occ { AvailTC $1 [$1] } | tc_occ '|' stuff_inside { AvailTC $1 $3 } - | tc_occ stuff_inside { AvailTC $1 (insert $1 $2) } - -- The 'insert' is important. The stuff_inside is sorted, and - -- insert keeps it that way. This is important when comparing - -- against the new interface file, which has the stuff in sorted order - -- If they differ, we'll bump the module number when it's unnecessary + | tc_occ stuff_inside { AvailTC $1 ($1:$2) } + -- Note that the "main name" comes at the beginning stuff_inside :: { [OccName] } stuff_inside : '{' val_occs '}' { $2 } @@ -332,8 +327,9 @@ csigs1 : { [] } | csig ';' csigs1 { $1 : $3 } csig :: { RdrNameSig } -csig : src_loc var_name '::' type { mkClassOpSig False $2 $4 $1 } - | src_loc var_name '=' '::' type { mkClassOpSig True $2 $5 $1 } +csig : src_loc qvar_name '::' type { ClassOpSig $2 NoDefMeth $4 $1 } + | src_loc qvar_name ';' '::' type { ClassOpSig $2 GenDefMeth $5 $1 } + | src_loc qvar_name '=' '::' type { mkClassOpSigDM $2 $5 $1 } -------------------------------------------------------------------------- @@ -342,7 +338,7 @@ instance_decl_part : {- empty -} { [] } | instance_decl_part inst_decl { $2 : $1 } inst_decl :: { RdrNameInstDecl } -inst_decl : src_loc 'instance' type '=' var_name ';' +inst_decl : src_loc 'instance' type '=' qvar_name ';' { InstDecl $3 EmptyMonoBinds {- No bindings -} [] {- No user pragmas -} @@ -352,32 +348,47 @@ inst_decl : src_loc 'instance' type '=' var_name ';' -------------------------------------------------------------------------- -decls_part :: { [(Version, RdrNameHsDecl)] } +decls_part :: { [(Version, RdrNameTyClDecl)] } decls_part : {- empty -} { [] } | opt_version decl ';' decls_part { ($1,$2):$4 } -decl :: { RdrNameHsDecl } -decl : src_loc var_name '::' type maybe_idinfo - { SigD (IfaceSig $2 $4 ($5 $2) $1) } - | src_loc 'type' tc_name tv_bndrs '=' type - { TyClD (TySynonym $3 $4 $6 $1) } - | src_loc 'data' opt_decl_context tc_name tv_bndrs constrs - { TyClD (TyData DataType $3 $4 $5 $6 (length $6) Nothing noDataPragmas $1) } - | src_loc 'newtype' opt_decl_context tc_name tv_bndrs newtype_constr - { TyClD (TyData NewType $3 $4 $5 $6 1 Nothing noDataPragmas $1) } - | src_loc 'class' opt_decl_context tc_name tv_bndrs fds csigs - { TyClD (mkClassDecl $3 $4 $5 $6 $7 EmptyMonoBinds - noClassPragmas $1) } +decl :: { RdrNameTyClDecl } +decl : src_loc qvar_name '::' type maybe_idinfo + { IfaceSig $2 $4 ($5 $2) $1 } + | src_loc 'type' qtc_name tv_bndrs '=' type + { TySynonym $3 $4 $6 $1 } + | src_loc 'data' opt_decl_context qtc_name tv_bndrs constrs + { mkTyData DataType $3 $4 $5 $6 (length $6) Nothing $1 } + | src_loc 'newtype' opt_decl_context qtc_name tv_bndrs newtype_constr + { mkTyData NewType $3 $4 $5 $6 1 Nothing $1 } + | src_loc 'class' opt_decl_context qtc_name tv_bndrs fds csigs + { mkClassDecl $3 $4 $5 $6 $7 Nothing $1 } maybe_idinfo :: { RdrName -> [HsIdInfo RdrName] } maybe_idinfo : {- empty -} { \_ -> [] } - | pragma { \x -> case $1 of - POk _ (PIdInfo id_info) -> id_info - PFailed err -> - pprPanic "IdInfo parse failed" - (vcat [ppr x, err]) + | pragma { \x -> if opt_IgnoreIfacePragmas then [] + else case $1 of + POk _ (PIdInfo id_info) -> id_info + PFailed err -> pprPanic "IdInfo parse failed" + (vcat [ppr x, err]) } + {- + If a signature decl is being loaded, and opt_IgnoreIfacePragmas is on, + we toss away unfolding information. + + Also, if the signature is loaded from a module we're importing from source, + we do the same. This is to avoid situations when compiling a pair of mutually + recursive modules, peering at unfolding info in the interface file of the other, + e.g., you compile A, it looks at B's interface file and may as a result change + its interface file. Hence, B is recompiled, maybe changing its interface file, + which will the unfolding info used in A to become invalid. Simple way out is to + just ignore unfolding info. + + [Jan 99: I junked the second test above. If we're importing from an hi-boot + file there isn't going to *be* any pragma info. The above comment + dates from a time where we picked up a .hi file first if it existed.] + -} pragma :: { ParseResult IfaceStuff } pragma : src_loc PRAGMA { parseIface $2 PState{ bol = 0#, atbol = 1#, @@ -388,26 +399,23 @@ pragma : src_loc PRAGMA { parseIface $2 PState{ bol = 0#, atbol = 1#, ----------------------------------------------------------------------------- -rules_and_deprecs :: { ([RdrNameRuleDecl], [RdrNameDeprecation]) } -rules_and_deprecs : {- empty -} { ([], []) } - | rules_and_deprecs rule_or_deprec - { let - append2 (xs1,ys1) (xs2,ys2) = - (xs1 `app` xs2, ys1 `app` ys2) - xs `app` [] = xs -- performance paranoia - xs `app` ys = xs ++ ys - in append2 $1 $2 - } +rules_and_deprecs_part :: { ([RdrNameRuleDecl], IfaceDeprecs) } +rules_and_deprecs_part : {- empty -} { ([], Nothing) } + | pragma { case $1 of + POk _ (PRulesAndDeprecs rds) -> rds + PFailed err -> pprPanic "Rules/Deprecations parse failed" err + } -rule_or_deprec :: { ([RdrNameRuleDecl], [RdrNameDeprecation]) } -rule_or_deprec : pragma { case $1 of - POk _ (PRules rules) -> (rules,[]) - POk _ (PDeprecs deprecs) -> ([],deprecs) - PFailed err -> pprPanic "Rules/Deprecations parse failed" err - } +rules_and_deprecs :: { ([RdrNameRuleDecl], IfaceDeprecs) } +rules_and_deprecs : rule_prag deprec_prag { ($1, $2) } + ----------------------------------------------------------------------------- +rule_prag :: { [RdrNameRuleDecl] } +rule_prag : {- empty -} { [] } + | '__R' rules { $2 } + rules :: { [RdrNameRuleDecl] } : {- empty -} { [] } | rule ';' rules { $1:$3 } @@ -421,18 +429,24 @@ rule_forall : '__forall' '{' core_bndrs '}' { $3 } ----------------------------------------------------------------------------- -deprecs :: { [RdrNameDeprecation] } -deprecs : {- empty -} { [] } - | deprec ';' deprecs { $1 : $3 } +deprec_prag :: { IfaceDeprecs } +deprec_prag : {- empty -} { Nothing } + | '__D' deprecs { Just $2 } + +deprecs :: { Either DeprecTxt [(RdrName,DeprecTxt)] } +deprecs : STRING { Left $1 } + | deprec_list { Right $1 } + +deprec_list :: { [(RdrName,DeprecTxt)] } +deprec_list : deprec { [$1] } + | deprec ';' deprec_list { $1 : $3 } -deprec :: { RdrNameDeprecation } -deprec : src_loc STRING { Deprecation (IEModuleContents undefined) $2 $1 } - | src_loc deprec_name STRING { Deprecation $2 $3 $1 } +deprec :: { (RdrName,DeprecTxt) } +deprec : deprec_name STRING { ($1, $2) } --- SUP: TEMPORARY HACK -deprec_name :: { RdrNameIE } - : var_name { IEVar $1 } - | data_name { IEThingAbs $1 } +deprec_name :: { RdrName } + : qvar_name { $1 } + | qtc_name { $1 } ----------------------------------------------------------------------------- @@ -458,13 +472,13 @@ constrs1 : constr { [$1] } | constr '|' constrs1 { $1 : $3 } constr :: { RdrNameConDecl } -constr : src_loc ex_stuff data_name batypes { mk_con_decl $3 $2 (VanillaCon $4) $1 } - | src_loc ex_stuff data_name '{' fields1 '}' { mk_con_decl $3 $2 (RecCon $5) $1 } +constr : src_loc ex_stuff qdata_name batypes { mk_con_decl $3 $2 (VanillaCon $4) $1 } + | src_loc ex_stuff qdata_name '{' fields1 '}' { mk_con_decl $3 $2 (RecCon $5) $1 } -- We use "data_fs" so as to include () newtype_constr :: { [RdrNameConDecl] {- Not allowed to be empty -} } -newtype_constr : src_loc '=' ex_stuff data_name atype { [mk_con_decl $4 $3 (VanillaCon [Unbanged $5]) $1] } - | src_loc '=' ex_stuff data_name '{' var_name '::' atype '}' +newtype_constr : src_loc '=' ex_stuff qdata_name atype { [mk_con_decl $4 $3 (VanillaCon [Unbanged $5]) $1] } + | src_loc '=' ex_stuff qdata_name '{' qvar_name '::' atype '}' { [mk_con_decl $4 $3 (RecCon [([$6], Unbanged $8)]) $1] } ex_stuff :: { ([HsTyVarBndr RdrName], RdrNameContext) } @@ -476,30 +490,27 @@ batypes : { [] } | batype batypes { $1 : $2 } batype :: { RdrNameBangType } -batype : atype { Unbanged $1 } - | '!' atype { Banged $2 } - | '!' '!' atype { Unpacked $3 } +batype : tatype { Unbanged $1 } + | '!' tatype { Banged $2 } + | '!' '!' tatype { Unpacked $3 } fields1 :: { [([RdrName], RdrNameBangType)] } fields1 : field { [$1] } | field ',' fields1 { $1 : $3 } field :: { ([RdrName], RdrNameBangType) } -field : var_names1 '::' type { ($1, Unbanged $3) } - | var_names1 '::' '!' type { ($1, Banged $4) } - | var_names1 '::' '!' '!' type { ($1, Unpacked $5) } +field : qvar_names1 '::' ttype { ($1, Unbanged $3) } + | qvar_names1 '::' '!' ttype { ($1, Banged $4) } + | qvar_names1 '::' '!' '!' ttype { ($1, Unpacked $5) } + -------------------------------------------------------------------------- type :: { RdrNameHsType } -type : '__fuall' fuall '=>' type { mkHsUsForAllTy $2 $4 } - | '__forall' tv_bndrs +type : '__forall' tv_bndrs opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 } | btype '->' type { HsFunTy $1 $3 } | btype { $1 } -fuall :: { [RdrName] } -fuall : '[' uv_bndrs ']' { $2 } - opt_context :: { RdrNameContext } opt_context : { [] } | context { $1 } @@ -528,16 +539,13 @@ types2 : type ',' type { [$1,$3] } btype :: { RdrNameHsType } btype : atype { $1 } | btype atype { HsAppTy $1 $2 } - | '__u' usage atype { HsUsgTy $2 $3 } - -usage :: { HsUsageAnn RdrName } -usage : '-' { HsUsOnce } - | '!' { HsUsMany } - | uv_name { HsUsVar $1 } + | '__u' atype atype { HsUsageTy $2 $3 } atype :: { RdrNameHsType } atype : qtc_name { HsTyVar $1 } | tv_name { HsTyVar $1 } + | '.' { hsUsOnce } + | '!' { hsUsMany } | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] } | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 } | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 } @@ -549,7 +557,34 @@ atype : qtc_name { HsTyVar $1 } atypes :: { [RdrNameHsType] {- Zero or more -} } atypes : { [] } | atype atypes { $1 : $2 } +-------------------------------------------------------------------------- + +-- versions of type/btype/atype that cant begin with '!' (or '.') +-- for use where the kind is definitely known NOT to be '$' + +ttype :: { RdrNameHsType } +ttype : '__forall' tv_bndrs + opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 } + | tbtype '->' type { HsFunTy $1 $3 } + | tbtype { $1 } + +tbtype :: { RdrNameHsType } +tbtype : tatype { $1 } + | tbtype atype { HsAppTy $1 $2 } + | '__u' atype atype { HsUsageTy $2 $3 } + +tatype :: { RdrNameHsType } +tatype : qtc_name { HsTyVar $1 } + | tv_name { HsTyVar $1 } + | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] } + | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 } + | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 } + | '[' type ']' { HsListTy $2 } + | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 } + | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 } + | '(' type ')' { $2 } --------------------------------------------------------------------- + package :: { PackageName } : STRING { $1 } | {- empty -} { opt_InPackage } -- Useful for .hi-boot files, @@ -557,7 +592,7 @@ package :: { PackageName } -- Module loops are always within a package mod_name :: { ModuleName } - : CONID { mkSysModuleFS $1 } + : CONID { mkSysModuleNameFS $1 } --------------------------------------------------- @@ -589,10 +624,14 @@ var_name : var_occ { mkRdrUnqual $1 } qvar_name :: { RdrName } qvar_name : var_name { $1 } - | qvar_fs { mkSysQual varName $1 } + | qvar_fs { mkIfaceOrig varName $1 } ipvar_name :: { RdrName } - : IPVARID { mkSysUnqual ipName (tailFS $1) } + : IPVARID { mkRdrUnqual (mkSysOccFS ipName (tailFS $1)) } + +qvar_names1 :: { [RdrName] } +qvar_names1 : qvar_name { [$1] } + | qvar_name qvar_names1 { $1 : $2 } var_names :: { [RdrName] } var_names : { [] } @@ -623,60 +662,41 @@ data_name :: { RdrName } qdata_name :: { RdrName } qdata_name : data_name { $1 } - | qdata_fs { mkSysQual dataName $1 } + | qdata_fs { mkIfaceOrig dataName $1 } -qdata_names :: { [RdrName] } -qdata_names : { [] } - | qdata_name qdata_names { $1 : $2 } - var_or_data_name :: { RdrName } - : var_name { $1 } - | data_name { $1 } + : qvar_name { $1 } + | qdata_name { $1 } --------------------------------------------------- -tc_fs :: { EncodedFS } - : data_fs { $1 } - tc_occ :: { OccName } - : tc_fs { mkSysOccFS tcName $1 } + : data_fs { mkSysOccFS tcName $1 } tc_name :: { RdrName } : tc_occ { mkRdrUnqual $1 } qtc_name :: { RdrName } : tc_name { $1 } - | qdata_fs { mkSysQual tcName $1 } + | qdata_fs { mkIfaceOrig tcName $1 } --------------------------------------------------- cls_name :: { RdrName } - : data_fs { mkSysUnqual clsName $1 } + : data_fs { mkRdrUnqual (mkSysOccFS clsName $1) } qcls_name :: { RdrName } : cls_name { $1 } - | qdata_fs { mkSysQual clsName $1 } - ---------------------------------------------------- -uv_name :: { RdrName } - : VARID { mkSysUnqual uvName $1 } - -uv_bndr :: { RdrName } - : uv_name { $1 } - -uv_bndrs :: { [RdrName] } - : { [] } - | uv_bndr uv_bndrs { $1 : $2 } + | qdata_fs { mkIfaceOrig clsName $1 } --------------------------------------------------- tv_name :: { RdrName } - : VARID { mkSysUnqual tvName $1 } - | VARSYM { mkSysUnqual tvName $1 {- Allow t2 as a tyvar -} } + : VARID { mkRdrUnqual (mkSysOccFS tvName $1) } tv_bndr :: { HsTyVarBndr RdrName } : tv_name '::' akind { IfaceTyVar $1 $3 } | tv_name { IfaceTyVar $1 boxedTypeKind } tv_bndrs :: { [HsTyVarBndr RdrName] } -tv_bndrs : tv_bndrs1 { $1 } + : tv_bndrs1 { $1 } | '[' tv_bndrs1 ']' { $2 } -- Backward compatibility tv_bndrs1 :: { [HsTyVarBndr RdrName] } @@ -709,14 +729,16 @@ akind :: { Kind } boxedTypeKind else if $1 == SLIT("?") then openTypeKind - else panic "ParseInterface: akind" + else if $1 == SLIT("\36") then + usageTypeKind -- dollar + else panic "ParseInterface: akind" } | '(' kind ')' { $2 } -------------------------------------------------------------------------- id_info :: { [HsIdInfo RdrName] } - : { [] } + : id_info_item { [$1] } | id_info_item id_info { $1 : $2 } id_info_item :: { HsIdInfo RdrName } @@ -919,11 +941,10 @@ checkVersion :: { () } happyError :: P a happyError buf PState{ loc = loc } = PFailed (ifaceParseErr buf loc) -data IfaceStuff = PIface ParsedIface - | PIdInfo [HsIdInfo RdrName] - | PType RdrNameHsType - | PRules [RdrNameRuleDecl] - | PDeprecs [RdrNameDeprecation] +data IfaceStuff = PIface ParsedIface + | PIdInfo [HsIdInfo RdrName] + | PType RdrNameHsType + | PRulesAndDeprecs ([RdrNameRuleDecl], IfaceDeprecs) mk_con_decl name (ex_tvs, ex_ctxt) details loc = mkConDecl name ex_tvs ex_ctxt details loc }