X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Frename%2FParseIface.y;h=8cb756f91e97a576475c0be8d5afa777523479c5;hb=da162afcfc9db8335834bb279217c4707fb67988;hp=b9cfc8946b5c8b46a05413660f9cd61b651773d1;hpb=6c1d2ec4f8f08d77e39de6f79afa4143110901fa;p=ghc-hetmet.git diff --git a/ghc/compiler/rename/ParseIface.y b/ghc/compiler/rename/ParseIface.y index b9cfc89..8cb756f 100644 --- a/ghc/compiler/rename/ParseIface.y +++ b/ghc/compiler/rename/ParseIface.y @@ -43,18 +43,17 @@ import BasicTypes ( Fixity(..), FixityDirection(..), ) import CostCentre ( CostCentre(..), IsCafCC(..), IsDupdCC(..) ) import CallConv ( cCallConv ) -import HsPragmas ( noDataPragmas, noClassPragmas ) import Type ( Kind, mkArrowKind, boxedTypeKind, openTypeKind ) import IdInfo ( exactArity, InlinePragInfo(..) ) import PrimOp ( CCall(..), CCallTarget(..) ) import Lex -import RnMonad ( ParsedIface(..), ExportItem ) +import RnMonad ( ParsedIface(..), ExportItem, IfaceDeprecs ) import HscTypes ( WhetherHasOrphans, IsBootInterface, GenAvailInfo(..), ImportVersion, WhatsImported(..), RdrAvailInfo ) -import RdrName ( RdrName, mkRdrUnqual, mkSysQual, mkSysUnqual ) +import RdrName ( RdrName, mkRdrIfaceUnqual, mkIfaceOrig ) import Name ( OccName ) import OccName ( mkSysOccFS, tcName, varName, ipName, dataName, clsName, tvName, uvName, @@ -62,7 +61,7 @@ import OccName ( mkSysOccFS, ) 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 (..) ) @@ -207,9 +206,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 @@ -220,21 +217,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) } @@ -260,7 +257,7 @@ is_boot : { False } whats_imported :: { WhatsImported OccName } whats_imported : { NothingAtAll } | '::' version { Everything $2 } - | '::' version version name_version_pairs version { Specifically $2 (Just $3) $4 $5 } + | '::' version version version name_version_pairs { Specifically $2 (Just $3) $5 $4 } name_version_pairs :: { [(OccName, Version)] } name_version_pairs : { [] } @@ -358,32 +355,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 :: { RdrNameTyClDecl } decl : src_loc var_name '::' type maybe_idinfo - { SigD (IfaceSig $2 $4 ($5 $2) $1) } + { IfaceSig $2 $4 ($5 $2) $1 } | src_loc 'type' tc_name tv_bndrs '=' type - { TyClD (TySynonym $3 $4 $6 $1) } + { TySynonym $3 $4 $6 $1 } | src_loc 'data' opt_decl_context tc_name tv_bndrs constrs - { TyClD (mkTyData DataType $3 $4 $5 $6 (length $6) Nothing noDataPragmas $1) } + { mkTyData DataType $3 $4 $5 $6 (length $6) Nothing $1 } | src_loc 'newtype' opt_decl_context tc_name tv_bndrs newtype_constr - { TyClD (mkTyData NewType $3 $4 $5 $6 1 Nothing noDataPragmas $1) } + { mkTyData NewType $3 $4 $5 $6 1 Nothing $1 } | src_loc 'class' opt_decl_context tc_name tv_bndrs fds csigs - { TyClD (mkClassDecl $3 $4 $5 $6 $7 EmptyMonoBinds - noClassPragmas $1) } + { mkClassDecl $3 $4 $5 $6 $7 EmptyMonoBinds $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#, @@ -394,26 +406,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 } @@ -427,18 +436,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 } -deprec :: { RdrNameDeprecation } -deprec : src_loc STRING { Deprecation (IEModuleContents undefined) $2 $1 } - | src_loc deprec_name STRING { Deprecation $2 $3 $1 } +deprecs :: { Either DeprecTxt [(RdrName,DeprecTxt)] } +deprecs : STRING { Left $1 } + | deprec_list { Right $1 } --- SUP: TEMPORARY HACK -deprec_name :: { RdrNameIE } - : var_name { IEVar $1 } - | data_name { IEThingAbs $1 } +deprec_list :: { [(RdrName,DeprecTxt)] } +deprec_list : deprec { [$1] } + | deprec ';' deprec_list { $1 : $3 } + +deprec :: { (RdrName,DeprecTxt) } +deprec : deprec_name STRING { ($1, $2) } + +deprec_name :: { RdrName } + : var_name { $1 } + | tc_name { $1 } ----------------------------------------------------------------------------- @@ -591,14 +606,14 @@ var_occ :: { OccName } : var_fs { mkSysOccFS varName $1 } var_name :: { RdrName } -var_name : var_occ { mkRdrUnqual $1 } +var_name : var_occ { mkRdrIfaceUnqual $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 { mkRdrIfaceUnqual (mkSysOccFS ipName (tailFS $1)) } var_names :: { [RdrName] } var_names : { [] } @@ -625,45 +640,38 @@ data_occ :: { OccName } : data_fs { mkSysOccFS dataName $1 } data_name :: { RdrName } - : data_occ { mkRdrUnqual $1 } + : data_occ { mkRdrIfaceUnqual $1 } 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 } --------------------------------------------------- -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 } + : tc_occ { mkRdrIfaceUnqual $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 { mkRdrIfaceUnqual (mkSysOccFS clsName $1) } qcls_name :: { RdrName } : cls_name { $1 } - | qdata_fs { mkSysQual clsName $1 } + | qdata_fs { mkIfaceOrig clsName $1 } --------------------------------------------------- uv_name :: { RdrName } - : VARID { mkSysUnqual uvName $1 } + : VARID { mkRdrIfaceUnqual (mkSysOccFS uvName $1) } uv_bndr :: { RdrName } : uv_name { $1 } @@ -674,8 +682,8 @@ uv_bndrs :: { [RdrName] } --------------------------------------------------- tv_name :: { RdrName } - : VARID { mkSysUnqual tvName $1 } - | VARSYM { mkSysUnqual tvName $1 {- Allow t2 as a tyvar -} } + : VARID { mkRdrIfaceUnqual (mkSysOccFS tvName $1) } + | VARSYM { mkRdrIfaceUnqual (mkSysOccFS tvName $1) {- Allow t2 as a tyvar -} } tv_bndr :: { HsTyVarBndr RdrName } : tv_name '::' akind { IfaceTyVar $1 $3 } @@ -722,7 +730,7 @@ akind :: { Kind } -------------------------------------------------------------------------- id_info :: { [HsIdInfo RdrName] } - : { [] } + : id_info_item { [$1] } | id_info_item id_info { $1 : $2 } id_info_item :: { HsIdInfo RdrName } @@ -925,11 +933,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 }